Help needed with one or more _MEM commands

[Stuart]

Basically, the program I've been working on uses a SCREEN 0 text screen that is always a minimum of 80 characters x 50 lines, and could conceiveably be as large as 80 chars x 200 lines when using QB64.  The usual size is between 66 and 130 lines depending on the screen resolution, available desktop space and _FONT used.


Here's the problem : 

I'm currently using the code below to BSAVE a copy of a certain segment of the video memory for SCREEN 0 which has already been calculated using the 'offset' and 'length' variables.

Next, the subroutine at line 1400 resets the screen size to either a 50 line screen (using a different _FONT), or...  a more than 50 line screen.  The actual number of lines will vary as described above.

After the new SCREEN 0 text screen has been established at 1400 (using the WIDTH command), the new screen will be blank, so the BLOAD statement is used to write the previously saved screen data to the beginning segment of the new SCREEN 0 video memory at &HB800 and then the KILL command deletes the temporary file that was used.

Code: QB64: [Select]

1.            LN = CSRLIN
2.            offset = (LN - 48) * 160: length = LN * 160
3.            IF offset < 0 THEN offset = 0 ELSE LN = 48
4.            '
5.            DEF SEG = &HB800
6.            BSAVE "tmpscrn.tmp", offset, length
7.            GOSUB 1400
8.            BLOAD "tmpscrn.tmp", 0
9.            DEF SEG
10.            KILL "tmpscrn.tmp"
11.  

Everything works just like I want it to, but...  I don't really like having to save and then delete a file from disk each time the routine is used.

I'm pretty sure that one or more of the _MEM commands can be used to do all of this in QB64, but even after reading the info here :  https://www.qb64.org/articles/articlemem.txt I just can't figure out exactly how to go about doing it.  I'm thinking that the BSAVE and BLOAD lines just need to be replaced with the proper variant of _MEM such as _MEMIMAGE and/or _MEMCOPY or _MEMGET and _MEMPUT, but who knows?

Thanks in advance for any help that can be provided.

[luke]

If you're only changing the vertical height this isn't too hard:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(80, 25, 0)
2. FOR i = 1 TO 10
3.     PRINT STRING$(i, "*")
4.     COLOR i
5. NEXT i
6.  
7. character_count = _WIDTH * 10 'save 10 lines worth of characters
8.  
9. DIM m AS _MEM
10. DIM saved AS _MEM
11. m = _MEMIMAGE(0) '_mem reference to the display
12. saved = _MEMNEW(m.ELEMENTSIZE * _WIDTH * 10) 'buffer to save data in
13. _MEMCOPY m, m.OFFSET, m.ELEMENTSIZE * character_count TO saved, saved.OFFSET 'copy screen -> buffer
14. _MEMFREE m
15. SLEEP
16.  
17. SCREEN _NEWIMAGE(80, 30, 0)
18. m = _MEMIMAGE(0) 'we are now displaying a new screen, do get a new reference to it
19. _MEMCOPY saved, saved.OFFSET, m.ELEMENTSIZE * character_count TO m, m.OFFSET 'copy buffer -> screen
20.  
21. _MEMFREE saved
22. _MEMFREE m

But if you're changing the width (characters per line) or you only want to save part of a line it'll be a little more complicated because you're no longer dealing with a contiguous block of memory. At this point (or even before) consider if it isn't just easier to save the data to an array.

[SMcNeill]

And since it sounds like you just want to grab a segment of a screen, why don't you give these little routines a quick try:

Code: QB64: [Select]

