![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to restscrn.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386|
Return to restscrn.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 root 1: ;---------------------------Module-Header------------------------------;
2: ; Module Name: restscrn.asm
3: ;
4: ; Copyright (c) 1992 Microsoft Corporation
5: ;-----------------------------------------------------------------------;
6: ;-----------------------------------------------------------------------;
7: ; VOID vRestoreScreenBitsFromMemory(PDEVSURF pdsurf, PRECTL prcl,
8: ; PVOID pjSrcBuffer, ULONG ulRestoreWidthInBytes,
9: ; ULONG ulSrcDelta);
10: ; Input:
11: ; pdsurf - surface to which to copy
12: ; prcl - pointer to rectangle to which to copy
13: ; pjSrcBuffer - pointer to source memory buffer. Should have the same
14: ; dword alignment as the dest rect left edge does in screen
15: ; memory
16: ; ulRestoreWidthInBytes - # of bytes to restore per scan (including any
17: ; partial edges)
18: ; ulSrcDelta - distance from end of one source scan to start of next.
19: ; together with ulRestoreWidthInBytes, should maintain
20: ; dword alignment between source and dest
21: ;
22: ; Copies a rectangle from a memory buffer to VGA memory.
23: ;
24: ;-----------------------------------------------------------------------;
25: ;
26: ; Note: Assumes all rectangles have positive heights and widths. Will not
27: ; work properly if this is not the case.
28: ;
29: ;-----------------------------------------------------------------------;
30: ;
31: ; Note: The rectangle is restored from interleaved-scan format; all four planes
32: ; of one scan are saved together, then all four planes of the next scan,
33: ; and so on. This is done for maximum restoration efficiency. Planes are
34: ; saved in order 3, 2, 1, 0:
35: ;
36: ; Scan n, plane 3
37: ; Scan n, plane 2
38: ; Scan n, plane 1
39: ; Scan n, plane 0
40: ; Scan n+1, plane 3
41: ; Scan n+1, plane 2
42: ; Scan n+1, plane 1
43: ; Scan n+1, plane 0
44: ; :
45: ;
46: ; There may be padding on either edge of the saved bits in the destination
47: ; buffer, so that the destination can be dword aligned with the source.
48: ;
49: ;-----------------------------------------------------------------------;
50: ;Additional optimizations:
51: ;
52: ; Could break out separate scan copy code with and without edge handling.
53: ; (Possibly by threading the desired operations, or by having many separate
54: ; optimizations.)
55: ;
56: ; Could handle odd bytes to dword align more efficiently, by having separate
57: ; optimizations for various alignment widths, thereby avoiding starting REP
58: ; and getting word accesses for 2 and 3 wide cases. Most VGAs are 8 or 16
59: ; bit devices, and for them, using MOVSB/REP MOVSW/MOVSB might actually be
60: ; faster, especially because it's easier to break out optimizations.
61: ;
62: ; Could end all scan handlers with loop bottom code.
63: ;
64: ; Could do more scans in one plane before doing next plane, to avoid
65: ; slow OUTs. This could cause color effects, but that might be avoidable
66: ; by scaling the # of scans done per plane to the width of the rectangle.
67: ;
68: ;-----------------------------------------------------------------------;
69:
70:
71: .386
72:
73: ifndef DOS_PLATFORM
74: .model small,c
75: else
76: ifdef STD_CALL
77: .model small,c
78: else
79: .model small,pascal
80: endif; STD_CALL
81: endif; DOS_PLATFORM
82:
83: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
84: assume fs:nothing,gs:nothing
85:
86: .xlist
87: include stdcall.inc ;calling convention cmacros
88: include i386\egavga.inc
89: include i386\strucs.inc
90:
91: .list
92:
93: .data
94:
95: ;-----------------------------------------------------------------------;
96: ; Masks used to do left and right edge clipping for various alignments.
97: ; Low byte = destination mask, high byte = source mask.
98: ;-----------------------------------------------------------------------;
99: align 2
100: usLeftMasks label word
101: dw 0ff00h, 07f80h, 03fc0h, 01fe0h, 00ff0h, 007f8h, 003fch, 001feh
102:
103: usRightMasks label word
104: dw 0ff00h, 0807fh, 0c03fh, 0e01fh, 0f00fh, 0f807h, 0fc03h, 0fe01h
105:
106: ;-----------------------------------------------------------------------;
107: ; Same as above, but dest masks only, and whole byte case is represented
108: ; as 0ffh rather than 0. Used for 1-byte-wide cases.
109: ;-----------------------------------------------------------------------;
110: jLeftMasks label byte
111: db 0ffh, 080h, 0c0h, 0e0h, 0f0h, 0f8h, 0fch, 0feh
112:
113: jRightMasks label byte
114: db 0ffh, 07fh, 03fh, 01fh, 00fh, 007h, 003h, 001h
115:
116: .code
117:
118: _TEXT$03 SEGMENT DWORD USE32 PUBLIC 'CODE'
119: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
120:
121: ;-----------------------------------------------------------------------;
122:
123: cProc vRestoreScreenBitsFromMemory,20,< \
124: uses esi edi ebx, \
125: pdsurf:ptr, \
126: prcl:ptr, \
127: pjSrcBuffer:ptr, \
128: ulRestoreWidthInBytes:dword, \
129: ulSrcDelta:dword >
130:
131: local ulCurrentTopScan :dword ;top scan line to copy to in current
132: ; bank
133: local ulBottomScan :dword ;bottom scan line of rectangle to which
134: ; to copy
135: local pjDstStart :dword ;destination address
136: local ulDstDelta :dword ;distance from end of dest scan to
137: ; start of next
138: local ulBlockHeight :dword ;# of scans to copy in block
139: local ulLeadingBytes :dword ;# of leading bytes to copy per scan
140: local ulMiddleDwords :dword ;# of dwords to copy per scan
141: local ulTrailingBytes :dword ;# of trailing bytes to copy per scan
142: local pfnCopyVector :dword ;pointer to inner loop routine to copy
143: ; from buffer to screen
144: local ulLeftMask :dword ;2 byte masks for left edge clipping
145: ; (low byte = dest mask,
146: ; high byte = src mask)
147: local ulRightMask :dword ;2 byte masks for right edge clipping
148:
149: ;-----------------------------------------------------------------------;
150: ; Leave the GC Index pointing to the Read Map for the rest of this routine.
151: ;-----------------------------------------------------------------------;
152:
153: mov edx,VGA_BASE + GRAF_ADDR
154: mov al,GRAF_READ_MAP
155: out dx,al
156:
157: ;-----------------------------------------------------------------------;
158: ; Set up local variables.
159: ;-----------------------------------------------------------------------;
160:
161: mov edi,prcl ;point to rectangle from which to copy
162: mov esi,pdsurf ;point to surface from which to copy
163:
164: mov eax,[edi].yBottom
165: mov ulBottomScan,eax ;bottom scan line of source rect
166:
167: mov eax,[esi].dsurf_lNextScan
168: sub eax,ulRestoreWidthInBytes
169: mov ulDstDelta,eax ;distance from end of one scan's bits to save
170: ; to start of next scan's in display memory
171:
172: ;-----------------------------------------------------------------------;
173: ; Figure out the left and right clip masks. If either or both edges are
174: ; solid, add them into the whole bytes.
175: ;-----------------------------------------------------------------------;
176:
177: mov ebx,[edi].xLeft
178: mov ecx,[edi].xRight
179: mov edx,ebx
180: lea eax,[ecx-1]
181: and ebx,0111b
182: and ecx,0111b
183:
184: and edx,not 0111b
185: sub eax,edx
186: shr eax,3 ;width in bytes - 1
187: ;only 1 byte wide?
188: jnz short @F ;no
189: ;1 byte wide; special case
190: mov al,jLeftMasks[ebx] ;look up left dest mask
191: and al,jRightMasks[ecx] ;factor in right dest mask
192: mov ah,0ffh
193: mov ebx,offset copy_from_buffer_l_whole_only ;assume whole byte
194: xor ah,al ;calculate matching dest mask
195: ;is this single byte a whole byte?
196: jz set_copy_vector ;yes, select whole byte optimization
197: ;no, select partial byte optimization
198: mov ebx,offset copy_from_buffer_l_partial_only
199: mov ulLeftMask,eax
200: jmp set_copy_vector
201:
202: align 4
203: @@: ;more than 1 byte wide
204:
205: mov edx,ulRestoreWidthInBytes
206:
207: mov ax,usLeftMasks[ebx*2] ;look up left masks
208: mov ulLeftMask,eax
209: and al,al ;any left clipping?
210: jz short @F ;no, do as part of whole bytes
211: dec edx ;yes, don't count as whole byte
212: @@:
213:
214:
215: mov ax,usRightMasks[ecx*2] ;look up right masks
216: mov ulRightMask,eax
217: and al,al ;any right clipping?
218: jz short @F ;no, do as part of whole bytes
219: dec edx ;yes, don't count as whole byte
220: @@:
221:
222: ;-----------------------------------------------------------------------;
223: ; Set up for copying as much as possible via aligned dwords, and
224: ; select the most efficient loop for doing the copy, based on the copy
225: ; width, and on the necessity for leading and/or trailing bytes to
226: ; dword align.
227: ;-----------------------------------------------------------------------;
228:
229: cmp edx,8 ;if it's less than 8 bytes, just do a
230: ; straight byte copy. This means we
231: ; we only have to start 1 REP per line,
232: ; and performing this check guarantees
233: ; that we have at least 1 aligned dword
234: ; to copy in the dword loops
235: jb short copy_all_as_bytes ;do straight byte copy
236: mov eax,pjSrcBuffer
237: neg eax
238: and eax,3 ;# of bytes that have to be done as leading
239: ; bytes to dword align with source (note that
240: ; for performance, the source should be dword
241: ; aligned with the destination)
242: jz short copy_no_leading_bytes ;no leading bytes
243: ;leading bytes
244: mov ulLeadingBytes,eax
245: mov ebx,offset copy_from_buffer_l ;assume no trailing bytes
246: sub edx,eax ;# of bytes after leading bytes
247: mov eax,edx
248: shr eax,2 ;# of dwords that can be handled as aligned
249: ; dwords
250: mov ulMiddleDwords,eax
251: and edx,3 ;# of trailing bytes left after aligned dwords
252: ; copied
253: jz short set_copy_vector ;no trailing bytes
254: mov ulTrailingBytes,edx
255: mov ebx,offset copy_from_buffer_lt ;there are both leading and
256: ; trailing bytes
257: jmp short set_copy_vector
258:
259: align 4
260: copy_no_leading_bytes:
261: mov ebx,offset copy_from_buffer ;assume no trailing bytes
262: mov eax,edx
263: shr eax,2 ;# of dwords that can be handled as aligned
264: ; dwords
265: mov ulMiddleDwords,eax
266: and edx,3 ;# of trailing bytes left after aligned dwords
267: ; copied
268: jz short set_copy_vector ;no trailing bytes
269: mov ulTrailingBytes,edx
270: mov ebx,offset copy_from_buffer_t ;there are trailing bytes
271: jmp short set_copy_vector
272:
273: ; It's so narrow that we'll forget about aligned dwords, and just do a straight
274: ; byte copy, which we'll handle by treating the entire copy as leading bytes.
275: align 4
276: copy_all_as_bytes:
277: mov ulLeadingBytes,edx
278: mov ebx,offset copy_from_buffer_lonly
279:
280: set_copy_vector:
281: mov pfnCopyVector,ebx
282:
283: ;-----------------------------------------------------------------------;
284: ; Map in the bank containing the top scan to copy, if it's not mapped in
285: ; already.
286: ;-----------------------------------------------------------------------;
287:
288: mov eax,[edi].yTop ;top scan line of copy
289: mov ulCurrentTopScan,eax ;this will be the copy top in 1st bank
290:
291: cmp eax,[esi].dsurf_rcl1WindowClip.yTop ;is copy top less than
292: ; current bank?
293: jl short map_init_bank ;yes, map in proper bank
294: cmp eax,[esi].dsurf_rcl1WindowClip.yBottom ;copy top greater than
295: ; current bank?
296: jl short init_bank_mapped ;no, proper bank already mapped
297: map_init_bank:
298:
299: ; Map in the bank containing the top scan line of the copy.
300:
301: ptrCall <dword ptr [esi].dsurf_pfnBankControl>,<esi,eax,JustifyTop>
302:
303: init_bank_mapped:
304:
305: ;-----------------------------------------------------------------------;
306: ; Calculate the initial start address to which to copy.
307: ;-----------------------------------------------------------------------;
308:
309: mov eax,ulCurrentTopScan ;top scan line to copy to in current
310: ; bank
311: imul [esi].dsurf_lNextScan ;offset of starting scan line in bitmap
312: add eax,[esi].dsurf_pvBitmapStart ;start address of scan
313: mov ebx,[edi].xLeft
314: shr ebx,3 ;convert from pixel to byte address
315: add eax,ebx ;start dest address
316: mov pjDstStart,eax
317:
318: ;-----------------------------------------------------------------------;
319: ; Loop through and copy all bank blocks spanned by the destination
320: ; rectangle.
321: ;
322: ; Input:
323: ; ESI = pdsurf
324: ;-----------------------------------------------------------------------;
325:
326: copy_from_buffer_bank_loop:
327:
328: ; Copy this bank block to the buffer.
329:
330: ; Calculate # of scans in this bank.
331:
332: mov ebx,ulBottomScan ;bottom of dest rectangle
333: cmp ebx,[esi].dsurf_rcl1WindowClip.yBottom
334: ;which comes first, the bottom of the
335: ; dest rect or the bottom of the
336: ; current bank?
337: jl short @F ;dest bottom comes first, so copy to
338: ; that; this is the last bank in copy
339: mov ebx,[esi].dsurf_rcl1WindowClip.yBottom
340: ;bank bottom comes first; copy to
341: ; bottom of bank
342: @@:
343: sub ebx,ulCurrentTopScan ;# of scans to copy in this bank
344: mov ulBlockHeight,ebx
345:
346: mov esi,pjSrcBuffer ;point to start of source rect
347:
348: mov dh,VGA_BASE SHR 8 ;leave DH pointing to VGA_BASE
349:
350: ;-----------------------------------------------------------------------;
351: ; Loop through all scans in this block, copying all four planes of each
352: ; scan in turn, then doing the next scan.
353: ;-----------------------------------------------------------------------;
354: copy_to_buffer_scan_loop:
355:
356: mov bl,MM_C3 ;start by copying to plane 3
357:
358: ;-----------------------------------------------------------------------;
359: ; Loop through all four planes, copying all scans in this block for each
360: ; plane in turn.
361: ;-----------------------------------------------------------------------;
362:
363: copy_to_buffer_plane_loop:
364:
365: mov dl,SEQ_DATA
366: mov al,bl
367: out dx,al ;set Map Mask to plane to which we're copying
368:
369: mov dl,GRAF_DATA
370: shr al,1
371: cmp al,3
372: adc al,-1
373: out dx,al
374:
375: mov edi,pjDstStart ;point to start of dest buffer (scan starts
376: ; at same address in all planes)
377: jmp pfnCopyVector ;jump to the appropriate loop to copy plane
378:
379: ;-----------------------------------------------------------------------;
380: ; Copy loops, broken out by leading and trailing bytes needed for dword
381: ; alignment, plus one loop to perform a straight byte copy.
382: ;
383: ; Input:
384: ; ESI = initial source copy address
385: ; EDI = initial dest copy address
386: ;-----------------------------------------------------------------------;
387:
388: ; All bytes can be copied as aligned dwords (no leading or trailing whole
389: ; bytes).
390: align 4
391: copy_from_buffer:
392:
393: ; Do the left edge byte, if there's a partial left edge byte.
394:
395: mov eax,ulLeftMask ;AL = dest mask, AH = source mask
396: and al,al ;any left mask?
397: jz short @F ;left edge is whole
398: and al,[edi] ;mask the dest
399: and ah,[esi] ;mask the source
400: inc esi ;point to next source byte
401: or al,ah ;combine the source and dest
402: stosb ;store the new byte
403: @@:
404:
405: ; Do the middle (whole) bytes.
406:
407: mov ecx,ulMiddleDwords
408: rep movsd
409:
410: ; Do the right edge byte, if there's a partial right edge byte.
411:
412: mov eax,ulRightMask ;AL = dest mask, AH = source mask
413: and al,al ;any left mask?
414: jz short @F ;right edge is whole
415: and al,[edi] ;mask the dest
416: and ah,[esi] ;mask the source
417: inc esi ;point to next source byte
418: or al,ah ;combine the source and dest
419: stosb ;store the new byte
420: @@:
421:
422: jmp copy_from_buffer_scan_done
423:
424: ; Leading odd whole bytes, but no trailing whole bytes.
425: align 4
426: copy_from_buffer_l:
427:
428: ; Do the left edge byte, if there's a partial left edge byte.
429:
430: mov eax,ulLeftMask ;AL = dest mask, AH = source mask
431: and al,al ;any left mask?
432: jz short @F ;left edge is whole
433: and al,[edi] ;mask the dest
434: and ah,[esi] ;mask the source
435: inc esi ;point to next source byte
436: or al,ah ;combine the source and dest
437: stosb ;store the new byte
438: @@:
439:
440: ; Do the middle (whole) bytes.
441:
442: mov ecx,ulLeadingBytes
443: rep movsb
444: mov ecx,ulMiddleDwords
445: rep movsd
446:
447: ; Do the right edge byte, if there's a partial right edge byte.
448:
449: mov eax,ulRightMask ;AL = dest mask, AH = source mask
450: and al,al ;any left mask?
451: jz short @F ;right edge is whole
452: and al,[edi] ;mask the dest
453: and ah,[esi] ;mask the source
454: inc esi ;point to next source byte
455: or al,ah ;combine the source and dest
456: stosb ;store the new byte
457: @@:
458:
459: jmp copy_from_buffer_scan_done
460:
461: ; Trailing odd whole bytes, but no leading whole bytes.
462: align 4
463: copy_from_buffer_t:
464:
465: ; Do the left edge byte, if there's a partial left edge byte.
466:
467: mov eax,ulLeftMask ;AL = dest mask, AH = source mask
468: and al,al ;any left mask?
469: jz short @F ;left edge is whole
470: and al,[edi] ;mask the dest
471: and ah,[esi] ;mask the source
472: inc esi ;point to next source byte
473: or al,ah ;combine the source and dest
474: stosb ;store the new byte
475: @@:
476:
477: ; Do the middle (whole) bytes.
478:
479: mov ecx,ulMiddleDwords
480: rep movsd
481: mov ecx,ulTrailingBytes
482: rep movsb
483:
484: ; Do the right edge byte, if there's a partial right edge byte.
485:
486: mov eax,ulRightMask ;AL = dest mask, AH = source mask
487: and al,al ;any left mask?
488: jz short @F ;right edge is whole
489: and al,[edi] ;mask the dest
490: and ah,[esi] ;mask the source
491: inc esi ;point to next source byte
492: or al,ah ;combine the source and dest
493: stosb ;store the new byte
494: @@:
495:
496: jmp copy_from_buffer_scan_done
497:
498: ; Only leading whole bytes (straight whole byte copy; no aligned dwords).
499: align 4
500: copy_from_buffer_lonly:
501:
502: ; Do the left edge byte, if there's a partial left edge byte.
503:
504: mov eax,ulLeftMask ;AL = dest mask, AH = source mask
505: and al,al ;any left mask?
506: jz short @F ;left edge is whole
507: and al,[edi] ;mask the dest
508: and ah,[esi] ;mask the source
509: inc esi ;point to next source byte
510: or al,ah ;combine the source and dest
511: stosb ;store the new byte
512: @@:
513:
514: ; Do the middle (whole) bytes.
515:
516: mov ecx,ulLeadingBytes
517: rep movsb
518:
519: ; Do the right edge byte, if there's a partial right edge byte.
520:
521: mov eax,ulRightMask ;AL = dest mask, AH = source mask
522: and al,al ;any left mask?
523: jz short @F ;right edge is whole
524: and al,[edi] ;mask the dest
525: and ah,[esi] ;mask the source
526: inc esi ;point to next source byte
527: or al,ah ;combine the source and dest
528: stosb ;store the new byte
529: @@:
530:
531: jmp short copy_from_buffer_scan_done
532:
533: ; Only one masked byte; no whole bytes and no right byte.
534: align 4
535: copy_from_buffer_l_partial_only:
536:
537: mov eax,ulLeftMask ;AL = dest mask, AH = source mask
538: and al,[edi] ;mask the dest
539: and ah,[esi] ;mask the source
540: inc esi ;point to next source byte
541: or al,ah ;combine the source and dest
542: stosb ;store the new byte
543: jmp short copy_from_buffer_scan_done
544:
545: ; Only one whole byte; no left byte and no right byte.
546: align 4
547: copy_from_buffer_l_whole_only:
548:
549: movsb ;copy the one byte
550: jmp short copy_from_buffer_scan_done
551:
552: ; Leading and trailing odd whole bytes.
553: align 4
554: copy_from_buffer_lt:
555:
556: ; Do the left edge byte, if there's a partial left edge byte.
557:
558: mov eax,ulLeftMask ;AL = dest mask, AH = source mask
559: and al,al ;any left mask?
560: jz short @F ;left edge is whole
561: and al,[edi] ;mask the dest
562: and ah,[esi] ;mask the source
563: inc esi ;point to next source byte
564: or al,ah ;combine the source and dest
565: stosb ;store the new byte
566: @@:
567:
568: ; Do the middle (whole) bytes.
569:
570: mov ecx,ulLeadingBytes
571: rep movsb
572: mov ecx,ulMiddleDwords
573: rep movsd
574: mov ecx,ulTrailingBytes
575: rep movsb
576:
577: ; Do the right edge byte, if there's a partial right edge byte.
578:
579: mov eax,ulRightMask ;AL = dest mask, AH = source mask
580: and al,al ;any left mask?
581: jz short @F ;right edge is whole
582: and al,[edi] ;mask the dest
583: and ah,[esi] ;mask the source
584: inc esi ;point to next source byte
585: or al,ah ;combine the source and dest
586: stosb ;store the new byte
587: @@:
588:
589: copy_from_buffer_scan_done:
590:
591: add esi,ulSrcDelta ;point to next source scan
592: shr bl,1 ;count down planes
593: jnz copy_to_buffer_plane_loop
594:
595: add edi,ulDstDelta ;point to next dest scan
596: mov pjDstStart,edi
597: dec ulBlockHeight ;count down scans
598: jnz copy_to_buffer_scan_loop
599:
600: ; Remember where we left off, for the next block.
601:
602: mov pjSrcBuffer,esi
603:
604: ;-----------------------------------------------------------------------;
605: ; See if there are more banks to do
606: ;-----------------------------------------------------------------------;
607:
608: mov esi,pdsurf
609: mov eax,[esi].dsurf_rcl1WindowClip.yBottom ;is the copy bottom in
610: cmp ulBottomScan,eax ; the current bank?
611: jle short copy_from_buffer_banks_done ;yes, so we're done
612: ;no, map in the next bank and copy it
613: mov ulCurrentTopScan,eax ;remember where the top of the bank
614: ; we're about to map in is (same as
615: ; bottom of bank we just did)
616: mov edx,[esi].dsurf_pvBitmapStart
617: sub pjDstStart,edx ;convert from address to offset within bitmap
618:
619: ptrCall <dword ptr [esi].dsurf_pfnBankControl>,<esi,eax,JustifyTop>
620: ;map in the bank
621:
622: ; Compute the starting address in this bank.
623: ; Note that the start of the bitmap will change each time through the
624: ; bank loop, because the start of the bitmap is varied to map the
625: ; desired scan line to the banking window.
626:
627: mov eax,[esi].dsurf_pvBitmapStart
628: add pjDstStart,eax ;address of next scan to draw
629:
630: ; Copy the new bank.
631:
632: jmp copy_from_buffer_bank_loop
633:
634:
635: ;-----------------------------------------------------------------------;
636: ; Done with all banks.
637: ;
638: ; At this point:
639: ; DX = VGA_BASE + GRAF_DATA
640: ;-----------------------------------------------------------------------;
641: align 4
642: copy_from_buffer_banks_done:
643:
644: mov ax,(MM_ALL shl 8)+SEQ_MAP_MASK ;restore writability for all planes
645: mov dx,VGA_BASE+SEQ_ADDR
646: out dx,ax
647:
648: cRet vRestoreScreenBitsFromMemory ;done
649:
650: ;-----------------------------------------------------------------------;
651:
652: endProc vRestoreScreenBitsFromMemory
653:
654: _TEXT$03 ends
655:
656: end
657:
658:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.