How to load and save a picture faster when using this program?

[ascii]

So, below I have this little program, which is a kind of a graphic war. Or screensaver. First, it needs me to create a R:\Gwar.bmp 1920x1080 bitmap with 8 bit color depth (256 colors). But loading and saving the picture (when hitting Esc), is very slow. How can I speed that up?


CLS: DEFINT A-Z: DEFSNG N: DEFSTR F, S: DIM r(255), g(255), b(255)
v = 1920: w = 1080: SCREEN _NEWIMAGE(v, w, 256)
f = COMMAND$: IF f = "" THEN f = "r:\Gwar.bmp"
IF INSTR(f, "/") GOTO help ELSE IF INSTR(f, ".") = 0 THEN f = f + ".bmp"
IF NOT _FILEEXISTS(f) GOTO err1
OPEN f FOR RANDOM AS 1 LEN = 1: FIELD 1, 1 AS s: N = -1 'Read palette (55-1078)
FOR a = 55 TO 1075 STEP 4: N = N + 1: GET 1, a
r(N) = INT(ASC(s) / 4): GET 1, a + 1: g(N) = INT(ASC(s) / 4): GET 1, a + 2: b(N) = INT(ASC(s) / 4): NEXT
FOR a = 0 TO 255: PALETTE a, b(a) + 256 * g(a) + 65536 * r(a): NEXT: N = 1079 + v * w

'DRAW pic:
FOR a = 0 TO w - 1: N = N - v: FOR b = 0 TO v - 1: GET 1, N + b: PSET (b, a), ASC(s): NEXT: NEXT

WHILE INKEY$ <> CHR$(27)
  x = RND * (v - 1): y = RND * (w - 1): c = POINT(x, y) 'find a pixel and it's color. Next = war algorithm
  d = 3: PSET (x, y), c
  PSET (x, y - d), c
  PSET (x + d, y), c
  PSET (x, y + d), c
  PSET (x - d, y), c
  r1 = RND * 20 + 1: CIRCLE (x, y), r1, c
WEND

'SAVE pic:
save: N = 1079 + v * w: FOR a = 0 TO w - 1: N = N - v: FOR b = 0 TO v - 1: LSET s = CHR$(POINT(b, a)): PUT 1, N + b: NEXT

NEXT: PLAY "l16c": CLOSE: CLS: SYSTEM
err1: CLOSE: SCREEN 0: PRINT "r:\Gwar.bmp not found.": SLEEP: SYSTEM
help: CLOSE: SCREEN 0: PRINT "Graphwar x*y*256 bmp. Esc=Save. Command$ = filename.": SLEEP: SYSTEM

[bplus]

Welcome @ascii

I can't read that yellow text that starts your post but I assume you are looking to load images and save images from your title.

For loading an image check out
https://www.qb64.org/wiki/Images

general overview and
https://www.qb64.org/wiki/LOADIMAGE

particularly.


For SaveImage I recommend looking under Utilities Board
https://www.qb64.org/forum/index.php?topic=1651.msg108777#msg108777

for Steve McNeill's SaveImage routines which will link you to
https://www.qb64.org/forum/index.php?topic=2701.msg138667#msg138667

his most recent update of that code.

[RhoSigma]

Welcome @ascii
I can't read that yellow text that starts your post but I assume you are looking to load images nd save images from your title.

B+,
guess u are on the light SMF theme, me as well, simply mark the text as if you would do to copy it, it will become readable.

As most users (and definitly new users) are on the dark theme, we must probably live with bad readable text. We, still at the light theme, are a minority.

[bplus]

@RhoSigma Oh! thanks for tip, works perfect!

[Petr]

So, below I have this little program, which is a kind of a graphic war. Or screensaver. First, it needs me to create a R:\Gwar.bmp 1920x1080 bitmap with 8 bit color depth (256 colors). But loading and saving the picture (when hitting Esc), is very slow. How can I speed that up?


CLS: DEFINT A-Z: DEFSNG N: DEFSTR F, S: DIM r(255), g(255), b(255)
v = 1920: w = 1080: SCREEN _NEWIMAGE(v, w, 256)
f = COMMAND$: IF f = "" THEN f = "r:\Gwar.bmp"
IF INSTR(f, "/") GOTO help ELSE IF INSTR(f, ".") = 0 THEN f = f + ".bmp"
IF NOT _FILEEXISTS(f) GOTO err1
OPEN f FOR RANDOM AS 1 LEN = 1: FIELD 1, 1 AS s: N = -1 'Read palette (55-1078)
FOR a = 55 TO 1075 STEP 4: N = N + 1: GET 1, a
r(N) = INT(ASC(s) / 4): GET 1, a + 1: g(N) = INT(ASC(s) / 4): GET 1, a + 2: b(N) = INT(ASC(s) / 4): NEXT
FOR a = 0 TO 255: PALETTE a, b(a) + 256 * g(a) + 65536 * r(a): NEXT: N = 1079 + v * w

'DRAW pic:
FOR a = 0 TO w - 1: N = N - v: FOR b = 0 TO v - 1: GET 1, N + b: PSET (b, a), ASC(s): NEXT: NEXT