1. SCREEN 0
2. REDIM Array(0) AS STRING
3.  
4. FOR i = 1 TO 25 'draw an original screen
5.     COLOR 4
6.     LOCATE i, 1: PRINT i;
7.     COLOR 15
8.     LOCATE i, i: PRINT i;
9. NEXT
10.  
11. ScreenSave 0, 10, 10, 20, 20, Array() 'save a portion of it
12. SLEEP
13. CLS 'clear it
14. SLEEP
15. ScreenRestore 0, 10, 10, Array() 'restore it exactly where it was
16. SLEEP
17. CLS 'clear it
18. SCREEN _NEWIMAGE(120, 50, 0) 'and make a larger screen
19. SLEEP
20. ScreenRestore 0, 10, 10, Array() 'restore it to that larger screen
21. SLEEP
22. ScreenRestore 0, 45, 7, Array() 'And to showcase that we can move this text elsewhere...
23.  
24.  
25. SUB ScreenSave (Image, X1, Y1, X2, Y2, Array() AS STRING) 'coordinates of the screen to copy
26.     $CHECKING:OFF
27.     IF X1 > X2 THEN SWAP X1, X2 'go from left to right, not right to left
28.     IF Y1 > Y2 THEN SWAP Y1, Y2 'and from top yo bottom, not bottom to top
29.  
30.     DIM M AS _MEM
31.     M = _MEMIMAGE(Image) '
32.     E = ConvertOffset(M.ELEMENTSIZE) 'How many bytes per pixel are in memory?  Screen 0 uses 2 bytes, 256 color screens use 1, 32-bit screens use 4
33.  
34.     Length = (X2 - X1 + 1) * E 'Width of stored area * bytes per pixel
35.     Rows = (Y2 - Y1 + 1) 'Number of rows to store
36.  
37.     REDIM Array(1 TO Rows) AS STRING 'Array to store the data
38.     FOR i = 1 TO Rows
39.         Array(i) = SPACE$(Length) 'Set the array to the proper length to store each row of data
40.     NEXT
41.  
42.     count = 0
43.     IF E = 2 THEN
44.         FOR y = Y1 - 1 TO Y2 - 1 'for text screens, we need to change the coordinates from using text locations
45.             '                     (starting at 1,1), and convert them to memory locations starting at 0,0.
46.             count = count + 1
47.             _MEMGET M, M.OFFSET + (y * _WIDTH + X1) * E, Array(count) 'get the rows into memory starting from the proper offset
48.         NEXT
49.     ELSE
50.         FOR y = Y1 TO Y2
51.             count = count + 1
52.             _MEMGET M, M.OFFSET + (y * _WIDTH + X1) * E, Array(count) 'get the rows into memory starting from the proper offset
53.         NEXT
54.     END IF
55.     _MEMFREE M 'Free the temp mem block
56.     $CHECKING:ON
57. END SUB
58.  
59. SUB ScreenRestore (Image, X1, Y1, Array() AS STRING) 'coordinates of the screen to copy
60.     $CHECKING:OFF
61.     y2 = Y1 + UBOUND(Array) - 1
62.  
63.     DIM M AS _MEM
64.     M = _MEMIMAGE(Image) '
65.     E = ConvertOffset(M.ELEMENTSIZE) 'How many bytes per pixel are in memory?  Screen 0 uses 2 bytes, 256 color screens use 1, 32-bit screens use 4
66.  
67.     length = LEN(Array(1))
68.     Rows = (y2 - Y1 + 1) 'Number of rows to store
69.  
70.     count = 0
71.     IF E = 2 THEN
72.         FOR y = Y1 - 1 TO y2 - 1
73.             count = count + 1
74.             _MEMPUT M, M.OFFSET + (y * _WIDTH + X1) * E, Array(count) 'get the rows into memory starting from the proper offset
75.         NEXT
76.     ELSE
77.         FOR y = Y1 TO y2
78.             count = count + 1
79.             _MEMPUT M, M.OFFSET + (y * _WIDTH + X1) * E, Array(count) 'get the rows into memory starting from the proper offset
80.         NEXT
81.  
82.     END IF
83.     _MEMFREE M 'Free the temp mem block
84.     $CHECKING:ON
85. END SUB
86.  
87.  
88.  
89. FUNCTION ConvertOffset&& (value AS _OFFSET)
90.     $CHECKING:OFF
91.     DIM m AS _MEM 'Define a memblock
92.     m = _MEM(value) 'Point it to use value
93.     $IF 64BIT THEN
94.         'On 64 bit OSes, an OFFSET is 8 bytes in size.  We can put it directly into an Integer64
95.         _MEMGET m, m.OFFSET, ConvertOffset&& 'Get the contents of the memblock and put the values there directly into ConvertOffset&&
96.     $ELSE
97.         'However, on 32 bit OSes, an OFFSET is only 4 bytes.  We need to put it into a LONG variable first
98.         _MEMGET m, m.OFFSET, temp& 'Like this
99.         ConvertOffset&& = temp& 'And then assign that long value to ConvertOffset&&
100.     $END IF
101.     _MEMFREE m 'Free the memblock
102.     $CHECKING:ON
103. END FUNCTION
104.  