WHILE INKEY$ <> CHR$(27)
  x = RND * (v - 1): y = RND * (w - 1): c = POINT(x, y) 'find a pixel and it's color. Next = war algorithm
  d = 3: PSET (x, y), c
  PSET (x, y - d), c
  PSET (x + d, y), c
  PSET (x, y + d), c
  PSET (x - d, y), c
  r1 = RND * 20 + 1: CIRCLE (x, y), r1, c
WEND

'SAVE pic:
save: N = 1079 + v * w: FOR a = 0 TO w - 1: N = N - v: FOR b = 0 TO v - 1: LSET s = CHR$(POINT(b, a)): PUT 1, N + b: NEXT

NEXT: PLAY "l16c": CLOSE: CLS: SYSTEM
err1: CLOSE: SCREEN 0: PRINT "r:\Gwar.bmp not found.": SLEEP: SYSTEM
help: CLOSE: SCREEN 0: PRINT "Graphwar x*y*256 bmp. Esc=Save. Command$ = filename.": SLEEP: SYSTEM

There are many things you can do to speed it up. I'll take it gradually. To read or change the palette of an 8-bit image, we have the command and function _PALETTECOLOR. Use _MEMPUT instead of PSET, use _MEMGET instead of POINT. To save and load an image. Use the _LOADIMAGE function (bmp, jpg, png, gif) to load and use the SAVEIMAGE function (jpg, bmp, png, gif formats) to save it. SaveImage you can download from @SMcNeill signature.

Another thing - do you need to save those images immediately, or can you first generate a hundred images and then save them at once? They can be stored in memory (see the commands _DEST, _SOURCE, _NEWIMAGE, _FREEIMAGE) because any immediate storage on the hard disk is always slow (maybe it will be fast with the SSD disk or if the program runs in RAMDISK). With QB64 you have many options including direct memory access.

[bplus]

@ascii

I have taken Steve's SaveImage download .zip altered to add your code with mods to fit my screen and draw concentric circles at random places until escape and then saves the picture into a .bmp format after you press escape from the circle drawing loop.

It's all in a zip, the exe for Windows but always best compile source .bas yourself.

Do you know about BI's and BM's as applies to QB64? because Steve's code uses them for SaveImage work.

[SMcNeill]

For something simple like this, just do a quick screen grab.

DIM M AS _MEM: M = _MEMIMAGE(0)
Screengrab$ = SPACE$(M.SIZE)
_MEMGET M, M.OFFSET, Screengrab$

The above will:
Dim a mem block.  Point it to your screen's image.
Set a string that size.
Get the whole screen at once into that string.


Then to save to disk all at once:
OPEN "my_file.bin" FOR BINARY AS #1
PUT #1, , Screengrab$
CLOSE

Open the file, put the data in one chunk, close the file.



Loading is the same, in reverse:
OPEN "my_file.bin" FOR BINARY AS #1
GET #1, , Screengrab$
CLOSE


And putting the data back to screen is also done all in one command:
_MEMPUT M, M.OFFSET, Screengrab$


You'll be hard pressed to find any method faster than that.

[SMcNeill]

@ascii

I have taken Steve's SaveImage download .zip altered to add your code with mods to fit my screen and draw concentric circles at random places until escape and then saves the picture into a .bmp format after you press escape from the circle drawing loop.

It's all in a zip, the exe for Windows but always best compile source .bas yourself.

Do you know about BI's and BM's as applies to QB64? because Steve's code uses them for SaveImage work.

There's a problem with your approach @bplus:  Loading the image.

QB64 only _LOADIMAGEs 32-bit images.  The program is running and saving in 256-color mode.   You'll need to convert/dither down to 256 colors after loadimage loads your saved file in the wrong format, taking an unnecessary speed hit.

I'd just do a whole screen grab, save, and restore, as I posted above, for a 256 color screen.  (Unless I needed the images for an external program.)

[Petr]

Loading 8 bit images is solved here: https://www.qb64.org/forum/index.php?topic=3521.msg128456#msg128456

[bplus]

Yeah Steve yours works great! if you don't have the bin file ready yet or working from one of your own

after you fix your Typo!! ;-)) (in 3rd line in post above)

Code: QB64: [Select]

1.  
2. Scn& = _NewImage(800, 600, 32)
3. Screen Scn&
4. Circle (400, 300), 200
5. Print "Save this endangered circle!   zzz..."
6. Sleep
7.  
8. Dim M As _MEM: M = _MemImage(Scn&)
9.  
10. Screengrab$ = Space$(M.SIZE)
11.  
12. _MemGet M, M.OFFSET, Screengrab$
13.  
14. 'The above will:
15. 'Dim a mem block.  Point it to your screen's image.
16. 'Set a string that size.
17. 'Get the whole screen at once into that string.
18.  
19.  
20. 'Then to save to disk all at once:
21. Open "Test SaveLoad Image.bin" For Binary As #1
22. Put #1, , Screengrab$
23. Close
24.  
25. 'Open the file, put the data in one chunk, close the file.
26.  
27. Cls
28. Print "Press any to see circle again... "
29. Sleep
30.  
31. 'Loading is the same, in reverse:
32. Open "Test SaveLoad Image.bin" For Binary As #1
33. Get #1, , Screengrab$
34. Close
35.  
36.  
37. 'And putting the data back to screen is also done all in one command:
38. _MemPut M, M.OFFSET, Screengrab$
39.  
40.  