The Screen Information is stored in a REDIM array, which you use to pass the information back and forth between the two subs, which in this case is found near the top of the code with: REDIM Array(0) AS STRING.

Note, this should work in graphic modes just the same as it does for SCREEN 0, though I haven't tested it extensively.

[Stuart]

If you're only changing the vertical height this isn't too hard:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(80, 25, 0)
2. FOR i = 1 TO 10
3.     PRINT STRING$(i, "*")
4.     COLOR i
5. NEXT i
6.  
7. character_count = _WIDTH * 10 'save 10 lines worth of characters
8.  
9. DIM m AS _MEM
10. DIM saved AS _MEM
11. m = _MEMIMAGE(0) '_mem reference to the display
12. saved = _MEMNEW(m.ELEMENTSIZE * _WIDTH * 10) 'buffer to save data in
13. _MEMCOPY m, m.OFFSET, m.ELEMENTSIZE * character_count TO saved, saved.OFFSET 'copy screen -> buffer
14. _MEMFREE m
15. SLEEP
16.  
17. SCREEN _NEWIMAGE(80, 30, 0)
18. m = _MEMIMAGE(0) 'we are now displaying a new screen, do get a new reference to it
19. _MEMCOPY saved, saved.OFFSET, m.ELEMENTSIZE * character_count TO m, m.OFFSET 'copy buffer -> screen
20.  
21. _MEMFREE saved
22. _MEMFREE m

But if you're changing the width (characters per line) or you only want to save part of a line it'll be a little more complicated because you're no longer dealing with a contiguous block of memory. At this point (or even before) consider if it isn't just easier to save the data to an array.

Thanks for your reply.  I'm sorry it took so long for me get back to you.

I did think about using an array at one time to hold the screen data which would have eliminated the unwanted disk activity when using BSAVE, BLOAD and KILL, but I was also thinking about all of the (up to 7680) PEEKs and POKEs, etc... and it seemed like it would be such a long and drawn out process that it might end up looking too flashy, so I never even bothered to try it that way.

I was able to use the code you provided to do exactly what I wanted, with a few small changes to make allowances for the _original_ 'offset' and 'length' variables that I was using for the SCREEN 0 memory segment at &HB800 (which was originally used by BSAVE and BLOAD).

Here's what I came up with :

           LN = CSRLIN
          _DELAY .001: offset = (LN - 48) * 160 '(originally used with BSAVE -- based on DEF SEG = &HB800)
           _DELAY .001: IF offset < 0 THEN offset = 0 ELSE LN = 48
           _DELAY .001: length = LN * 160 ''''''''(originally used with BSAVE -- same as m.ELEMENTSIZE * _WIDTH * LN)

_DELAY .001 'Thanks Luke, for all the help with the _MEM commands below...
          _DELAY .001: DIM m AS _MEM, saved AS _MEM
           _DELAY .001: m = _MEMIMAGE(0) ''''''''This is the _MEM reference to the display.
          _DELAY .001: saved = _MEMNEW(length) 'This is the buffer to save data in.
           _MEMCOPY m, m.OFFSET + offset, length TO saved, saved.OFFSET 'Copy (up to) the first 48 of the _last 50_ lines of screen data to the buffer.
          _MEMFREE m

           GOSUB 1400
           _DELAY .001: m = _MEMIMAGE(0) '''''''''''''''''''''''We are now displaying a new screen, so get a new reference to it.
           _MEMCOPY saved, saved.OFFSET, length TO m, m.OFFSET 'Copy from the buffer to the new screen.

           _MEMFREE saved
           _MEMFREE m



Red   -- original code -- (used with the older BSAVE and BLOAD method)
Green -- new QB64 code -- (replaces the older code and doesn't cause unwanted disk activity)
Black -- always used
Blue  -- all REMarks

Note :  The "_DELAY .001" at the beginning of a few lines is used only because the program that this code is for was written in such a way that it could be loaded using either QB64 _or_ QuickBASIC 4.5. Any line that begins with an underscore will be ignored completely by QB4.5 instead of being partially loaded, causing errors, and requiring a lot of manual editing to get it working again.  Also, some of the lines are only needed for features that are available in QB64, so those lines don't get loaded by QB4.5 in order to conserve memory.

Thanks again for providing this code and the remarks; it's certainly made it a lot easier for me to understand how the _MEM commands are implemented and used together.

Stuart

[Stuart]

And since it sounds like you just want to grab a segment of a screen, why don't you give these little routines a quick try:

Code: QB64: [Select]

1. SCREEN 0
2. REDIM Array(0) AS STRING
3.  
4. FOR i = 1 TO 25 'draw an original screen
5.     COLOR 4
6.     LOCATE i, 1: PRINT i;
7.     COLOR 15
8.     LOCATE i, i: PRINT i;
9. NEXT
10.  
11. ScreenSave 0, 10, 10, 20, 20, Array() 'save a portion of it
12. SLEEP
13. CLS 'clear it
14. SLEEP
15. ScreenRestore 0, 10, 10, Array() 'restore it exactly where it was
16. SLEEP
17. CLS 'clear it
18. SCREEN _NEWIMAGE(120, 50, 0) 'and make a larger screen
19. SLEEP
20. ScreenRestore 0, 10, 10, Array() 'restore it to that larger screen
21. SLEEP
22. ScreenRestore 0, 45, 7, Array() 'And to showcase that we can move this text elsewhere...
23.  
24.  
25. SUB ScreenSave (Image, X1, Y1, X2, Y2, Array() AS STRING) 'coordinates of the screen to copy
26.     $CHECKING:OFF
27.     IF X1 > X2 THEN SWAP X1, X2 'go from left to right, not right to left
28.     IF Y1 > Y2 THEN SWAP Y1, Y2 'and from top yo bottom, not bottom to top
29.  
30.     DIM M AS _MEM
31.     M = _MEMIMAGE(Image) '
32.     E = ConvertOffset(M.ELEMENTSIZE) 'How many bytes per pixel are in memory?  Screen 0 uses 2 bytes, 256 color screens use 1, 32-bit screens use 4
33.  
34.     Length = (X2 - X1 + 1) * E 'Width of stored area * bytes per pixel
35.     Rows = (Y2 - Y1 + 1) 'Number of rows to store
36.  
37.     REDIM Array(1 TO Rows) AS STRING 'Array to store the data
38.     FOR i = 1 TO Rows
39.         Array(i) = SPACE$(Length) 'Set the array to the proper length to store each row of data
40.     NEXT
41.  
42.     count = 0
43.     IF E = 2 THEN
44.         FOR y = Y1 - 1 TO Y2 - 1 'for text screens, we need to change the coordinates from using text locations
45.             '                     (starting at 1,1), and convert them to memory locations starting at 0,0.
46.             count = count + 1
47.             _MEMGET M, M.OFFSET + (y * _WIDTH + X1) * E, Array(count) 'get the rows into memory starting from the proper offset
48.         NEXT
49.     ELSE
50.         FOR y = Y1 TO Y2
51.             count = count + 1
52.             _MEMGET M, M.OFFSET + (y * _WIDTH + X1) * E, Array(count) 'get the rows into memory starting from the proper offset
53.         NEXT
54.     END IF
55.     _MEMFREE M 'Free the temp mem block
56.     $CHECKING:ON
57. END SUB
58.  
59. SUB ScreenRestore (Image, X1, Y1, Array() AS STRING) 'coordinates of the screen to copy
60.     $CHECKING:OFF
61.     y2 = Y1 + UBOUND(Array) - 1
62.  
63.     DIM M AS _MEM
64.     M = _MEMIMAGE(Image) '
65.     E = ConvertOffset(M.ELEMENTSIZE) 'How many bytes per pixel are in memory?  Screen 0 uses 2 bytes, 256 color screens use 1, 32-bit screens use 4
66.  
67.     length = LEN(Array(1))
68.     Rows = (y2 - Y1 + 1) 'Number of rows to store
69.  
70.     count = 0
71.     IF E = 2 THEN
72.         FOR y = Y1 - 1 TO y2 - 1
73.             count = count + 1
74.             _MEMPUT M, M.OFFSET + (y * _WIDTH + X1) * E, Array(count) 'get the rows into memory starting from the proper offset
75.         NEXT
76.     ELSE
77.         FOR y = Y1 TO y2
78.             count = count + 1
79.             _MEMPUT M, M.OFFSET + (y * _WIDTH + X1) * E, Array(count) 'get the rows into memory starting from the proper offset
80.         NEXT
81.  
82.     END IF
83.     _MEMFREE M 'Free the temp mem block
84.     $CHECKING:ON
85. END SUB
86.  
87.  
88.  
89. FUNCTION ConvertOffset&& (value AS _OFFSET)
90.     $CHECKING:OFF
91.     DIM m AS _MEM 'Define a memblock
92.     m = _MEM(value) 'Point it to use value
93.     $IF 64BIT THEN
94.         'On 64 bit OSes, an OFFSET is 8 bytes in size.  We can put it directly into an Integer64
95.         _MEMGET m, m.OFFSET, ConvertOffset&& 'Get the contents of the memblock and put the values there directly into ConvertOffset&&
96.     $ELSE
97.         'However, on 32 bit OSes, an OFFSET is only 4 bytes.  We need to put it into a LONG variable first
98.         _MEMGET m, m.OFFSET, temp& 'Like this
99.         ConvertOffset&& = temp& 'And then assign that long value to ConvertOffset&&
100.     $END IF
101.     _MEMFREE m 'Free the memblock
102.     $CHECKING:ON
103. END FUNCTION
104.  

The Screen Information is stored in a REDIM array, which you use to pass the information back and forth between the two subs, which in this case is found near the top of the code with: REDIM Array(0) AS STRING.

Note, this should work in graphic modes just the same as it does for SCREEN 0, though I haven't tested it extensively.

I'm sorry it took so long for me get back to you.

Thanks for the code and REMarks you provided.  It's a little more than I need at the moment because my program always uses a SCREEN 0, 80 character width display, but I'm sure I can learn a lot from it for future projects.  I like the way that you and Luke both comment each line to explain exactly what it does and why it's needed.

There were a lot of articles you had posted back on [abandoned, outdated and now likely malicious qb64 dot net website - don’t go there], one in particular that explained in great detail how the SCREEN 0 memory works -- (that 2 bytes are used for each character position, first byte = ascii value of character, and the second byte = the foreground and background colors).  I think that MOD could then be used to get those 2 values from that second, single byte.
That article was a lot of help when I had to manually calculate the 'offset' and 'length' variables needed when I was using the older BSAVE, BLOAD method to transfer screen data.  As a matter of fact, I'm still using the older 'offset' and 'length' variables _as_part_of_ the newer _MEM command(s) method.

It would be nice if those old acticles could be found and restored here at qb64.org if/when they are made available from [abandoned, outdated and now likely malicious qb64 dot net website - don’t go there] because I'm sure that lots of other people would find them interesting and useful.

Oh, and thanks again for getting the problems with VAL fixed a few years ago.  That was one of the first bugs I ever reported way back in the SDL days, and it just so happens that this program I'm working on right now is the same one I was using when I noticed the problems with VAL.

Stuart