Is this faster than loadImage? It seems way more convenient for saving images!

[SMcNeill]

I haven't tried bplus's demo yet, but here's how I'd normally do this type of thing:

Code: QB64: [Select]

1. Cls: DefInt A-Z: DefSng N: DefStr F, S: Dim r(255), g(255), b(255)
2. v = 1920: w = 1080: Screen _NewImage(v, w, 256)
3. _ScreenMove 0, 0
4. Const DataSize = 1920 * 1080
5. Dim m As _MEM: m = _MemImage(0) 'make a mem block, point it at the screen
6. Dim ImageData As String * DataSize 'set a string large enough to hold the screen
7. Dim l As Long
8.  
9. Open "My Movie.movie" For Output As #1: Close #1 'make certain our file is blank starting out
10. Open "My Movie.movie" For Binary As #1 'open a file to get and put data to
11.  
12. Randomize Timer
13.  
14. 'let's draw to the screen
15. 'heck, let's save while we're doing it.
16.  
17. t# = Timer + 5 'I'm going to draw and save for 5 seconds uninterrupted.
18. Do
19.     CircleFill Rnd * _Width, Rnd * _Height, Rnd * 500, _RGB(Rnd * 255, Rnd * 255, Rnd * 255)
20.     _Display
21.     _Limit 300 ' Let's run with an insane 300 fps for a limit here.
22.     _MemGet m, m.OFFSET, ImageData
23.     compress$ = _Deflate$(ImageData): l = Len(compress$)
24.     full$ = full$ + MKL$(l) + compress$
25.     count = count + 1
26. Loop Until Timer > t#
27. Put #1, 1, full$ 'put our whole movie to disk in one pass.
28. Close #1
29.  
30.  
31. Sleep 'pause so the user can see the screen
32.  
33. Cls 'blank the screen just to start with a blank canvas
34. 'go back to the start of the file for image loading
35.  
36. Open "My Movie.movie" For Binary As #1 'open a file to get and put data to
37.  
38. t# = Timer
39. Do
40.     Get #1, , l
41.     If EOF(1) Then Exit Do
42.     compress$ = Space$(l) 'a string the size of the compressed data
43.     Get #1, , compress$
44.     ImageData = _Inflate$(compress$)
45.     _MemPut m, m.OFFSET, ImageData
46.     _Limit 300
47.     _Display
48.     recount = recount + 1
49. Loop
50. t1# = Timer - t#
51. Sleep
52.  
53. Cls
54. Print "In 5 seconds we drew, grabbed, compressed, and saved"; count; " images."
55. Print Using "In #.## seconds, we loaded, uncompressed, and redrew those same #### images."; t1#, recount
56.  
57. Close
58. Kill "My Movie.movie" 'clean up the drive of our "movie" after this demo is over.
59.  
60.  
61.  
62.  
63. Sub CircleFill (CX As Integer, CY As Integer, R As Integer, C As _Unsigned Long)
64.     ' CX = center x coordinate
65.     ' CY = center y coordinate
66.     '  R = radius
67.     '  C = fill color
68.     Dim Radius As Integer, RadiusError As Integer
69.     Dim X As Integer, Y As Integer
70.     Radius = Abs(R)
71.     RadiusError = -Radius
72.     X = Radius
73.     Y = 0
74.     If Radius = 0 Then PSet (CX, CY), C: Exit Sub
75.     Line (CX - X, CY)-(CX + X, CY), C, BF
76.     While X > Y
77.         RadiusError = RadiusError + Y * 2 + 1
78.         If RadiusError >= 0 Then
79.             If X <> Y + 1 Then
80.                 Line (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
81.                 Line (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
82.             End If
83.             X = X - 1
84.             RadiusError = RadiusError - X * 2
85.         End If
86.         Y = Y + 1
87.         Line (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
88.         Line (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
89.     Wend
90. End Sub
91.  

Now, on my PC this is set to run at a limit of 300 FPS. 

SPOILER ALERT -- We don't actually get those speeds from it!

What we're doing here is drawing random circles of various sizes, colors, and positions, on a large 1920x1080 screen. Then we're grabbing that screen, compressing it so it doesn't use so much disk space, and then saving it to the disk.

I'm letting this run for 5 seconds to create a movie for me, and the statistics I get on my laptop are:

198 screens grabbed and compressed, and then wrote to disk in a 5MB file after running for 5 seconds.

Loading and displaying of those same 198 screens only takes about 1.8 seconds on my laptop.

This gives us a savetime of about 0.025 seconds per screen, with a loadtime of about half that amount -- all while compressing the image to reduce disk usage as much as possible.

I'd call that an acceptable speed for my general usage needs.