![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nalgnblt.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 nalgnblt.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 root 1: ;******************************Module*Header*******************************\
2: ; Module Name: nalgnblt.asm
3: ;
4: ; driver prototypes
5: ;
6: ; Copyright (c) 1992 Microsoft Corporation
7: ;**************************************************************************/
8:
9: ;-----------------------------------------------------------------------;
10: ; VOID vNonAlignedSrcCopy(PDEVSURF pdsurf, RECTL * prcldst, PPOINTL * pptlsrc,
11: ; INT icopydir);
12: ; Input:
13: ; pdsurf - surface on which to copy
14: ; prcldest - pointer to destination rectangle
15: ; pptlsrc - pointer to source upper left corner
16: ; icopydir - direction in which copy must proceed to avoid overlap problems
17: ; and synchronize with the clip enumeration visually, according to
18: ; constants CD_RIGHTDOWN, CD_LEFTDOWN, CD_RIGHTUP, and CD_LEFTUP in
19: ; WINDDI.H
20: ;
21: ; Performs accelarated non-aligned SRCCOPY VGA-to-VGA blts.
22: ;
23: ;-----------------------------------------------------------------------;
24: ;
25: ; Note: The source and dest *must* be non-aligned (not have the same
26: ; left-edge intrabyte pixel alignment. Will not work properly if they are
27: ; in fact aligned.
28: ;
29: ; Note: Assumes all rectangles have positive heights and widths. Will not
30: ; work properly if this is not the case.
31: ;
32: ;-----------------------------------------------------------------------;
33:
34: comment $
35:
36: The overall approach of this module for each rectangle to copy is:
37:
38: 1) Precalculate the masks and whole byte widths, and determine which of
39: partial left edge, partial right edge, and whole middle bytes are required
40: for this copy.
41:
42: 2) Set up the starting pointers for each of the areas (left, whole middle,
43: right), the start and stop scan lines, the copying direction (left-to-right
44: or right-to-left, and top-to-bottom or bottom-to-top), the threading
45: (sequence of calls required to do the left/whole/right components in the
46: proper sequence), based on the passed-in copy direction, which in turn is
47: dictated by the nature of the overlap between the source and destination.
48:
49: 3) Execute a loop, based on adapter type (2 R/W windows, 1R/1W window,
50: 1 R/W window, unbanked), that sequences through the intersection of each
51: bank with the source and destination rectangles in the proper direction
52: (top-to-bottom or bottom-to-top, based on the passed-in copy direction),
53: and performs the copy in each such rectangle. The threading vector is used
54: to call the required routines (copy left/whole/right bytes). For 1 R/W and
55: 1R/1W adapters, there is a second threading vector that is called when the
56: source and the destination are both adequately (for the copy purposes)
57: addressable simultaneously (because they're in the same bank), so there's
58: no need to copy through a temp buffer. We want to avoid the temp
59: buffer whenever we can, because it's slower.
60:
61: Note: 1 R/W and 1R/1W edges are copied through a temporary buffer. However,
62: each plane's bytes are not stored in the corresponding plane's temp buffer, but
63: rather consecutively in the plane 0 temp buffer. This is to reduce page
64: faulting, and also so that 1R/1W adapters only need a temp buffer large enough
65: to hold 4*tallest bank words (4K will do). 1 R/W adapters still copy whole
66: bytes through the full temp buffer, using all four planes' temp buffers, so
67: they require a temp buffer big enough to hold a full bank (256K will do).
68:
69: Note: The VGA's rotator is used to perform all rotation in this module. The
70: two source bytes relevant to this operation are masked to preserve the desired
71: bits, then combined and fed to the VGA's rotator, which performs the rotation.
72: This is better than letting the 386/486 do the rotation because even with the
73: barrel shifter, those processors take 3 cycles per rotate, where the masking
74: and combining take only 2 cycles (or no cycles, for edges with 1-wide
75: sources). We also get to avoid 16-bit instructions like ROL AX,CL; the 16-bit
76: size prefix costs a cycle on a 486.
77:
78: commend $
79:
80: ;-----------------------------------------------------------------------;
81: ; Set LOOP_UNROLL_SHIFT to the log2 of the number of times you want loops in
82: ; this module unrolled. For example, LOOP_UNROLL_SHIFT of 3 yields 2**3 = 8
83: ; times unrolling. This is the only thing you need to change to control
84: ; unrolling. Note: does not affect loops that process in chunks, like edge
85: ; loops.
86:
87: LOOP_UNROLL_SHIFT equ 2
88:
89: ;-----------------------------------------------------------------------;
90: ; Maximum # of edge bytes to process before switching to next plane. Larger
91: ; means faster, but there's more potential for flicker, since the raster scan
92: ; has a better chance of catching bytes that have changed in some planes but
93: ; not all planes.
94:
95: EDGE_CHUNK_SIZE equ 16
96:
97: ;-----------------------------------------------------------------------;
98: ; Macro to push the current threading sequence (string of routine calls) on the
99: ; stack, then jump to the first threading entry. The threading pointer can be
100: ; specified, or defaults to pCurrentThread. The return address can be
101: ; immediately after the JMP, or can be specified.
102:
103: THREAD_AND_START macro THREADING,RETURN_ADDR
104: local push_base, return_address
105:
106: ifb <&RETURN_ADDR&>
107: push offset return_address ;after all the threaded routines, we
108: ; return here
109: else
110: push offset &RETURN_ADDR& ;return here
111: endif
112:
113: ifb <&THREADING&>
114: mov eax,pCurrentThread
115: else
116: mov eax,&THREADING&
117: endif
118:
119: mov ecx,[eax] ;# of routines to thread (at least 1)
120: lea ecx,[ecx*2+ecx] ;pushes below are 3 bytes each
121: mov edx,offset push_base+3
122: sub edx,ecx
123: jmp edx ;branch to push or jmp below
124:
125: ; Push the threading addresses on to the stack, so routines perform the
126: ; threading as they return.
127:
128: push dword ptr [eax+12] ;3 byte instruction
129: push dword ptr [eax+8]
130: push_base:
131: jmp dword ptr [eax+4] ;jump to the first threaded routine
132:
133: align 4
134: return_address:
135: endm
136:
137: ;-----------------------------------------------------------------------;
138:
139: .386
140:
141: ifndef DOS_PLATFORM
142: .model small,c
143: else
144: ifdef STD_CALL
145: .model small,c
146: else
147: .model small,pascal
148: endif; STD_CALL
149: endif; DOS_PLATFORM
150:
151: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
152: assume fs:nothing,gs:nothing
153:
154: .xlist
155: include stdcall.inc ;calling convention cmacros
156: include i386\egavga.inc
157: include i386\strucs.inc
158: include i386\unroll.inc
159: include i386\ropdefs.inc
160:
161: .list
162:
163: ;-----------------------------------------------------------------------;
164:
165: .data
166:
167: ; Threads for stringing together left, whole byte, and right operations
168: ; in various orders, both using a temp buffer and not. Data format is:
169: ;
170: ; DWORD +0 = # of calls in thread (1, 2, or 3)
171: ; +4 = first call (required)
172: ; +8 = second call (optional)
173: ; +12 = third call (optional)
174:
175: align 4
176:
177: ; Copies not involving the temp buffer.
178:
179: Thread_L dd 1
180: dd copy_left_edge
181:
182: Thread_W dd 1
183: dd copy_whole_bytes
184:
185: Thread_R dd 1
186: dd copy_right_edge
187:
188: Thread_LR dd 2
189: dd copy_left_edge
190: dd copy_right_edge
191:
192: Thread_RL dd 2
193: dd copy_right_edge
194: dd copy_left_edge
195:
196: Thread_LW dd 2
197: dd copy_left_edge
198: dd copy_whole_bytes
199:
200: Thread_WL dd 2
201: dd copy_whole_bytes
202: dd copy_left_edge
203:
204: Thread_WR dd 2
205: dd copy_whole_bytes
206: dd copy_right_edge
207:
208: Thread_RW dd 2
209: dd copy_right_edge
210: dd copy_whole_bytes
211:
212: Thread_LWR dd 3
213: dd copy_left_edge
214: dd copy_whole_bytes
215: dd copy_right_edge
216:
217: Thread_RWL dd 3
218: dd copy_right_edge
219: dd copy_whole_bytes
220: dd copy_left_edge
221:
222: ; Copies involving the temp buffer.
223:
224: Thread_Lb dd 1
225: dd copy_left_edge_via_buffer
226:
227: Thread_Wb dd 1
228: dd copy_whole_bytes_via_buffer
229:
230: Thread_Rb dd 1
231: dd copy_right_edge_via_buffer
232:
233: Thread_LbRb dd 2
234: dd copy_left_edge_via_buffer
235: dd copy_right_edge_via_buffer
236:
237: Thread_RbLb dd 2
238: dd copy_right_edge_via_buffer
239: dd copy_left_edge_via_buffer
240:
241: Thread_LbW dd 2
242: dd copy_left_edge_via_buffer
243: dd copy_whole_bytes
244:
245: Thread_LbWb dd 2
246: dd copy_left_edge_via_buffer
247: dd copy_whole_bytes_via_buffer
248:
249: Thread_WLb dd 2
250: dd copy_whole_bytes
251: dd copy_left_edge_via_buffer
252:
253: Thread_WbLb dd 2
254: dd copy_whole_bytes_via_buffer
255: dd copy_left_edge_via_buffer
256:
257: Thread_WRb dd 2
258: dd copy_whole_bytes
259: dd copy_right_edge_via_buffer
260:
261: Thread_WbRb dd 2
262: dd copy_whole_bytes_via_buffer
263: dd copy_right_edge_via_buffer
264:
265: Thread_RbW dd 2
266: dd copy_right_edge_via_buffer
267: dd copy_whole_bytes
268:
269: Thread_RbWb dd 2
270: dd copy_right_edge_via_buffer
271: dd copy_whole_bytes_via_buffer
272:
273: Thread_LbWRb dd 3
274: dd copy_left_edge_via_buffer
275: dd copy_whole_bytes
276: dd copy_right_edge_via_buffer
277:
278: Thread_LbWbRb dd 3
279: dd copy_left_edge_via_buffer
280: dd copy_whole_bytes_via_buffer
281: dd copy_right_edge_via_buffer
282:
283: Thread_RbWLb dd 3
284: dd copy_right_edge_via_buffer
285: dd copy_whole_bytes
286: dd copy_left_edge_via_buffer
287:
288: Thread_RbWbLb dd 3
289: dd copy_right_edge_via_buffer
290: dd copy_whole_bytes_via_buffer
291: dd copy_left_edge_via_buffer
292:
293: ;-----------------------------------------------------------------------;
294: ; Table of thread selection for various horizontal copy directions, with
295: ; the look-up index a 4-bit field as follows:
296: ;
297: ; Bit 3 = 1 if left-to-right copy, 0 if right-to-left
298: ; Bit 2 = 1 if left edge must be copied
299: ; Bit 1 = 1 if whole bytes must be copied
300: ; Bit 0 = 1 if right edge must be copied
301: ;
302: ; This is used for all cases where both the source and destination are
303: ; simultaneously addressable for our purposes, so there's no need to go
304: ; through the temp buffer (unbanked, 2 R/W, and sometimes for 1 R/W and 1R/1W).
305:
306: MasterThreadTable label dword
307: ;right-to-left
308: dd 0 ;<not used>
309: dd Thread_R ;R->L, R
310: dd Thread_W ;R->L, W
311: dd Thread_RW ;R->L, RW
312: dd Thread_L ;R->L, L
313: dd Thread_RL ;R->L, RL
314: dd Thread_WL ;R->L, WL
315: dd Thread_RWL ;R->L, RWL
316: ;left-to-right
317: dd 0 ;<not used>
318: dd Thread_R ;L->R, R
319: dd Thread_W ;L->R, W
320: dd Thread_WR ;L->R, WR
321: dd Thread_L ;L->R, L
322: dd Thread_LR ;L->R, LR
323: dd Thread_LW ;L->R, LW
324: dd Thread_LWR ;L->R, LWR
325:
326:
327: ; Table of thread selection for various adapter types and horizontal
328: ; copy directions, with the look-up index a 6-bit field as follows:
329: ;
330: ; Bit 5 = adapter type high bit
331: ; Bit 4 = adapter type low bit
332: ; Bit 3 = 1 if left-to-right copy, 0 if right-to-left
333: ; Bit 2 = 1 if left edge must be copied
334: ; Bit 1 = 1 if whole bytes must be copied
335: ; Bit 0 = 1 if right edge must be copied
336: ;
337: ; This is used for all cases where the source and destination are not both
338: ; simultaneously addressable for our purposes, so we need to go through the
339: ; temp buffer (only for 1 R/W and 1R/1W, and only sometimes).
340:
341: MasterThreadTableViaBuffer label dword
342: ;unbanked (no need for buffer)
343: ;right-to-left
344: dd 0 ;<not used>
345: dd Thread_R ;R->L, R
346: dd Thread_W ;R->L, W
347: dd Thread_RW ;R->L, RW
348: dd Thread_L ;R->L, L
349: dd Thread_RL ;R->L, RL
350: dd Thread_WL ;R->L, WL
351: dd Thread_RWL ;R->L, RWL
352: ;left-to-right
353: dd 0 ;<not used>
354: dd Thread_R ;L->R, R
355: dd Thread_W ;L->R, W
356: dd Thread_WR ;L->R, WR
357: dd Thread_L ;L->R, L
358: dd Thread_LR ;L->R, LR
359: dd Thread_LW ;L->R, LW
360: dd Thread_LWR ;L->R, LWR
361:
362: ;1 R/W banking window (everything goes through
363: ; buffer)
364: ;right-to-left
365: dd 0 ;<not used>
366: dd Thread_Rb ;R->L, R
367: dd Thread_Wb ;R->L, W
368: dd Thread_RbWb ;R->L, RW
369: dd Thread_Lb ;R->L, L
370: dd Thread_RbLb ;R->L, RL
371: dd Thread_WbLb ;R->L, WL
372: dd Thread_RbWbLb ;R->L, RWL
373: ;left-to-right
374: dd 0 ;<not used>
375: dd Thread_Rb ;L->R, R
376: dd Thread_Wb ;L->R, W
377: dd Thread_WbRb ;L->R, WR
378: dd Thread_Lb ;L->R, L
379: dd Thread_LbRb ;L->R, LR
380: dd Thread_LbWb ;L->R, LW
381: dd Thread_LbWbRb ;L->R, LWR
382:
383: ;1R/1W banking window (edge go through buffer)
384: ;right-to-left
385: dd 0 ;<not used>
386: dd Thread_Rb ;R->L, R
387: dd Thread_W ;R->L, W
388: dd Thread_RbW ;R->L, RW
389: dd Thread_Lb ;R->L, L
390: dd Thread_RbLb ;R->L, RL
391: dd Thread_WLb ;R->L, WL
392: dd Thread_RbWLb ;R->L, RWL
393: ;left-to-right
394: dd 0 ;<not used>
395: dd Thread_Rb ;L->R, R
396: dd Thread_W ;L->R, W
397: dd Thread_WRb ;L->R, WR
398: dd Thread_Lb ;L->R, L
399: dd Thread_LbRb ;L->R, LR
400: dd Thread_LbW ;L->R, LW
401: dd Thread_LbWRb ;L->R, LWR
402:
403: ;2 R/W banking window (no need for buffer)
404: ;right-to-left
405: dd 0 ;<not used>
406: dd Thread_R ;R->L, R
407: dd Thread_W ;R->L, W
408: dd Thread_RW ;R->L, RW
409: dd Thread_L ;R->L, L
410: dd Thread_RL ;R->L, RL
411: dd Thread_WL ;R->L, WL
412: dd Thread_RWL ;R->L, RWL
413: ;left-to-right
414: dd 0 ;<not used>
415: dd Thread_R ;L->R, R
416: dd Thread_W ;L->R, W
417: dd Thread_WR ;L->R, WR
418: dd Thread_L ;L->R, L
419: dd Thread_LR ;L->R, LR
420: dd Thread_LW ;L->R, LW
421: dd Thread_LWR ;L->R, LWR
422:
423:
424: ; Amount to shift adapter type field left for use in MasterThreadTableViaBuffer.
425:
426: ADAPTER_FIELD_SHIFT equ 4
427:
428: ; Mask for setting left-to-right bit to "left-to-right true" for use in both
429: ; MasterThread tables.
430:
431: LEFT_TO_RIGHT_FIELD_SET equ 1000b
432:
433:
434: ; Table of top-to-bottom loops for adapter types.
435:
436: align 4
437: TopToBottomLoopTable label dword
438: dd top_to_bottom_2RW ;unbanked is same as 2RW
439: dd top_to_bottom_1RW
440: dd top_to_bottom_1R1W
441: dd top_to_bottom_2RW
442:
443:
444: ; Table of bottom-to-top loops for adapter types.
445:
446: align 4
447: BottomToTopLoopTable label dword
448: dd bottom_to_top_2RW ;unbanked is same as 2RW
449: dd bottom_to_top_1RW
450: dd bottom_to_top_1R1W
451: dd bottom_to_top_2RW
452:
453:
454: ; Table of routines for setting up to copy in various directions.
455:
456: align 4
457: SetUpForCopyDirection label dword
458: dd left_to_right_top_to_bottom ;CD_RIGHTDOWN
459: dd right_to_left_top_to_bottom ;CD_LEFTDOWN
460: dd left_to_right_bottom_to_top ;CD_RIGHTUP
461: dd right_to_left_bottom_to_top ;CD_LEFTUP
462:
463: ;-----------------------------------------------------------------------;
464: ; Left edge clip masks for intrabyte start addresses 0 through 7.
465: ; Whole byte cases are flagged as 0ffh.
466:
467: jLeftMaskTable label byte
468: db 0ffh,07fh,03fh,01fh,00fh,007h,003h,001h
469:
470: ;-----------------------------------------------------------------------;
471: ; Right edge clip masks for intrabyte end addresses (non-inclusive)
472: ; 0 through 7. Whole byte cases are flagged as 0ffh.
473:
474: jRightMaskTable label byte
475: db 0ffh,080h,0c0h,0e0h,0f0h,0f8h,0fch,0feh
476:
477: ;-----------------------------------------------------------------------;
478: ; Table of width-based source-edge-to-buffer copy routines.
479:
480: align 4
481: copy_edge_from_screen_to_buffer label dword
482: dd copy_screen_to_buffered_edge_1ws
483: dd copy_screen_to_buffered_edge_2ws
484:
485: ;-----------------------------------------------------------------------;
486: ; Table of width-based buffer-to-dest-edge copy routines.
487:
488: align 4
489: copy_edge_from_buffer_to_screen label dword
490: dd copy_buffered_edge_to_screen_1ws
491: dd copy_buffered_edge_to_screen_2ws
492:
493: ;-----------------------------------------------------------------------;
494: ; Table of width-based edge copy routines (no intermediate buffer).
495:
496: align 4
497: copy_edge_table label dword
498: dd copy_edge_1ws
499: dd copy_edge_2ws
500:
501: ;-----------------------------------------------------------------------;
502:
503: .code
504:
505: _TEXT$04 SEGMENT DWORD USE32 PUBLIC 'CODE'
506: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
507:
508: ;-----------------------------------------------------------------------;
509:
510: cProc vNonAlignedSrcCopy,16,< \
511: uses esi edi ebx, \
512: pdsurf: ptr DEVSURF, \
513: prcldest : ptr RECTL, \
514: pptlsrc : ptr POINTL, \
515: icopydir : dword
516:
517: local culWholeBytesWidth : dword ;# of bytes to copy across each scan
518: local ulBlockHeight : dword ;# of scans to copy per bank block
519: local ulWholeScanDelta : dword;offset from end of one whole bytes
520: ; scan to start of next
521: local ulWholeBytesSrc : dword ;offset in bitmap of first source whole
522: ; byte to copy from
523: local ulWholeBytesDest : dword;offset in bitmap of first source whole
524: ; byte to copy to
525: local ulLeftEdgeSrc : dword ;offset in bitmap of first source left
526: ; edge byte to copy from
527: local ulLeftEdgeDest : dword ;offset in bitmap of first dest left
528: ; edge byte to copy to
529: local ulRightEdgeSrc : dword ;offset in bitmap of first source right
530: ; edge byte to copy from
531: local ulRightEdgeDest : dword ;offset in bitmap of first dest right
532: ; edge byte to copy to
533: local ulNextScan : dword ;width of scan, in bytes
534: local jLeftMask : dword ;left edge clip mask
535: local jRightMask : dword ;right edge clip mask
536: local culTempCount : dword ;handy temporary counter
537: local pTempEntry : dword ;temporary storage for vector into
538: ; unrolled loop
539: local pTempPlane : dword ;pointer to storage in temp buffer for
540: ; edge bytes (which are stored
541: ; consecutively, not in each plane's
542: ; temp buffer, to reduce possible page
543: ; faulting
544: local ppTempPlane0 : dword ;pointer to pointer to storage in temp
545: ; buffer for plane 0, immediately
546: ; preceded by storage for planes 1, 2,
547: ; and 3
548: local ppTempPlane3 : dword ;like above, but for plane 3
549: local ulOffsetInBank : dword ;offset relative to bank start
550: local pSrcAddr : dword ;working pointer to first source
551: ; byte to copy from
552: local pDestAddr : dword ;working pointer to first dest
553: ; byte to copy to
554: local ulCurrentJustification:dword ;justification used to map in
555: ; banks; top for top to bottom
556: ; copies, bottom for bottom to top
557: local ulCurrentSrcScan :dword ;scan line used to map in current
558: ; source bank
559: local ulCurrentDestScan:dword ;scan line used to map in current dest
560: ; bank
561: local ulLastDestScan :dword ;scan in target rect at which we stop
562: ; advancing through banks
563: local pCurrentThread : dword ;pointer to data describing the
564: ; threaded calls to be performed to
565: ; perform the current copy
566: local pCurrentThreadViaBuffer:dword
567: ;pointer to data describing the
568: ; threaded calls to be performed to
569: ; perform the current copy in the case
570: ; where the source and destination are
571: ; not simultaneously adequately
572: ; accessible, so the copy has to go
573: ; through a temp buffer (used only for
574: ; 1 R/W and 1R/1W banking)
575: local ulAdapterType : dword ;adapter type code, per VIDEO_BANK_TYPE
576: local ulLWRType : dword ;whether left edge, whole bytes, and
577: ; right edge are involved in the
578: ; current operation;
579: ; bit 2 = 1 if left edge involved
580: ; bit 1 = 1 if whole bytes involved
581: ; bit 0 = 1 if right edge involved
582: local ulLeftEdgeAdjust :dword ;used to bump the whole bytes start
583: ; address past the left edge when the
584: ; left edge is partial
585: local ulCombineMask : dword ;mask for combining desired portions
586: ; of AL and AH before ORing to make a
587: ; single byte; used to combine before
588: ; letting VGA rotate byte as it's
589: ; written. Used for all cases except
590: ; whole bytes copied left-to-right
591: local ulCombineMaskWhole : dword
592: ;mask for combining desired portions of
593: ; AL and AH when copying whole bytes
594: ; (different from ulCombineMask in the
595: ; case of whole bytes left-to-right
596: ; copies, because then AH is the lsb
597: ; and AL is the MSB; then, this is
598: ; ulCombineMask with the bytes swapped.
599: ; For right-to-left whole byte copies,
600: ; this is the same as ulCombineMask)
601: local ulTempScanCount : dword ;temp scan line countdown variable
602: local ulWholeScanSrcDelta : dword
603: ;offset from end of one source whole
604: ; bytes scan line to start of next.
605: ; Differs from ulWholeScanDelta because
606: ; of source rotation pipeline priming
607: local ulLeftSrcWidthMinus1 : dword ;# of bytes in left src edge minus
608: ; one (0 or 1)
609: local ulRightSrcWidthMinus1 : dword ;# of bytes in right src edge
610: ; minus one (0 or 1)
611:
612: ;-----------------------------------------------------------------------;
613:
614: ; Set pointers to temp buffer plane pointers (used only by 1 R/W and 1R/1W
615: ; adapters), and other rectangle-independent variables.
616:
617: mov esi,pdsurf
618: mov eax,[esi].dsurf_pvBankBufferPlane0
619: mov pTempPlane,eax
620: lea eax,[esi].dsurf_pvBankBufferPlane0
621: mov ppTempPlane0,eax
622: lea eax,[esi].dsurf_pvBankBufferPlane3
623: mov ppTempPlane3,eax
624:
625: mov eax,[esi].dsurf_vbtBankingType
626: mov ulAdapterType,eax
627:
628: ; Copy the rectangle.
629:
630: call copy_rect
631:
632: ;-----------------------------------------------------------------------;
633: ; Set the VGA registers back to their default state.
634: ;-----------------------------------------------------------------------;
635:
636: mov edx,VGA_BASE + GRAF_ADDR
637: mov eax,(0ffh shl 8) + GRAF_BIT_MASK
638: out dx,ax ;enable bit mask for all bits
639:
640: mov eax,(DR_SET shl 8) + GRAF_DATA_ROT
641: out dx,ax ;restore default of no rotation
642:
643: mov dl,SEQ_DATA
644: mov al,MM_ALL
645: out dx,al ;enable writes to all planes
646:
647: cld ;restore default direction flag
648:
649: cRet vNonAlignedSrcCopy ;done
650:
651:
652: ;***********************************************************************;
653: ;
654: ; Copies the specified rectangle.
655: ;
656: ;***********************************************************************;
657:
658: align 4
659: copy_rect:
660:
661: ; Calculate the rotation, set up the VGA's rotator, and set the byte-combining
662: ; masks.
663:
664: mov edi,prcldest ;left edge of destination
665: mov esi,pptlsrc
666: mov ah,byte ptr [edi].xLeft ;left edge of source
667: sub ah,byte ptr [esi].ptl_x
668: and ah,07h ;rotation = (dest - source) % 8
669: mov edx,VGA_BASE + GRAF_ADDR
670: mov al,GRAF_DATA_ROT
671: out dx,ax ;set the VGA's rotator for the rotation
672:
673: ; Set up byte-combining mask, in preparation for ORing and letting the VGA's
674: ; rotator rotate, assuming the left-hand source byte is in AL and the
675: ; right-hand source byte is in AH (true for all cases except left-to-right
676: ; whole bytes).
677:
678: mov cl,ah
679: mov eax,0000ff00h
680: rol ax,cl
681: mov ulCombineMask,eax
682:
683: ; Calculate source edge widths (1 or 2 bytes).
684:
685: sub edx,edx ;assume right source width is 1
686: mov ebx,[edi].xLeft
687: mov ecx,[edi].xRight ;dest right edge (non-inclusive)
688: dec ecx ;make it inclusive
689: sub ecx,ebx ;dest width = dest right - dest left
690: mov eax,[esi].ptl_x
691: add ecx,eax ;ECX = right edge of source
692: xor eax,ecx
693: and eax,not 07h ;do the src start and end differ in byte
694: ; address bits? (as opposed to intrabyte)
695: jz short @F ;no, force 1-wide source
696:
697: mov al,byte ptr [edi].xLeft
698: mov ah,byte ptr [esi].ptl_x
699: and eax,00000707h
700: cmp ah,al
701: jb short @F
702: inc edx ;left source width is 2
703: @@:
704: mov ulLeftSrcWidthMinus1,edx
705:
706: sub edx,edx ;assume right source width is 1
707: mov eax,[edi].xRight ;dest right edge (non-inclusive)
708: dec eax ;make it inclusive
709: and cl,07h ;intrabyte source address
710: and al,07h ;intrabyte dest address
711: cmp cl,al
712: ja short @F
713: inc edx ;right source width is 2
714: @@:
715: mov ulRightSrcWidthMinus1,edx
716:
717: ; Set up masks and whole bytes count, and build left/whole/right index
718: ; indicating which of those parts are involved in the copy.
719:
720: mov ebx,[edi].xRight ;right edge of fill (non-inclusive)
721: mov ecx,ebx
722: and ecx,0111b ;intrabyte address of right edge
723: mov ah,jRightMaskTable[ecx] ;right edge mask
724:
725: mov esi,[edi].xLeft ;left edge of fill (inclusive)
726: mov ecx,esi
727: shr ecx,3 ;/8 for start offset from left edge
728: ; of scan line
729: sub ebx,esi ;width in pixels of fill
730:
731: and esi,0111b ;intrabyte address of left edge
732: mov al,jLeftMaskTable[esi] ;left edge mask
733:
734: dec ebx ;make inclusive on right
735: add ebx,esi ;inclusive width, starting counting at
736: ; the beginning of the left edge byte
737: shr ebx,3 ;width of fill in bytes touched - 1
738: jnz short more_than_1_byte ;more than 1 byte is involved
739:
740: ; Only one byte will be affected. Combine first/last masks.
741:
742: and al,ah ;we'll use first byte mask only
743: xor ah,ah ;want last byte mask to be 0 to
744: ; indicate right edge not involved
745: inc ebx ;so there's one count to subtract below
746: ; if this isn't a whole edge byte
747: more_than_1_byte:
748:
749: ; If all pixels in the left edge are altered, combine the first byte into the
750: ; whole byte count, because we can handle solid edge bytes faster as part of
751: ; the whole bytes. Ditto for the right edge.
752:
753: sub ecx,ecx ;edge whole-status accumulator
754: cmp al,-1 ;is left edge a whole byte or partial?
755: adc ecx,ecx ;ECX=1 if left edge partial, 0 if whole
756: sub ebx,ecx ;if left edge partial, deduct it from
757: ; the whole bytes count
758: mov ulLeftEdgeAdjust,ecx ;for skipping over the left edge if
759: ; it's partial when pointing to the
760: ; whole bytes
761: and ah,ah ;is right edge mask 0, meaning this
762: ; fill is only 1 byte wide?
763: jz short save_masks ;yes, no need to do anything
764: or ecx,40h ;assume there's a partial right edge
765: cmp ah,-1 ;is right edge a whole byte or partial?
766: jnz short save_masks ;partial
767: ;bit 1=0 if left edge partial, 1 whole
768: inc ebx ;if right edge whole, include it in the
769: ; whole bytes count
770: and ecx,not 40h ;there's no partial right edge
771: save_masks:
772: cmp ebx,1 ;do we have any whole bytes?
773: cmc ;CF set if whole byte count > 0
774: adc ecx,ecx ;if any whole bytes, set whole bytes
775: ; bit in left/whole/right accumulator
776: rol cl,1 ;align the left/whole/right bits
777: mov ulLWRType,ecx ;save left/whole/right status
778:
779: mov byte ptr jLeftMask,al ;save left and right clip masks
780: mov byte ptr jRightMask,ah
781: mov culWholeBytesWidth,ebx ;save # of whole bytes
782:
783: ; Copy the rectangle in the specified direction.
784:
785: mov eax,icopydir
786: jmp SetUpForCopyDirection[eax*4]
787:
788:
789: ;***********************************************************************;
790: ;
791: ; The following routines set up to handle the four possible copy
792: ; directions.
793: ;
794: ;***********************************************************************;
795:
796:
797: ;-----------------------------------------------------------------------;
798: ; Set-up code for left-to-right, top-to-bottom copies.
799: ;-----------------------------------------------------------------------;
800:
801: align 4
802: left_to_right_top_to_bottom:
803:
804: cld ;we'll copy left to right
805:
806: ; Byte-combining mask, in preparation for ORing and letting the VGA's rotator
807: ; rotate, assuming the left-hand source byte is in AH and the right-hand source
808: ; byte is in AL (true only for left-to-right whole bytes).
809:
810: mov eax,ulCombineMask
811: not eax
812: mov ulCombineMaskWhole,eax
813:
814: mov esi,pdsurf
815: mov eax,[esi].dsurf_lNextScan
816: mov ulNextScan,eax ;copy top to bottom
817: sub eax,culWholeBytesWidth ;offset from end of one dest whole byte
818: mov ulWholeScanDelta,eax ; scan to start of next
819: dec eax ;offset from end of one src whole byte
820: mov ulWholeScanSrcDelta,eax ; scan to start of next, accounting for
821: ; leading byte used to prime the
822: ; rotation pipeline
823:
824: mov esi,ulLWRType ;3-bit flag field for left, whole, and
825: ; right involvement in operation
826: or esi,LEFT_TO_RIGHT_FIELD_SET ;add left-to-right into the index
827: mov eax,MasterThreadTable[esi*4]
828: mov pCurrentThread,eax ;threading when no buffering is needed
829: mov edx,ulAdapterType
830: shl edx,ADAPTER_FIELD_SHIFT
831: or esi,edx ;factor adapter type into the index
832: mov eax,MasterThreadTableViaBuffer[esi*4]
833: mov pCurrentThreadViaBuffer,eax ;threading when buffering is needed
834:
835: mov ulCurrentJustification,JustifyTop ;copy top to bottom
836:
837: mov esi,prcldest
838: mov eax,[esi].yBottom
839: mov ulLastDestScan,eax ;end at bottom of dest copy rect
840: mov eax,[esi].yTop
841: mov ulCurrentDestScan,eax ;start at top of dest copy rect
842: mul ulNextScan ;offset in bitmap of top dest rect scan
843: mov edx,[esi].xLeft
844: shr edx,3 ;byte X address
845: add eax,edx ;offset in bitmap of first dest byte
846: mov ulLeftEdgeDest,eax ;that's where the left dest edge is
847: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next
848: ; byte, unless the left edge is a whole
849: ; byte and is thus part of the whole
850: ; bytes already
851: mov ulWholeBytesDest,eax ;where the whole dest bytes start
852: add eax,culWholeBytesWidth ;point to the right edge
853: mov ulRightEdgeDest,eax ;where the right dest edge starts
854:
855: mov esi,pptlsrc
856: mov eax,[esi].ptl_y
857: mov ulCurrentSrcScan,eax ;start at top of source copy rect
858: mul ulNextScan ;offset in bitmap of top dest rect scan
859: mov edx,[esi].ptl_x
860: shr edx,3 ;byte X address
861: add eax,edx ;offset in bitmap of first source byte
862: mov ulLeftEdgeSrc,eax ;that's where the left src edge is
863: add eax,ulLeftSrcWidthMinus1 ;the first whole byte includes the
864: dec eax ; last (leftmost) left edge byte, so
865: add eax,ulLeftEdgeAdjust ; add a byte if the left edge is 2
866: ; wide, except when the left dest byte
867: ; is solid so the left edge is part of
868: ; the whole bytes
869: mov ulWholeBytesSrc,eax ;where the src whole bytes start
870: add eax,culWholeBytesWidth ;point to the right edge
871: mov ulRightEdgeSrc,eax ;where the right src edge starts,
872: ; because the whole bytes and the right
873: ; source edge share a byte, and we
874: ; always point to the leftmost byte in
875: ; the right source edge
876:
877: ; Branch to the appropriate top-to-bottom bank enumeration loop.
878:
879: mov eax,ulAdapterType
880: jmp TopToBottomLoopTable[eax*4]
881:
882:
883: ;-----------------------------------------------------------------------;
884: ; Set-up code for right-to-left, top-to-bottom copies.
885: ;-----------------------------------------------------------------------;
886:
887: align 4
888: right_to_left_top_to_bottom:
889:
890: std ;we'll copy right to left
891:
892: ; Byte-combining mask, in preparation for ORing and letting the VGA's rotator
893: ; rotate, assuming the left-hand source byte is in AL and the right-hand source
894: ; byte is in AH (always true except for left-to-right whole bytes).
895:
896: mov eax,ulCombineMask
897: mov ulCombineMaskWhole,eax
898:
899: mov esi,pdsurf
900: mov eax,[esi].dsurf_lNextScan
901: mov ulNextScan,eax ;copy top to bottom
902: add eax,culWholeBytesWidth ;offset from end of one whole byte scan
903: mov ulWholeScanDelta,eax ; to start of next, given that we're
904: ; copying one way and going scan-to-
905: ; scan the other way
906: inc eax ;offset from end of one src whole byte
907: mov ulWholeScanSrcDelta,eax ; scan to start of next, accounting for
908: ; leading byte used to prime the
909: ; rotation pipeline
910:
911: mov esi,ulLWRType ;3-bit flag field for left, whole, and
912: ; right involvement in operation
913: ;leave left-to-right field cleared, so
914: ; we look up right-to-left entries
915: mov eax,MasterThreadTable[esi*4]
916: mov pCurrentThread,eax ;threading when no buffering is needed
917: mov edx,ulAdapterType
918: shl edx,ADAPTER_FIELD_SHIFT
919: or esi,edx ;factor adapter type into the index
920: mov eax,MasterThreadTableViaBuffer[esi*4]
921: mov pCurrentThreadViaBuffer,eax ;threading when buffering is needed
922:
923: mov ulCurrentJustification,JustifyTop ;copy top to bottom
924:
925: mov esi,prcldest
926: mov eax,[esi].yBottom
927: mov ulLastDestScan,eax ;end at bottom of dest copy rect
928: mov eax,[esi].yTop
929: mov ulCurrentDestScan,eax ;start at top of dest copy rect
930: mul ulNextScan ;offset in bitmap of top dest rect scan
931: mov edx,[esi].xLeft
932: shr edx,3 ;byte X address
933: add eax,edx ;offset in bitmap of first dest byte
934: mov ulLeftEdgeDest,eax ;that's where the left dest edge is
935: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next
936: ; byte, unless the left edge is a whole
937: ; byte and is thus part of the whole
938: ; bytes already
939: add eax,culWholeBytesWidth ;point to the right edge
940: mov ulRightEdgeDest,eax ;where the right dest edge starts
941: dec eax ;back up to the last whole byte
942: mov ulWholeBytesDest,eax ;where the whole dest bytes start
943:
944: mov esi,pptlsrc
945: mov eax,[esi].ptl_y
946: mov ulCurrentSrcScan,eax ;start at top of source copy rect
947: mul ulNextScan ;offset in bitmap of top dest rect scan
948: mov edx,[esi].ptl_x
949: shr edx,3 ;byte X address
950: add eax,edx ;offset in bitmap of first source byte
951: mov ulLeftEdgeSrc,eax ;that's where the left src edge is
952: add eax,ulLeftSrcWidthMinus1 ;the first whole byte includes the
953: dec eax ; last (leftmost) left edge byte, so
954: add eax,ulLeftEdgeAdjust ; add a byte if the left edge is 2
955: ; wide, except when the left dest byte
956: ; is solid so the left edge is part of
957: ; the whole bytes
958: add eax,culWholeBytesWidth ;point to the right edge of the whole
959: ; src bytes, accounting for the extra
960: ; source byte needed to prime the
961: ; rotation pipeline
962: mov ulWholeBytesSrc,eax ;where the src whole bytes start
963: mov ulRightEdgeSrc,eax ;that's also where the right src edge
964: ; starts, because the whole bytes and
965: ; the right source edge share a byte,
966: ; and we always point to the leftmost
967: ; byte in the right source edge
968:
969: ; Branch to the appropriate top-to-bottom bank enumeration loop.
970:
971: mov eax,ulAdapterType
972: jmp TopToBottomLoopTable[eax*4]
973:
974:
975: ;-----------------------------------------------------------------------;
976: ; Set-up code for left-to-right, bottom-to-top copies.
977: ;-----------------------------------------------------------------------;
978:
979: align 4
980: left_to_right_bottom_to_top:
981:
982: cld ;we'll copy left to right
983:
984: ; Byte-combining mask, in preparation for ORing and letting the VGA's rotator
985: ; rotate, assuming the left-hand source byte is in AH and the right-hand source
986: ; byte is in AL (true only for left-to-right whole bytes).
987:
988: mov eax,ulCombineMask
989: not eax
990: mov ulCombineMaskWhole,eax
991:
992: mov edi,pdsurf
993: mov eax,[edi].dsurf_lNextScan
994: neg eax
995: mov ulNextScan,eax ;copy bottom to top
996: sub eax,culWholeBytesWidth ;offset from end of one whole byte scan
997: mov ulWholeScanDelta,eax ; to start of next, given that we're
998: ; copying one way and going scan-to-
999: ; scan the other way
1000: dec eax ;offset from end of one src whole byte
1001: mov ulWholeScanSrcDelta,eax ; scan to start of next, accounting for
1002: ; leading byte used to prime the
1003: ; rotation pipeline
1004:
1005: mov esi,ulLWRType ;3-bit flag field for left, whole, and
1006: ; right involvement in operation
1007: or esi,LEFT_TO_RIGHT_FIELD_SET ;add left-to-right into the index
1008: mov eax,MasterThreadTable[esi*4]
1009: mov pCurrentThread,eax ;threading when no buffering is needed
1010: mov edx,ulAdapterType
1011: shl edx,ADAPTER_FIELD_SHIFT
1012: or esi,edx ;factor adapter type into the index
1013: mov eax,MasterThreadTableViaBuffer[esi*4]
1014: mov pCurrentThreadViaBuffer,eax ;threading when buffering is needed
1015:
1016: mov ulCurrentJustification,JustifyBottom ;copy bottom to top
1017:
1018: mov esi,prcldest
1019: mov edx,[esi].yTop
1020: mov ulLastDestScan,edx ;end at top of dest copy rect
1021: mov eax,[esi].yBottom
1022: dec eax ;rectangle definition is non-inclusive,
1023: ; so advance to first scan we'll copy
1024: sub edx,eax ;-(offset from rect top to bottom)
1025: push edx ;remember for use with source
1026: mov ulCurrentDestScan,eax ;start at bottom of dest copy rect
1027: mul [edi].dsurf_lNextScan ;offset in bitmap of bottom dest rect
1028: ; scan (first scan to which to copy)
1029: mov edx,[esi].xLeft
1030: shr edx,3 ;byte X address
1031: add eax,edx ;offset in bitmap of first dest byte
1032: mov ulLeftEdgeDest,eax ;that's where the left dest edge is
1033: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next
1034: ; byte, unless the left edge is a whole
1035: ; byte and is thus part of the whole
1036: ; bytes already
1037: mov ulWholeBytesDest,eax ;where the whole dest bytes start
1038: add eax,culWholeBytesWidth ;point to the right edge
1039: mov ulRightEdgeDest,eax ;where the right dest edge starts
1040:
1041: mov esi,pptlsrc
1042: mov eax,[esi].ptl_y
1043: pop edx ;retrieve -(offset from top to bottom)
1044: sub eax,edx ;advance to bottom of source rect
1045: ; (inclusive; this is first scan from
1046: ; which to copy)
1047: mov ulCurrentSrcScan,eax ;start at bottom of source copy rect
1048: mul [edi].dsurf_lNextScan ;offset in bitmap of bottom dest rect
1049: ; scan
1050: mov edx,[esi].ptl_x
1051: shr edx,3 ;byte X address
1052: add eax,edx ;offset in bitmap of first source byte
1053: mov ulLeftEdgeSrc,eax ;that's where the left src edge is
1054: add eax,ulLeftSrcWidthMinus1 ;the first whole byte includes the
1055: dec eax ; last (leftmost) left edge byte, so
1056: add eax,ulLeftEdgeAdjust ; add a byte if the left edge is 2
1057: ; wide, except when the left dest byte
1058: ; is solid so the left edge is part of
1059: ; the whole bytes
1060: mov ulWholeBytesSrc,eax ;where the src whole bytes start
1061: add eax,culWholeBytesWidth ;point to the right edge
1062: mov ulRightEdgeSrc,eax ;where the right src edge starts,
1063: ; because the whole bytes and the right
1064: ; source edge share a byte, and we
1065: ; always point to the leftmost byte in
1066: ; the right source edge
1067:
1068: ; Branch to the appropriate bottom-to-top bank enumeration loop.
1069:
1070: mov eax,ulAdapterType
1071: jmp BottomToTopLoopTable[eax*4]
1072:
1073:
1074: ;-----------------------------------------------------------------------;
1075: ; Set-up code for right-to-left, bottom-to-top copies.
1076: ;-----------------------------------------------------------------------;
1077:
1078: align 4
1079: right_to_left_bottom_to_top:
1080:
1081: std ;we'll copy right to left
1082:
1083: ; Byte-combining mask, in preparation for ORing and letting the VGA's rotator
1084: ; rotate, assuming the left-hand source byte is in AL and the right-hand source
1085: ; byte is in AH (always true except for left-to-right whole bytes).
1086:
1087: mov eax,ulCombineMask
1088: mov ulCombineMaskWhole,eax
1089:
1090: mov edi,pdsurf
1091: mov eax,[edi].dsurf_lNextScan
1092: neg eax
1093: mov ulNextScan,eax ;copy bottom to top
1094: add eax,culWholeBytesWidth ;offset from end of one whole byte scan
1095: mov ulWholeScanDelta,eax ; to start of next
1096: inc eax ;offset from end of one src whole byte
1097: mov ulWholeScanSrcDelta,eax ; scan to start of next, accounting for
1098: ; leading byte used to prime the
1099: ; rotation pipeline
1100:
1101: mov esi,ulLWRType ;3-bit flag field for left, whole, and
1102: ; right involvement in operation
1103: ;leave left-to-right field cleared, so
1104: ; we look up right-to-left entries
1105: mov eax,MasterThreadTable[esi*4]
1106: mov pCurrentThread,eax ;threading when no buffering is needed
1107: mov edx,ulAdapterType
1108: shl edx,ADAPTER_FIELD_SHIFT
1109: or esi,edx ;factor adapter type into the index
1110: mov eax,MasterThreadTableViaBuffer[esi*4]
1111: mov pCurrentThreadViaBuffer,eax ;threading when buffering is needed
1112:
1113: mov ulCurrentJustification,JustifyBottom ;copy bottom to top
1114:
1115: mov esi,prcldest
1116: mov edx,[esi].yTop
1117: mov ulLastDestScan,edx ;end at top of dest copy rect
1118: mov eax,[esi].yBottom
1119: dec eax ;rectangle definition is non-inclusive,
1120: ; so advance to first scan we'll copy
1121: sub edx,eax ;-(offset from rect top to bottom)
1122: push edx ;remember for use with source
1123: mov ulCurrentDestScan,eax ;start at bottom of dest copy rect
1124: mul [edi].dsurf_lNextScan ;offset in bitmap of bottom dest rect
1125: ; scan (first scan to which to copy)
1126: mov edx,[esi].xLeft
1127: shr edx,3 ;byte X address
1128: add eax,edx
1129: mov ulLeftEdgeDest,eax ;that's where the left dest edge is
1130: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next
1131: ; byte, unless the left edge is a whole
1132: ; byte and is thus part of the whole
1133: ; bytes already
1134: add eax,culWholeBytesWidth ;point to the right edge
1135: mov ulRightEdgeDest,eax ;where the right dest edge starts
1136: dec eax ;back up to the last whole byte
1137: mov ulWholeBytesDest,eax ;where the whole dest bytes start
1138:
1139: mov esi,pptlsrc
1140: mov eax,[esi].ptl_y
1141: pop edx ;retrieve -(offset from top to bottom)
1142: sub eax,edx ;advance to bottom of source rect
1143: ; (inclusive; this is first scan from
1144: ; which to copy)
1145: mov ulCurrentSrcScan,eax ;start at bottom of source copy rect
1146: mul [edi].dsurf_lNextScan ;offset in bitmap of bottom dest rect
1147: ; scan
1148: mov edx,[esi].ptl_x
1149: shr edx,3 ;byte X address
1150: add eax,edx ;offset in bitmap of first source byte
1151: mov ulLeftEdgeSrc,eax ;that's where the left src edge is
1152: add eax,ulLeftSrcWidthMinus1 ;the first whole byte includes the
1153: dec eax ; last (leftmost) left edge byte, so
1154: add eax,ulLeftEdgeAdjust ; add a byte if the left edge is 2
1155: ; wide, except when the left dest byte
1156: ; is solid so the left edge is part of
1157: ; the whole bytes
1158: add eax,culWholeBytesWidth ;point to the right edge of the whole
1159: ; src bytes, accounting for the extra
1160: ; source byte needed to prime the
1161: ; rotation pipeline
1162: mov ulWholeBytesSrc,eax ;where the src whole bytes start
1163: mov ulRightEdgeSrc,eax ;that's also where the right src edge
1164: ; starts, because the whole bytes and
1165: ; the right source edge share a byte,
1166: ; and we always point to the leftmost
1167: ; byte in the right source edge
1168:
1169: ; Branch to the appropriate bottom-to-top bank enumeration loop.
1170:
1171: mov eax,ulAdapterType
1172: jmp BottomToTopLoopTable[eax*4]
1173:
1174:
1175: ;***********************************************************************;
1176: ;
1177: ; The following routines are the banking loops.
1178: ;
1179: ;***********************************************************************;
1180:
1181:
1182: ;-----------------------------------------------------------------------;
1183: ; Banking for 2 R/W and unbanked adapters, top to bottom.
1184: ;-----------------------------------------------------------------------;
1185: align 4
1186: top_to_bottom_2RW:
1187:
1188: ; We're going top to bottom. Map in the source and dest, top-justified.
1189:
1190: mov ebx,pdsurf
1191: mov edx,ulCurrentSrcScan
1192: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is source top less than
1193: ; current source bank?
1194: jl short top_2RW_map_init_src_bank ;yes, map in proper bank
1195: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;source top greater than
1196: ; current source bank?
1197: jl short top_2RW_init_src_bank_mapped
1198: ;no, proper bank already mapped
1199: top_2RW_map_init_src_bank:
1200:
1201: ; Map bank containing the top source scan line into source window.
1202: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1203:
1204: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1205: <ebx,edx,JustifyTop,MapSourceBank>
1206:
1207: top_2RW_init_src_bank_mapped:
1208:
1209: mov edx,ulCurrentDestScan
1210: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is dest top less than
1211: ; current dest bank?
1212: jl short top_2RW_map_init_dest_bank ;yes, map in proper bank
1213: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest top greater than
1214: ; current dest bank?
1215: jl short top_2RW_init_dest_bank_mapped
1216: ;no, proper bank already mapped
1217: top_2RW_map_init_dest_bank:
1218:
1219: ; Map bank containing the top dest scan line into source window.
1220: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1221:
1222: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1223: <ebx,edx,JustifyTop,MapDestBank>
1224:
1225: top_2RW_init_dest_bank_mapped:
1226:
1227: ; Bank-by-bank top-to-bottom copy loop.
1228:
1229: top_2RW_bank_loop:
1230:
1231: ; Decide how far we can go before we run out of bank or rectangle to copy.
1232:
1233: mov edx,ulLastDestScan
1234: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom
1235: jl short @F ;copy rectangle bottom is in this bank
1236: mov edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest extends to end
1237: ; of bank, at least
1238: @@:
1239: sub edx,ulCurrentDestScan ;# of scans we can and want to do in
1240: ; the dest bank
1241: mov eax,[ebx].dsurf_rcl2WindowClipS.yBottom
1242: sub eax,ulCurrentSrcScan ;# of scans we can do in the src bank
1243:
1244: cmp edx,eax
1245: jb short @F ;source bank isn't limiting
1246: mov edx,eax ;source bank is limiting
1247: @@:
1248: mov ulBlockHeight,edx ;# of scans we'll do in this bank
1249:
1250: ; We're ready to copy this block.
1251:
1252: THREAD_AND_START
1253:
1254: ; Any more scans to copy?
1255:
1256: mov eax,ulCurrentDestScan
1257: mov esi,ulBlockHeight
1258: add eax,esi ;we've copied to dest up to here
1259: cmp ulLastDestScan,eax ;are we at the dest rect bottom?
1260: jz short top_2RW_done ;yes, we're done
1261: mov ulCurrentDestScan,eax
1262:
1263: ; Now advance either or both banks, as needed.
1264:
1265: mov ebx,pdsurf
1266: cmp eax,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest scan greater than
1267: ; current dest bank?
1268: jl short top_2RW_dest_bank_mapped ;no, proper bank still mapped
1269:
1270: ; Map bank containing the current dest scan line into source window.
1271: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1272:
1273: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1274: <ebx,eax,JustifyTop,MapDestBank>
1275:
1276: top_2RW_dest_bank_mapped:
1277:
1278: add esi,ulCurrentSrcScan ;we've copied from source up to here
1279: mov ulCurrentSrcScan,esi
1280:
1281: cmp esi,[ebx].dsurf_rcl2WindowClipS.yBottom ;src scan greater than
1282: ; current src bank?
1283: jl short top_2RW_src_bank_mapped ;no, proper bank still mapped
1284:
1285: ; Map bank containing the current source scan line into source window.
1286: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1287:
1288: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1289: <ebx,esi,JustifyTop,MapSourceBank>
1290:
1291: top_2RW_src_bank_mapped:
1292:
1293: jmp top_2RW_bank_loop
1294:
1295: top_2RW_done:
1296: PLAIN_RET
1297:
1298:
1299: ;-----------------------------------------------------------------------;
1300: ; Banking for 2 R/W and unbanked adapters, bottom to top.
1301: ;-----------------------------------------------------------------------;
1302: align 4
1303: bottom_to_top_2RW:
1304:
1305: ; We're going bottom to top. Map in the source and dest, bottom-justified.
1306:
1307: mov ebx,pdsurf
1308: mov edx,ulCurrentSrcScan
1309: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is source bottom less than
1310: ; current source bank?
1311: jl short bot_2RW_map_init_src_bank ;yes, map in proper bank
1312: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;source bottom greater
1313: ; than current src bank?
1314: jl short bot_2RW_init_src_bank_mapped
1315: ;no, proper bank already mapped
1316: bot_2RW_map_init_src_bank:
1317:
1318: ; Map bank containing the bottom source scan line into source window.
1319: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1320:
1321: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1322: <ebx,edx,JustifyBottom,MapSourceBank>
1323:
1324: bot_2RW_init_src_bank_mapped:
1325:
1326: mov edx,ulCurrentDestScan
1327: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is dest bottom less than
1328: ; current dest bank?
1329: jl short bot_2RW_map_init_dest_bank ;yes, map in proper bank
1330: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest bottom greater
1331: ; than current dst bank?
1332: jl short bot_2RW_init_dest_bank_mapped
1333: ;no, proper bank already mapped
1334: bot_2RW_map_init_dest_bank:
1335:
1336: ; Map bank containing the bottom dest scan line into source window.
1337: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1338:
1339: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1340: <ebx,edx,JustifyBottom,MapDestBank>
1341:
1342: bot_2RW_init_dest_bank_mapped:
1343:
1344: ; Bank-by-bank bottom-to-top copy loop.
1345:
1346: bot_2RW_bank_loop:
1347:
1348: ; Decide how far we can go before we run out of bank or rectangle to copy.
1349:
1350: mov edx,ulLastDestScan
1351: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop
1352: jg short @F ;copy rectangle top is in this bank
1353: mov edx,[ebx].dsurf_rcl2WindowClipD.yTop ;dest extends to end
1354: ; of bank, at least
1355: @@:
1356: neg edx
1357: add edx,ulCurrentDestScan ;# of scans we can and want to do in
1358: inc edx ; the dest bank
1359:
1360: mov eax,ulCurrentSrcScan
1361: sub eax,[ebx].dsurf_rcl2WindowClipS.yTop
1362: inc eax ;# of scans we can do in the src bank
1363:
1364: cmp edx,eax
1365: jb short @F ;source bank isn't limiting
1366: mov edx,eax ;source bank is limiting
1367: @@:
1368: mov ulBlockHeight,edx ;# of scans we'll do in this bank
1369:
1370: ; We're ready to copy this block.
1371:
1372: THREAD_AND_START
1373:
1374: ; Any more scans to copy?
1375:
1376: mov eax,ulCurrentDestScan
1377: mov esi,ulBlockHeight
1378: sub eax,esi ;we've copied to dest up to here
1379: cmp ulLastDestScan,eax ;are we past the dest rect top?
1380: jg short bot_2RW_done ;yes, we're done
1381: mov ulCurrentDestScan,eax
1382:
1383: ; Now advance either or both banks, as needed.
1384:
1385: mov ebx,pdsurf
1386: cmp eax,[ebx].dsurf_rcl2WindowClipD.yTop ;dest scan less than
1387: ; current dest bank?
1388: jge short bot_2RW_dest_bank_mapped ;no, proper bank still mapped
1389:
1390: ; Map bank containing the current dest scan line into source window.
1391: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1392:
1393: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1394: <ebx,eax,JustifyBottom,MapDestBank>
1395:
1396: bot_2RW_dest_bank_mapped:
1397:
1398: mov eax,ulCurrentSrcScan
1399: sub eax,esi ;we've copied from source up to here
1400: mov ulCurrentSrcScan,eax
1401:
1402: cmp eax,[ebx].dsurf_rcl2WindowClipS.yTop ;src scan less than
1403: ; current src bank?
1404: jge short bot_2RW_src_bank_mapped ;no, proper bank still mapped
1405:
1406: ; Map bank containing the current source scan line into source window.
1407: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1408:
1409: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1410: <ebx,eax,JustifyBottom,MapSourceBank>
1411:
1412: bot_2RW_src_bank_mapped:
1413:
1414: jmp bot_2RW_bank_loop
1415:
1416: bot_2RW_done:
1417: PLAIN_RET
1418:
1419:
1420: ;-----------------------------------------------------------------------;
1421: ; Banking for 1R/1W adapters, top to bottom.
1422: ;-----------------------------------------------------------------------;
1423: align 4
1424: top_to_bottom_1R1W:
1425:
1426: ; We're going top to bottom. Map in the source and dest, top-justified.
1427:
1428: mov ebx,pdsurf
1429: mov edx,ulCurrentSrcScan
1430: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is source top less than
1431: ; current source bank?
1432: jl short top_1R1W_map_init_src_bank ;yes, map in proper bank
1433: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;source top greater than
1434: ; current source bank?
1435: jl short top_1R1W_init_src_bank_mapped
1436: ;no, proper bank already mapped
1437: top_1R1W_map_init_src_bank:
1438:
1439: ; Map bank containing the top source scan line into source window.
1440: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1441:
1442: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1443: <ebx,edx,JustifyTop,MapSourceBank>
1444:
1445: top_1R1W_init_src_bank_mapped:
1446:
1447: mov edx,ulCurrentDestScan
1448: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is dest top less than
1449: ; current dest bank?
1450: jl short top_1R1W_map_init_dest_bank ;yes, map in proper bank
1451: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest top greater than
1452: ; current dest bank?
1453: jl short top_1R1W_init_dest_bank_mapped
1454: ;no, proper bank already mapped
1455: top_1R1W_map_init_dest_bank:
1456:
1457: ; Map bank containing the top dest scan line into source window.
1458: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1459:
1460: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1461: <ebx,edx,JustifyTop,MapDestBank>
1462:
1463: top_1R1W_init_dest_bank_mapped:
1464:
1465: ; Bank-by-bank top-to-bottom copy loop.
1466:
1467: top_1R1W_bank_loop:
1468:
1469: ; Decide how far we can go before we run out of bank or rectangle to copy.
1470:
1471: mov edx,ulLastDestScan
1472: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom
1473: jl short @F ;copy rectangle bottom is in this bank
1474: mov edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest extends to end
1475: ; of bank, at least
1476: @@:
1477: sub edx,ulCurrentDestScan ;# of scans we can and want to do in
1478: ; the dest bank
1479: mov eax,[ebx].dsurf_rcl2WindowClipS.yBottom
1480: sub eax,ulCurrentSrcScan ;# of scans we can do in the src bank
1481:
1482: cmp edx,eax
1483: jb short @F ;source bank isn't limiting
1484: mov edx,eax ;source bank is limiting
1485: @@:
1486: mov ulBlockHeight,edx ;# of scans we'll do in this bank
1487:
1488: ; We're ready to copy this block.
1489: ; Select different threading, depending on whether the source and destination
1490: ; are currently in the same bank; we can do edges faster if they are.
1491:
1492: mov eax,[ebx].dsurf_ulWindowBank
1493: cmp eax,[ebx].dsurf_ulWindowBank[4]
1494: jz short top_1R1W_copy_same_bank
1495:
1496: ; Source and dest are currently in different banks, must go through temp buffer.
1497:
1498: THREAD_AND_START pCurrentThreadViaBuffer,top_1R1W_check_more_scans
1499:
1500: ; Source and dest are currently in the same bank.
1501:
1502: align 4
1503: top_1R1W_copy_same_bank:
1504: THREAD_AND_START
1505:
1506: ; Any more scans to copy?
1507:
1508: top_1R1W_check_more_scans:
1509:
1510: mov eax,ulCurrentDestScan
1511: mov esi,ulBlockHeight
1512: add eax,esi ;we've copied to dest up to here
1513: cmp ulLastDestScan,eax ;are we at the dest rect bottom?
1514: jz short top_1R1W_done ;yes, we're done
1515: mov ulCurrentDestScan,eax
1516:
1517: ; Now advance either or both banks, as needed.
1518:
1519: mov ebx,pdsurf
1520: cmp eax,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest scan greater than
1521: ; current dest bank?
1522: jl short top_1R1W_dest_bank_mapped ;no, proper bank still mapped
1523:
1524: ; Map bank containing the current dest scan line into source window.
1525: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1526:
1527: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1528: <ebx,eax,JustifyTop,MapDestBank>
1529:
1530: top_1R1W_dest_bank_mapped:
1531:
1532: add esi,ulCurrentSrcScan ;we've copied from source up to here
1533: mov ulCurrentSrcScan,esi
1534:
1535: cmp esi,[ebx].dsurf_rcl2WindowClipS.yBottom ;src scan greater than
1536: ; current src bank?
1537: jl short top_1R1W_src_bank_mapped ;no, proper bank still mapped
1538:
1539: ; Map bank containing the current source scan line into source window.
1540: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1541:
1542: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1543: <ebx,esi,JustifyTop,MapSourceBank>
1544:
1545: top_1R1W_src_bank_mapped:
1546:
1547: jmp top_1R1W_bank_loop
1548:
1549: top_1R1W_done:
1550: PLAIN_RET
1551:
1552:
1553: ;-----------------------------------------------------------------------;
1554: ; Banking for 1R/1W adapters, bottom to top.
1555: ;-----------------------------------------------------------------------;
1556: align 4
1557: bottom_to_top_1R1W:
1558:
1559: ; We're going bottom to top. Map in the source and dest, bottom-justified.
1560:
1561: mov ebx,pdsurf
1562: mov edx,ulCurrentSrcScan
1563: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is source bottom less than
1564: ; current source bank?
1565: jl short bot_1R1W_map_init_src_bank ;yes, map in proper bank
1566: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;source bottom greater
1567: ; than current src bank?
1568: jl short bot_1R1W_init_src_bank_mapped
1569: ;no, proper bank already mapped
1570: bot_1R1W_map_init_src_bank:
1571:
1572: ; Map bank containing the bottom source scan line into source window.
1573: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1574:
1575: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1576: <ebx,edx,JustifyBottom,MapSourceBank>
1577:
1578: bot_1R1W_init_src_bank_mapped:
1579:
1580: mov edx,ulCurrentDestScan
1581: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is dest bottom less than
1582: ; current dest bank?
1583: jl short bot_1R1W_map_init_dest_bank ;yes, map in proper bank
1584: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest bottom greater
1585: ; than current dst bank?
1586: jl short bot_1R1W_init_dest_bank_mapped
1587: ;no, proper bank already mapped
1588: bot_1R1W_map_init_dest_bank:
1589:
1590: ; Map bank containing the bottom dest scan line into source window.
1591: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1592:
1593: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1594: <ebx,edx,JustifyBottom,MapDestBank>
1595:
1596: bot_1R1W_init_dest_bank_mapped:
1597:
1598: ; Bank-by-bank bottom-to-top copy loop.
1599:
1600: bot_1R1W_bank_loop:
1601:
1602: ; Decide how far we can go before we run out of bank or rectangle to copy.
1603:
1604: mov edx,ulLastDestScan
1605: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop
1606: jg short @F ;copy rectangle top is in this bank
1607: mov edx,[ebx].dsurf_rcl2WindowClipD.yTop ;dest extends to end
1608: ; of bank, at least
1609: @@:
1610: neg edx
1611: add edx,ulCurrentDestScan ;# of scans we can and want to do in
1612: inc edx ; the dest bank
1613:
1614: mov eax,ulCurrentSrcScan
1615: sub eax,[ebx].dsurf_rcl2WindowClipS.yTop
1616: inc eax ;# of scans we can do in the src bank
1617:
1618: cmp edx,eax
1619: jb short @F ;source bank isn't limiting
1620: mov edx,eax ;source bank is limiting
1621: @@:
1622: mov ulBlockHeight,edx ;# of scans we'll do in this bank
1623:
1624: ; We're ready to copy this block.
1625: ; Select different threading, depending on whether the source and destination
1626: ; are currently in the same bank; we can do edges faster if they are.
1627:
1628: mov al,byte ptr [ebx].dsurf_ulWindowBank
1629: cmp al,byte ptr [ebx].dsurf_ulWindowBank[4]
1630: jz short bot_1R1W_copy_same_bank
1631:
1632: ; Source and dest are currently in different banks, must go through temp buffer.
1633:
1634: THREAD_AND_START pCurrentThreadViaBuffer,bot_1R1W_check_more_scans
1635:
1636: ; Source and dest are currently in the same bank.
1637:
1638: align 4
1639: bot_1R1W_copy_same_bank:
1640: THREAD_AND_START
1641:
1642: ; Any more scans to copy?
1643:
1644: align 4
1645: bot_1R1W_check_more_scans:
1646:
1647: mov eax,ulCurrentDestScan
1648: mov esi,ulBlockHeight
1649: sub eax,esi ;we've copied to dest up to here
1650: cmp ulLastDestScan,eax ;are we past the dest rect top?
1651: jg short bot_1R1W_done ;yes, we're done
1652: mov ulCurrentDestScan,eax
1653:
1654: ; Now advance either or both banks, as needed.
1655:
1656: mov ebx,pdsurf
1657: cmp eax,[ebx].dsurf_rcl2WindowClipD.yTop ;dest scan less than
1658: ; current dest bank?
1659: jge short bot_1R1W_dest_bank_mapped ;no, proper bank still mapped
1660:
1661: ; Map bank containing the current dest scan line into source window.
1662: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1663:
1664: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1665: <ebx,eax,JustifyBottom,MapDestBank>
1666:
1667: bot_1R1W_dest_bank_mapped:
1668:
1669: mov eax,ulCurrentSrcScan
1670: sub eax,esi ;we've copied from source up to here
1671: mov ulCurrentSrcScan,eax
1672:
1673: cmp eax,[ebx].dsurf_rcl2WindowClipS.yTop ;src scan less than
1674: ; current src bank?
1675: jge short bot_1R1W_src_bank_mapped ;no, proper bank still mapped
1676:
1677: ; Map bank containing the current source scan line into source window.
1678: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1679:
1680: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
1681: <ebx,eax,JustifyBottom,MapSourceBank>
1682:
1683: bot_1R1W_src_bank_mapped:
1684:
1685: jmp bot_1R1W_bank_loop
1686:
1687: bot_1R1W_done:
1688: PLAIN_RET
1689:
1690:
1691: ;-----------------------------------------------------------------------;
1692: ; Banking for 1 R/W adapters, top to bottom.
1693: ;-----------------------------------------------------------------------;
1694: align 4
1695: top_to_bottom_1RW:
1696:
1697: ; We're going top to bottom. Map in the dest, top-justified.
1698:
1699: mov ebx,pdsurf
1700: mov esi,ulCurrentDestScan
1701: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;is dest top less than
1702: ; current bank?
1703: jl short top_1RW_map_init_dest_bank ;yes, map in proper bank
1704: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest top greater than
1705: ; current bank?
1706: jl short top_1RW_init_dest_bank_mapped
1707: ;no, proper bank already mapped
1708: top_1RW_map_init_dest_bank:
1709:
1710: ; Map bank containing the top dest scan line into source window.
1711: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1712:
1713: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyTop>
1714:
1715: top_1RW_init_dest_bank_mapped:
1716:
1717: ; Bank-by-bank top-to-bottom copy loop.
1718:
1719: top_1RW_bank_loop:
1720:
1721: ; Decide how far we can go before we run out of bank or rectangle to copy.
1722:
1723: mov edi,ulLastDestScan
1724: cmp edi,[ebx].dsurf_rcl1WindowClip.yBottom
1725: jl short @F ;copy rectangle bottom is in this bank
1726: mov edi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest extends to end
1727: ; of bank, at least
1728: @@:
1729: sub edi,esi ;# of scans we can and want to do in the dest bank
1730:
1731: ; Now make sure source is mapped in. This is the condition the copying routines
1732: ; expect, and we need to figure out how far we can go in the source.
1733:
1734: sub edx,edx ;assume source and dest are in the same
1735: ; bank
1736: mov esi,ulCurrentSrcScan
1737: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;src scan less than
1738: ; current bank?
1739: jl short top_1RW_map_src_Bank ;yes, must map in
1740: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;src scan greater than
1741: ; current bank?
1742: jl short top_1RW_src_bank_mapped ;no, proper bank still mapped
1743:
1744: top_1RW_map_src_Bank:
1745:
1746: ; Map bank containing the current source scan line into source window.
1747: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1748:
1749: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyTop>
1750:
1751: mov edx,1 ;mark that source and dest are not in
1752: ; the same bank
1753: top_1RW_src_bank_mapped:
1754:
1755: mov eax,[ebx].dsurf_rcl1WindowClip.yBottom
1756: sub eax,esi ;# of scans we can do in the src bank
1757:
1758: cmp edi,eax
1759: jb short @F ;source bank isn't limiting
1760: mov edi,eax ;source bank is limiting
1761: @@:
1762: mov ulBlockHeight,edi ;# of scans we'll do in this bank
1763:
1764: ; We're ready to copy this block.
1765: ; Select different threading, depending on whether the source and destination
1766: ; are currently in the same bank; we can do edges faster if they are.
1767:
1768: and edx,edx
1769: jz short top_1RW_copy_same_bank
1770:
1771: ; Source and dest are currently in different banks, must go through temp buffer.
1772:
1773: THREAD_AND_START pCurrentThreadViaBuffer,top_1RW_check_more_scans
1774:
1775: ; Source and dest are currently in the same bank.
1776:
1777: align 4
1778: top_1RW_copy_same_bank:
1779: THREAD_AND_START
1780:
1781: ; Any more scans to copy?
1782:
1783: top_1RW_check_more_scans:
1784:
1785: mov esi,ulCurrentDestScan
1786: mov edi,ulBlockHeight
1787: add esi,edi ;we've copied to dest up to here
1788: cmp ulLastDestScan,esi ;are we at the dest rect bottom?
1789: jz short top_1RW_done ;yes, we're done
1790: mov ulCurrentDestScan,esi
1791:
1792: ; Now make sure the dest bank is mapped in.
1793:
1794: mov ebx,pdsurf
1795: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;dest scan less than
1796: ; current bank?
1797: jl short top_1RW_map_dest_bank ;yes, map in dest bank
1798: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest scan greater than
1799: ; current bank?
1800: jl short top_1RW_dest_bank_mapped ;no, proper bank mapped
1801:
1802: top_1RW_map_dest_bank:
1803:
1804: ; Map bank containing the current dest scan line into source window.
1805: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1806:
1807: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyTop>
1808:
1809: top_1RW_dest_bank_mapped:
1810:
1811: add ulCurrentSrcScan,edi ;we've copied from source up to here
1812:
1813: jmp top_1RW_bank_loop
1814:
1815: top_1RW_done:
1816: PLAIN_RET
1817:
1818:
1819: ;-----------------------------------------------------------------------;
1820: ; Banking for 1 R/W adapters, bottom to top.
1821: ;-----------------------------------------------------------------------;
1822: align 4
1823: bottom_to_top_1RW:
1824:
1825: ; We're going bottom to top. Map in the dest, bottom-justified.
1826:
1827: mov ebx,pdsurf
1828: mov esi,ulCurrentDestScan
1829: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;is dest bottom less than
1830: ; current dest bank?
1831: jl short bot_1RW_map_init_dest_bank ;yes, map in proper bank
1832: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest bottom greater
1833: ; than current dst bank?
1834: jl short bot_1RW_init_dest_bank_mapped
1835: ;no, proper bank already mapped
1836: bot_1RW_map_init_dest_bank:
1837:
1838: ; Map bank containing the bottom dest scan line into source window.
1839: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1840:
1841: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyBottom>
1842:
1843: bot_1RW_init_dest_bank_mapped:
1844:
1845: ; Bank-by-bank bottom-to-top copy loop.
1846:
1847: bot_1RW_bank_loop:
1848:
1849: ; Decide how far we can go before we run out of bank or rectangle to copy.
1850:
1851: mov edi,ulLastDestScan
1852: cmp edi,[ebx].dsurf_rcl1WindowClip.yTop
1853: jg short @F ;copy rectangle top is in this bank
1854: mov edi,[ebx].dsurf_rcl1WindowClip.yTop ;dest extends to end
1855: ; of bank, at least
1856: @@:
1857: neg edi
1858: add edi,esi ;# of scans we can and want to do in
1859: inc edi ; the dest bank
1860:
1861: ; Now make sure source is mapped in. This is the condition the copying routines
1862: ; expect, and we need to figure out how far we can go in the source.
1863:
1864: sub edx,edx ;assume source and dest are in the same
1865: ; bank
1866: mov esi,ulCurrentSrcScan
1867: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;src scan less than
1868: ; current bank?
1869: jl short bot_1RW_map_src_Bank ;yes, must map in
1870: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;src scan greater than
1871: ; current bank?
1872: jl short bot_1RW_src_bank_mapped ;no, proper bank still mapped
1873:
1874: bot_1RW_map_src_Bank:
1875:
1876: ; Map bank containing the current source scan line into source window.
1877: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1878:
1879: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyBottom>
1880:
1881: mov edx,1 ;mark that source and dest are not in
1882: ; the same bank
1883: bot_1RW_src_bank_mapped:
1884:
1885: sub esi,[ebx].dsurf_rcl1WindowClip.yTop
1886: inc esi ;# of scans we can do in the src bank
1887:
1888: cmp edi,esi
1889: jb short @F ;source bank isn't limiting
1890: mov edi,esi ;source bank is limiting
1891: @@:
1892: mov ulBlockHeight,edi ;# of scans we'll do in this bank
1893:
1894: ; We're ready to copy this block.
1895: ; Select different threading, depending on whether the source and destination
1896: ; are currently in the same bank; we can copy much faster if they are.
1897:
1898: and edx,edx
1899: jz short bot_1RW_copy_same_bank
1900:
1901: ; Source and dest are currently in different banks, must go through temp buffer.
1902:
1903: THREAD_AND_START pCurrentThreadViaBuffer,bot_1RW_check_more_scans
1904:
1905: ; Source and dest are currently in the same bank.
1906:
1907: align 4
1908: bot_1RW_copy_same_bank:
1909: THREAD_AND_START
1910:
1911: ; Any more scans to copy?
1912:
1913: align 4
1914: bot_1RW_check_more_scans:
1915:
1916: mov esi,ulCurrentDestScan
1917: mov edi,ulBlockHeight
1918: sub esi,edi ;we've copied to dest up to here
1919: cmp ulLastDestScan,esi ;are we past the dest rect top?
1920: jg short bot_1RW_done ;yes, we're done
1921: mov ulCurrentDestScan,esi
1922:
1923: ; Now make sure the dest bank is mapped in.
1924:
1925: mov ebx,pdsurf
1926: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;dest scan less than
1927: ; current bank?
1928: jl short bot_1RW_map_dest_bank ;yes, map in dest bank
1929: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest scan greater than
1930: ; current bank?
1931: jl short bot_1RW_dest_bank_mapped ;no, proper bank mapped
1932:
1933: bot_1RW_map_dest_bank:
1934:
1935: ; Map bank containing the current dest scan line into source window.
1936: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions.
1937:
1938: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyBottom>
1939:
1940: bot_1RW_dest_bank_mapped:
1941:
1942: sub ulCurrentSrcScan,edi ;we've copied from source up to here
1943:
1944: jmp bot_1RW_bank_loop
1945:
1946: bot_1RW_done:
1947: PLAIN_RET
1948:
1949:
1950: ;***********************************************************************;
1951: ;
1952: ; The following routines are the low-level copying routines. They know
1953: ; almost nothing about banks (the routines that copy through a temp
1954: ; buffer know how to switch banks after filling the temp buffer, but
1955: ; that's it). Banking should be taken care of at a higher level.
1956: ;
1957: ;***********************************************************************;
1958:
1959: ;-----------------------------------------------------------------------;
1960: ; Copies a block of solid bytes directly from the source to the
1961: ; destination, without using a temp buffer. We can't use the latches,
1962: ; though, because this is a rotated copy. Can only be used by 2 R/W or
1963: ; 1R/1W window banking, or by unbanked modes, or by 1 R/W adapters when
1964: ; the source and dest are in the same bank. 1 R/W adapters must go
1965: ; through an intermediate local buffer when the source and the destination
1966: ; aren't in the same bank.
1967: ;
1968: ; Input:
1969: ; Direction Flag set for desired direction of copy
1970: ; culWholeBytesWidth = # of bytes to copy across each scan line
1971: ; ulWholeScanDelta = distance to start of next dest scan from end of
1972: ; current
1973: ; ulWholeScanSrcDelta = distance to start of next source scan from end of
1974: ; current
1975: ; ulBlockHeight = # of scans to copy
1976: ; ulWholeBytesSrc = start source offset in bitmap
1977: ; ulWholeBytesDest = start dest offset in bitmap
1978: ; ulCombineMaskWhole = masking to be applied before ORing the two source
1979: ; bytes together, to keep only the data needed in preparation
1980: ; for the VGA rotator doing its stuff
1981: ;
1982: ; Output:
1983: ; Advances ulWholeBytesSrc and ulWholeBytesDest to scan after last
1984: ; scan processed
1985: ;-----------------------------------------------------------------------;
1986:
1987: align 4
1988: copy_whole_bytes:
1989:
1990: ; Calculate start source and dest addresses from bitmap start addresses and
1991: ; offsets within bitmap.
1992:
1993: mov ecx,pdsurf
1994: mov eax,ulWholeBytesSrc
1995: add eax,[ecx].dsurf_pvBitmapStart2WindowS
1996: mov pSrcAddr,eax
1997: mov eax,ulWholeBytesDest
1998: add eax,[ecx].dsurf_pvBitmapStart2WindowD
1999: mov pDestAddr,eax
2000:
2001: ; Set the bit mask to enable all bits.
2002:
2003: mov edx,VGA_BASE + GRAF_ADDR
2004: mov eax,(0ffh shl 8) + GRAF_BIT_MASK
2005: out dx,ax
2006:
2007: ; Leave GC Index pointing to the Read Map register.
2008:
2009: mov al,GRAF_READ_MAP
2010: out dx,al
2011:
2012: ; Set up to copy the whole bytes from the buffer.
2013:
2014: mov eax,ulBlockHeight
2015: mov ulTempScanCount,eax
2016:
2017: mov ebx,culWholeBytesWidth
2018: SET_UP_UNROLL_VARS ebx,ecx,ebx,pfnCopyWholeRWEntry, \
2019: LOOP_UNROLL_SHIFT
2020: mov culTempCount,ebx ;remember # of unrolled loop iterations
2021: mov pTempEntry,ecx ;ditto for entry point
2022:
2023: copy_whole_scan_loop:
2024:
2025: mov cl,MM_C3 ;start by copying plane 3 (for Map Mask)
2026:
2027: copy_whole_plane_loop:
2028:
2029: ; Set Map Mask to enable writes to the plane we're copying.
2030:
2031: mov edx,VGA_BASE + SEQ_DATA
2032: mov al,cl
2033: out dx,al
2034:
2035: ; Set Read Map to enable reads from the plane we're copying.
2036:
2037: mov dl,GRAF_DATA
2038: shr al,1 ;map plane into ReadMask
2039: cmp al,100b ;set Carry if not C3 (plane 3)
2040: adc al,-1 ;sub 1 only if C3
2041: out dx,al
2042:
2043: ; Select the corresponding plane from the temp buffer.
2044:
2045: mov esi,pSrcAddr ;source offset in screen
2046: mov edi,pDestAddr ;point to destination start
2047:
2048: lodsb ;prime the rotation pipeline
2049: mov ah,al ;for combining with the next byte
2050:
2051: mov ebx,culTempCount
2052: mov edx,ulCombineMaskWhole
2053: jmp pTempEntry
2054:
2055:
2056: ;-----------------------------------------------------------------------;
2057: ; Table of unrolled copy whole bytes from buffer loop entry points.
2058: ;-----------------------------------------------------------------------;
2059:
2060: UNROLL_LOOP_ENTRY_TABLE pfnCopyWholeRWEntry, \
2061: WHOLE_RW, LOOP_UNROLL_COUNT
2062:
2063: ;-----------------------------------------------------------------------;
2064: ; Unrolled loop for copying whole bytes from the buffer.
2065: ;-----------------------------------------------------------------------;
2066:
2067: COPY_WHOLE_RW macro ENTRY_LABEL,ENTRY_INDEX
2068: &ENTRY_LABEL&ENTRY_INDEX&:
2069: lodsb ;get byte to copy
2070: mov ch,al ;set aside for next time
2071: and eax,edx ;mask the bytes in preparation for combining
2072: ; and rotating them
2073: or al,ah ;combine them
2074: stosb ;write the composite byte
2075: ; VGA rotates during write
2076: mov ah,ch ;prepare byte for combining next time
2077: endm ;-----------------------------------;
2078:
2079: ; AH = rotation pipeline-priming byte
2080: ; EDX = mask to preserve desired portions of AH and AL before combining
2081: ; ESI = source address to copy from
2082: ; EDI = target address to copy to
2083: ; Map Mask set to enable the desired plane for write
2084: ; Bit Mask set to enable all bits
2085:
2086: align 4
2087: copy_whole_loop:
2088: UNROLL_LOOP COPY_WHOLE_RW,WHOLE_RW,LOOP_UNROLL_COUNT
2089:
2090: dec ebx
2091: jnz copy_whole_loop
2092:
2093: ; Do next plane, if any.
2094:
2095: shr cl,1 ;advance to next plane
2096: jnz copy_whole_plane_loop
2097:
2098: ; Remember where we left off, for next scan.
2099:
2100: add edi,ulWholeScanDelta ;point to next dest scan
2101: mov pDestAddr,edi
2102: add esi,ulWholeScanSrcDelta ;point to next source scan
2103: mov pSrcAddr,esi
2104:
2105: ; Count down scan lines.
2106:
2107: dec ulTempScanCount
2108: jnz copy_whole_scan_loop
2109:
2110: ; Remember where we left off, for next time.
2111:
2112: mov ecx,pdsurf
2113: sub esi,[ecx].dsurf_pvBitmapStart2WindowS
2114: mov ulWholeBytesSrc,esi
2115: sub edi,[ecx].dsurf_pvBitmapStart2WindowD
2116: mov ulWholeBytesDest,edi
2117:
2118: PLAIN_RET
2119:
2120:
2121: ;-----------------------------------------------------------------------;
2122: ; Copies a block of solid bytes from the source to the destination via
2123: ; the temp buffer. This should only be used by 1 R/W adapters, and then
2124: ; only when the source and dest are in different banks.
2125: ;
2126: ; All relevant bytes are first copied from the source to a temp buffer that's
2127: ; an image of the source. Then, we copy each of the four planes for one scan
2128: ; line from the temp buffer to the screen before going on to the next scan
2129: ; line. See ALIGNBLT.ASM for comments about why this is done.
2130: ;
2131: ; Input:
2132: ; Direction Flag set for desired direction of copy
2133: ; culWholeBytesWidth = # of bytes to copy across each scan line
2134: ; ulWholeScanDelta = distance to start of next scan from end of current
2135: ; ulNextScan = width of a scan line
2136: ; ulBlockHeight = # of scans to copy
2137: ; ulWholeBytesSrc = start source offset in bitmap
2138: ; ulWholeBytesDest = start dest offset in bitmap
2139: ; ppTempPlane0 = pointer to pointer to plane 0 storage in temp buffer
2140: ; ppTempPlane3 = pointer to pointer to plane 3 storage in temp buffer
2141: ; ulCombineMaskWhole = masking to be applied before ORing the two source
2142: ; bytes together, to keep only the data needed in preparation
2143: ; for the VGA rotator doing its stuff
2144: ; Expects the source bank to be mapped in; source bank is mapped in on
2145: ; exit
2146: ;
2147: ; Output:
2148: ; Advances ulWholeBytesSrc and ulWholeBytesDest to scan after last
2149: ; scan processed
2150: ;-----------------------------------------------------------------------;
2151:
2152: align 4
2153: copy_whole_bytes_via_buffer:
2154:
2155: ; Calculate start source address from bitmap start address and offset within
2156: ; bitmap.
2157:
2158: mov ecx,pdsurf
2159: mov eax,ulWholeBytesSrc
2160: add eax,[ecx].dsurf_pvBitmapStart
2161: mov pSrcAddr,eax
2162: sub eax,[ecx].dsurf_pvStart
2163: mov ulOffsetInBank,eax ;will come in handy because we treat the
2164: ; temp buffer as an image of the current
2165: ; bank
2166:
2167: ; First, copy all the bytes into the temporary buffer.
2168:
2169: ; Leave the GC Index pointing to the Read Map.
2170:
2171: mov edx,VGA_BASE + GRAF_ADDR
2172: mov al,GRAF_READ_MAP
2173: out dx,al
2174:
2175: mov eax,3 ;start by copying plane 3
2176: copy_whole_to_buffer_plane_loop:
2177: mov ebx,ulBlockHeight ;# of scans to copy
2178: mov esi,pSrcAddr ;source offset in screen
2179: mov edi,ppTempPlane0
2180: mov edi,[edi+eax*4] ;pointer to current plane in temp buffer
2181: add edi,ulOffsetInBank ;dest for plane in temp buffer
2182:
2183: mov edx,VGA_BASE + GRAF_DATA
2184: out dx,al ;set Read Map to plane we're copying from.
2185:
2186: push eax ;remember plane index
2187: mov eax,ulWholeScanSrcDelta ;offset to next scan
2188: mov edx,culWholeBytesWidth ;# of bytes per scan
2189: inc edx ;always one more source byte than dest byte
2190: copy_whole_to_buffer_scan_loop:
2191: mov ecx,edx ;# of bytes per scan
2192: rep movsb ;copy the scan line to the temp buffer
2193: add esi,eax ;point to next source scan
2194: add edi,eax ;point to next dest scan
2195:
2196: dec ebx ;count down scan lines
2197: jnz copy_whole_to_buffer_scan_loop
2198:
2199: pop eax ;get back plane index
2200: dec eax ;count down planes
2201: jns copy_whole_to_buffer_plane_loop
2202:
2203: ; Remember where we left off, for next time.
2204:
2205: mov ebx,pdsurf
2206: sub esi,[ebx].dsurf_pvBitmapStart
2207: mov ulWholeBytesSrc,esi
2208:
2209:
2210: ; Now copy the temp buffer to the screen.
2211:
2212: ; Map in the destination bank, so we can read/write to it and let the Bit Mask
2213: ; work.
2214:
2215: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>, \
2216: <ebx,ulCurrentDestScan,ulCurrentJustification>
2217:
2218: ; Calculate dest start address (if this is a 1 R/W adapter, we had to wait
2219: ; until now to calculate this, because the dest bank wasn't mapped earlier).
2220:
2221: mov eax,ulWholeBytesDest
2222: add eax,[ebx].dsurf_pvBitmapStart
2223: mov pDestAddr,eax
2224:
2225: ; Set the bit mask to enable all bits.
2226:
2227: mov edx,VGA_BASE + GRAF_ADDR
2228: mov eax,(0ffh shl 8) + GRAF_BIT_MASK
2229: out dx,ax
2230:
2231: ; Set up to copy the whole bytes from the buffer.
2232:
2233: mov eax,ulBlockHeight
2234: mov ulTempScanCount,eax
2235:
2236: mov ebx,culWholeBytesWidth
2237: SET_UP_UNROLL_VARS ebx,ecx,ebx,pfnCopyWholeFromBufferEntry, \
2238: LOOP_UNROLL_SHIFT
2239: mov culTempCount,ebx ;remember # of unrolled loop iterations
2240: mov pTempEntry,ecx ;ditto for entry point
2241:
2242: copy_whole_from_buffer_scan_loop:
2243:
2244: mov ebx,ppTempPlane3 ;point to plane 3's temp buffer offset
2245: mov cl,MM_C3 ;start by copying plane 3
2246:
2247: copy_whole_from_buffer_plane_loop:
2248:
2249: ; Set Map Mask to enable writes to the plane we're copying.
2250:
2251: mov edx,VGA_BASE + SEQ_DATA
2252: mov al,cl
2253: out dx,al
2254:
2255: ; Select the corresponding plane from the temp buffer.
2256:
2257: mov esi,[ebx] ;point to plane start in temp buffer
2258: sub ebx,4 ;point to next temp buffer plane ptr
2259: push ebx ;preserve pointer to plane pointer
2260:
2261: add esi,ulOffsetInBank ;point to current scan start in temp buffer
2262: mov edi,pDestAddr ;point to destination start
2263:
2264: lodsb ;prime the rotation pipeline
2265: mov ah,al ;for combining with the next byte
2266:
2267: mov ebx,culTempCount
2268: mov edx,ulCombineMaskWhole
2269: jmp pTempEntry
2270:
2271:
2272: ;-----------------------------------------------------------------------;
2273: ; Table of unrolled copy whole bytes from buffer loop entry points.
2274: ;-----------------------------------------------------------------------;
2275:
2276: UNROLL_LOOP_ENTRY_TABLE pfnCopyWholeFromBufferEntry, \
2277: WHOLE_FROM_BUFFER, LOOP_UNROLL_COUNT
2278:
2279: ;-----------------------------------------------------------------------;
2280: ; Unrolled loop for copying whole bytes from the buffer.
2281: ;-----------------------------------------------------------------------;
2282:
2283: COPY_WHOLE_FROM_BUFFER macro ENTRY_LABEL,ENTRY_INDEX
2284: &ENTRY_LABEL&ENTRY_INDEX&:
2285: lodsb ;get byte to copy
2286: mov ch,al ;set aside for next time
2287: and eax,edx ;mask the bytes in preparation for combining
2288: ; and rotating them
2289: or al,ah ;combine them
2290: stosb ;write the composite byte
2291: ; VGA rotates during write
2292: mov ah,ch ;prepare byte for combining next time
2293: endm ;-----------------------------------;
2294:
2295: ; AH = rotation pipeline-priming byte
2296: ; EDX = mask to preserve desired portions of AH and AL before combining
2297: ; ESI = source address to copy from
2298: ; EDI = target address to copy to
2299: ; Map Mask set to enable the desired plane for write
2300: ; Bit Mask set to enable all bits
2301:
2302: align 4
2303: copy_whole_from_buffer_loop:
2304: UNROLL_LOOP COPY_WHOLE_FROM_BUFFER,WHOLE_FROM_BUFFER,LOOP_UNROLL_COUNT
2305:
2306: dec ebx
2307: jnz copy_whole_from_buffer_loop
2308:
2309: ; Do next plane, if any.
2310:
2311: pop ebx ;retrieve pointer to plane pointer
2312: shr cl,1 ;advance to next plane
2313: jnz copy_whole_from_buffer_plane_loop
2314:
2315: ; Remember where we left off, for next scan.
2316:
2317: add edi,ulWholeScanDelta ;point to next dest scan
2318: mov pDestAddr,edi
2319: mov eax,ulNextScan
2320: add ulOffsetInBank,eax ;next scan's start in temp buffer,
2321: ; relative to start of plane's storage
2322:
2323: ; Count down scan lines.
2324:
2325: dec ulTempScanCount
2326: jnz copy_whole_from_buffer_scan_loop
2327:
2328: ; Remember where we left off, for next time.
2329:
2330: mov ebx,pdsurf
2331: sub edi,[ebx].dsurf_pvBitmapStart
2332: mov ulWholeBytesDest,edi
2333:
2334: ; Put back the original source bank.
2335:
2336: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>, \
2337: <ebx,ulCurrentSrcScan,ulCurrentJustification>
2338:
2339: PLAIN_RET
2340:
2341:
2342: ;-----------------------------------------------------------------------;
2343: ; Copies a strip of left edge bytes from the source to the destination,
2344: ; assuming both the source and the destination are both readable and
2345: ; writable. Can only be used by 2 R/W window banking, or by unbanked
2346: ; modes. 1 R/W and 1R/1W adapters must go through an intermediate local
2347: ; buffer when the source and dest are in different banks. Processes up to
2348: ; EDGE_CHUNK_SIZE bytes in each plane at a pop; more bytes might cause
2349: ; flicker.
2350: ;
2351: ; Input:
2352: ; ulNextScan = width of scan, in bytes
2353: ; ulBlockHeight = # of scans to copy
2354: ; ulLeftEdgeSrc = start source offset in bitmap
2355: ; ulLeftEdgeDest = start dest offset in bitmap
2356: ; ulLeftSrcWidthMinus1 = width of left source edge minus 1 (0 or 1)
2357: ; jLeftMask = left edge clip mask
2358: ;
2359: ; Output:
2360: ; Advances ulLeftEdgeSrc and ulLeftEdgeDest to scan after last
2361: ; scan processed
2362: ;-----------------------------------------------------------------------;
2363:
2364: align 4
2365: copy_left_edge:
2366:
2367: ; Calculate start source and dest addresses from bitmap start addresses and
2368: ; offsets within bitmap.
2369:
2370: mov ecx,pdsurf
2371: mov esi,ulLeftEdgeSrc
2372: add esi,[ecx].dsurf_pvBitmapStart2WindowS
2373: mov edi,ulLeftEdgeDest
2374: add edi,[ecx].dsurf_pvBitmapStart2WindowD
2375:
2376: ; Copy the edge.
2377:
2378: mov ah,byte ptr jLeftMask ;clip mask for this edge
2379: mov ebx,ulLeftSrcWidthMinus1
2380: call copy_edge_table[ebx*4]
2381:
2382: ; Remember where we left off, for next time.
2383:
2384: mov ecx,pdsurf
2385: sub esi,[ecx].dsurf_pvBitmapStart2WindowS
2386: mov ulLeftEdgeSrc,esi
2387: sub edi,[ecx].dsurf_pvBitmapStart2WindowD
2388: mov ulLeftEdgeDest,edi
2389:
2390: PLAIN_RET
2391:
2392:
2393: ;-----------------------------------------------------------------------;
2394: ; Copies a strip of right edge bytes from the source to the destination,
2395: ; assuming both the source and the destination are both readable and
2396: ; writable. Can only be used by 2 R/W window banking, or by unbanked
2397: ; modes. 1 R/W and 1R/1W adapters must go through an intermediate local
2398: ; buffer when the source and dest are in different banks. Processes up to
2399: ; EDGE_CHUNK_SIZE bytes in each plane at a pop; more bytes might cause
2400: ; flicker.
2401: ;
2402: ; Input:
2403: ; ulNextScan = width of scan, in bytes
2404: ; ulBlockHeight = # of scans to copy
2405: ; ulRightEdgeSrc = start source offset in bitmap
2406: ; ulRightEdgeDest = start dest offset in bitmap
2407: ; ulRightSrcWidthMinus1 = width of right source edge minus 1 (0 or 1)
2408: ; jRightMask = right edge clip mask
2409: ;
2410: ; Output:
2411: ; Advances ulRightEdgeSrc and ulRightEdgeDest to scan after last
2412: ; scan processed
2413: ;-----------------------------------------------------------------------;
2414:
2415: align 4
2416: copy_right_edge:
2417:
2418: ; Calculate start source and dest addresses from bitmap start addresses and
2419: ; offsets within bitmap.
2420:
2421: mov ecx,pdsurf
2422: mov esi,ulRightEdgeSrc
2423: add esi,[ecx].dsurf_pvBitmapStart2WindowS
2424: mov edi,ulRightEdgeDest
2425: add edi,[ecx].dsurf_pvBitmapStart2WindowD
2426:
2427: ; Copy the edge.
2428:
2429: mov ah,byte ptr jRightMask ;clip mask for this edge
2430: mov ebx,ulRightSrcWidthMinus1
2431: call copy_edge_table[ebx*4]
2432:
2433: ; Remember where we left off, for next time
2434:
2435: mov ecx,pdsurf
2436: sub esi,[ecx].dsurf_pvBitmapStart2WindowS
2437: mov ulRightEdgeSrc,esi
2438: sub edi,[ecx].dsurf_pvBitmapStart2WindowD
2439: mov ulRightEdgeDest,edi
2440:
2441: PLAIN_RET
2442:
2443:
2444: ;-----------------------------------------------------------------------;
2445: ; Copies an edge from a 1-wide source to the destination on the screen.
2446: ; Entry:
2447: ; AH = bit mask setting for edge
2448: ; ESI = source address
2449: ; EDI = destination address
2450: ; ulBlockHeight = # of bytes to copy per plane
2451: ; ulNextScan = scan width
2452: ; Source readable, and destination readable and writable
2453: ; Exit:
2454: ; ESI = next source address
2455: ; EDI = next destination address
2456: ;
2457: ; Preserved: EBP
2458: ;-----------------------------------------------------------------------;
2459:
2460: align 4
2461: copy_edge_1ws:
2462: mov pSrcAddr,esi
2463: mov pDestAddr,edi
2464:
2465: ; Set the clip mask for this edge.
2466:
2467: mov edx,VGA_BASE + GRAF_ADDR
2468: mov al,GRAF_BIT_MASK
2469: out dx,ax
2470:
2471: ; Leave the GC Index pointing to the Read Map.
2472:
2473: mov al,GRAF_READ_MAP
2474: out dx,al
2475:
2476: mov ecx,offset copy_edge_rw_1ws_full_chunk
2477: ;entry point into unrolled loop to copy first
2478: ; chunk, assuming it's a full chunk
2479: mov ebx,ulBlockHeight
2480:
2481: ; Copy the edge in a series of chunks.
2482:
2483: copy_edge_chunk_loop_1ws:
2484:
2485: sub ebx,EDGE_CHUNK_SIZE ;scans remaining after this chunk, assuming
2486: ; a full chunk
2487: jge short @F ;do a full chunk
2488: add ebx,EDGE_CHUNK_SIZE ;not a full chunk; process all remaining
2489: ; scans
2490: mov ecx,pfnCopyEdgeRWEntry_1ws[-4][ebx*4]
2491: ;entry point into unrolled loop to copy desired
2492: ; chunk size
2493: sub ebx,ebx ;no scans after this
2494: @@:
2495: push ebx ;remember remaining scan count
2496:
2497: mov ah,MM_C3 ;start by copying plane 3
2498: mov ebx,ulNextScan
2499:
2500: copy_edge_plane_loop_1ws:
2501:
2502: ; Set Map Mask to enable writes to plane we're copying.
2503:
2504: mov al,ah
2505: mov dl,SEQ_DATA
2506: out dx,al
2507:
2508: ; Set Read Map to same plane.
2509:
2510: shr al,1 ;map plane into ReadMask
2511: cmp al,100b ;set Carry if not C3 (plane 3)
2512: adc al,-1 ;sub 1 only if C3
2513: mov dl,GRAF_DATA
2514: out dx,al
2515:
2516: mov esi,pSrcAddr
2517: mov edi,pDestAddr
2518:
2519: jmp ecx ;copy the left edge
2520:
2521:
2522: ;-----------------------------------------------------------------------;
2523: ; Table of unrolled edge loop entry points. First entry point is to copy
2524: ; 1 byte, last entry point is to copy EDGE_CHUNK_SIZE bytes.
2525: ;-----------------------------------------------------------------------;
2526:
2527: pfnCopyEdgeRWEntry_1ws label dword
2528: INDEX = 1
2529: rept EDGE_CHUNK_SIZE
2530: DEFINE_DD EDGE_RW_1WS,%INDEX
2531: INDEX = INDEX+1
2532: endm
2533:
2534:
2535: ;-----------------------------------------------------------------------;
2536: ; Unrolled loop for copying a strip of edge bytes, with 1-wide source and
2537: ; destination both readable and writable.
2538: ;-----------------------------------------------------------------------;
2539:
2540: COPY_EDGE_RW_1WS macro ENTRY_LABEL,ENTRY_INDEX
2541: &ENTRY_LABEL&ENTRY_INDEX&:
2542: mov al,[esi] ;get byte to copy
2543: add esi,ebx ;point to next source scan
2544: xchg [edi],al ;read before write so Bit Mask can operate
2545: ; VGA rotates during write
2546: add edi,ebx ;point to next dest scan
2547: endm ;-----------------------------------;
2548:
2549: ; EBX = scan line width
2550: ; ESI = source address to copy from
2551: ; EDI = target address to copy to
2552: ; Bit Mask set to desired clipping
2553: ; Read Map and Map Mask set to enable the desired plane for read and write
2554:
2555: align 4
2556: copy_edge_rw_1ws_full_chunk:
2557: UNROLL_LOOP COPY_EDGE_RW_1WS,EDGE_RW_1WS,EDGE_CHUNK_SIZE
2558:
2559: ; Do next plane within this chunk, if any.
2560:
2561: shr ah,1 ;advance to next plane
2562: jnz copy_edge_plane_loop_1ws
2563:
2564: ; Remember where we left off, for the next chunk.
2565:
2566: mov pSrcAddr,esi
2567: mov pDestAddr,edi
2568:
2569: ; Do next chunk within this bank block, if any.
2570:
2571: pop ebx ;retrieve remaining scan count
2572: and ebx,ebx ;any scans left?
2573: jnz copy_edge_chunk_loop_1ws ;more scans to do
2574:
2575: PLAIN_RET
2576:
2577:
2578: ;-----------------------------------------------------------------------;
2579: ; Copies a strip of left edge bytes from the source to the destination
2580: ; through an intermediate RAM buffer. This is the approach required by
2581: ; 1 R/W and 1R/1W adapters when the source and dest are in different banks.
2582: ; Writes up to EDGE_CHUNK_SIZE bytes in each plane at a pop; more bytes might
2583: ; cause flicker.
2584: ;
2585: ; Input:
2586: ; ulNextScan = width of scan, in bytes
2587: ; ulBlockHeight = # of scans to copy
2588: ; ulLeftEdgeSrc = start source offset in bitmap
2589: ; ulLeftEdgeDest = start dest offset in bitmap
2590: ; jLeftMask = left edge clip mask
2591: ; pTempPlane = pointer to temp storage buffer
2592: ; ulCurrentSrcScan = scan used to map in source bank
2593: ; ulCurrentDestScan = scan used to map in dest bank
2594: ; ulCurrentJustification = justification used to map in current bank
2595: ; ulLeftSrcWidthMinus1 = width of left source edge minus 1 (0 or 1)
2596: ; For 1 R/W adapters, expects the source bank to be mapped in; banking
2597: ; is the same at exit as it was at entry
2598: ;
2599: ; Output:
2600: ; Advances ulLeftEdgeSrc and ulLeftEdgeDest to scan after last
2601: ; scan processed
2602: ;
2603: ; Note that this should never be called for an unbanked or 2 R/W adapter,
2604: ; because the source and dest are always both addressable simultaneously then.
2605: ;-----------------------------------------------------------------------;
2606:
2607: align 4
2608: copy_left_edge_via_buffer:
2609:
2610: ; First, copy all the bytes into the temporary buffer.
2611:
2612: ; Calculate start source and dest addresses from bitmap start addresses and
2613: ; offsets within bitmap.
2614:
2615: mov ecx,pdsurf
2616: mov esi,ulLeftEdgeSrc
2617: add esi,[ecx].dsurf_pvBitmapStart2WindowS
2618:
2619: ; Copy the edge from the source to the temp buffer.
2620:
2621: mov eax,ulLeftSrcWidthMinus1
2622: call copy_edge_from_screen_to_buffer[eax*4]
2623:
2624: ; Remember where we left off, for next time
2625:
2626: mov ebx,pdsurf
2627: sub esi,[ebx].dsurf_pvBitmapStart2WindowS
2628: mov ulLeftEdgeSrc,esi
2629:
2630: ; Now copy the temp buffer to the screen.
2631:
2632: ; Map in the source bank to match the destination, so we can read/write to it
2633: ; and let the Bit Mask work. Note that on a 1 R/W adapter, both banks will be
2634: ; mapped by this call, which is fine.
2635:
2636: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
2637: <ebx,ulCurrentDestScan,ulCurrentJustification,MapSourceBank>
2638:
2639: ; Calculate dest start address (if this is a 1 R/W adapter, we had to wait
2640: ; until now to calculate this, because the dest bank wasn't mapped earlier).
2641:
2642: mov edi,ulLeftEdgeDest
2643: add edi,[ebx].dsurf_pvBitmapStart2WindowD
2644:
2645: ; Do the copy.
2646:
2647: mov ah,byte ptr jLeftMask ;clip mask for this edge
2648: mov ebx,ulLeftSrcWidthMinus1
2649: call copy_edge_from_buffer_to_screen[ebx*4]
2650:
2651: ; Remember where we left off, for next time.
2652:
2653: mov ebx,pdsurf
2654: sub edi,[ebx].dsurf_pvBitmapStart2WindowD
2655: mov ulLeftEdgeDest,edi
2656:
2657: ; Put back the original source bank. Note that on a 1 R/W adapter, both banks
2658: ; will be mapped by this call, which is fine.
2659:
2660: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
2661: <ebx,ulCurrentSrcScan,ulCurrentJustification,MapSourceBank>
2662:
2663: PLAIN_RET
2664:
2665:
2666: ;-----------------------------------------------------------------------;
2667: ; Copies a strip of right edge bytes from the source to the destination
2668: ; through an intermediate RAM buffer. This is the approach required by
2669: ; 1 R/W and 1R/1W adapters when the source and dest are in different banks.
2670: ; Writes up to EDGE_CHUNK_SIZE bytes in each plane at a pop; more bytes might
2671: ; cause flicker.
2672: ;
2673: ; Input:
2674: ; ulNextScan = width of scan, in bytes
2675: ; ulBlockHeight = # of scans to copy
2676: ; ulRightEdgeSrc = start source offset in bitmap
2677: ; ulRightEdgeDest = start dest offset in bitmap
2678: ; jRightMask = right edge clip mask
2679: ; pTempPlane = pointer to temp storage buffer
2680: ; ulCurrentSrcScan = scan used to map in source bank
2681: ; ulCurrentDestScan = scan used to map in dest bank
2682: ; ulCurrentJustification = justification used to map in current bank
2683: ; ulRightSrcWidthMinus1 = width of right source edge minus 1 (0 or 1)
2684: ; For 1 R/W adapters, expects the source bank to be mapped in; banking
2685: ; is the same at exit as it was at entry
2686: ;
2687: ; Output:
2688: ; Advances ulRightEdgeSrc and ulRightEdgeDest to scan after last
2689: ; scan processed
2690: ;
2691: ; Note that this should never be called for an unbanked or 2 R/W adapter,
2692: ; because the source and dest are always both addressable simultaneously then.
2693: ;-----------------------------------------------------------------------;
2694:
2695: align 4
2696: copy_right_edge_via_buffer:
2697:
2698: ; First, copy all the bytes into the temporary buffer.
2699:
2700: ; Calculate start source address from bitmap start addresses and
2701: ; offsets within bitmap.
2702:
2703: mov ecx,pdsurf
2704: mov esi,ulRightEdgeSrc
2705: add esi,[ecx].dsurf_pvBitmapStart2WindowS
2706:
2707: ; Copy the edge from the source to the temp buffer.
2708:
2709: mov eax,ulRightSrcWidthMinus1
2710: call copy_edge_from_screen_to_buffer[eax*4]
2711:
2712: ; Remember where we left off, for next time
2713:
2714: mov ebx,pdsurf
2715: sub esi,[ebx].dsurf_pvBitmapStart2WindowS
2716: mov ulRightEdgeSrc,esi
2717:
2718: ; Now copy the temp buffer to the screen.
2719:
2720: ; Map in the source bank to match the destination, so we can read/write to it
2721: ; and let the Bit Mask work. Note that on a 1 R/W adapter, both banks will be
2722: ; mapped by this call, which is correct.
2723:
2724: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
2725: <ebx,ulCurrentDestScan,ulCurrentJustification,MapSourceBank>
2726:
2727: ; Calculate dest start address (if this is a 1 R/W adapter, we had to wait
2728: ; until now to calculate this, because the dest bank wasn't mapped earlier).
2729:
2730: mov edi,ulRightEdgeDest
2731: add edi,[ebx].dsurf_pvBitmapStart2WindowD
2732:
2733: ; Do the copy.
2734:
2735: mov ah,byte ptr jRightMask ;clip mask for this edge
2736: mov ebx,ulRightSrcWidthMinus1
2737: call copy_edge_from_buffer_to_screen[ebx*4]
2738:
2739: ; Remember where we left off, for next time.
2740:
2741: mov ebx,pdsurf
2742: sub edi,[ebx].dsurf_pvBitmapStart2WindowD
2743: mov ulRightEdgeDest,edi
2744:
2745: ; Put back the original source bank. Note that on a 1 R/W adapter, both banks
2746: ; will be mapped by this call, which is fine.
2747:
2748: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \
2749: <ebx,ulCurrentSrcScan,ulCurrentJustification,MapSourceBank>
2750:
2751: PLAIN_RET
2752:
2753:
2754: ;-----------------------------------------------------------------------;
2755: ; Copies an edge from the temp buffer (1 wide) to the screen.
2756: ; Entry:
2757: ; AH = bit mask setting for edge
2758: ; DH = VGA_BASE SHR 8
2759: ; EDI = destination address
2760: ; pTempPlane = temp buffer from which to copy
2761: ; ulBlockHeight = # of bytes to copy per plane
2762: ; ulNextScan = scan width
2763: ; Source and dest banks both pointing to destination
2764: ; Exit:
2765: ; EDI = next destination address
2766: ;
2767: ; Preserved: EBP
2768: ;-----------------------------------------------------------------------;
2769:
2770: align 4
2771: copy_buffered_edge_to_screen_1ws:
2772:
2773: mov pDestAddr,edi
2774:
2775: mov dl,GRAF_ADDR
2776: mov al,GRAF_BIT_MASK
2777: out dx,ax
2778:
2779: mov pTempEntry,offset copy_edge_from_buf_full_chunk_1ws
2780: ;entry point into unrolled loop to copy first
2781: ; chunk, assuming it's a full chunk
2782: mov ecx,pTempPlane ;temp buffer start (copy from here)
2783: mov ebx,ulBlockHeight ;total # of scans to copy
2784:
2785: ; Copy the edge in a series of chunks, to avoid flicker.
2786:
2787: copy_from_buffer_chunk_loop_1ws:
2788:
2789: sub ebx,EDGE_CHUNK_SIZE ;scans remaining after this chunk, assuming
2790: ; a full chunk
2791: jge short @F ;do a full chunk
2792: add ebx,EDGE_CHUNK_SIZE ;not a full chunk; process all remaining
2793: ; scans
2794: mov ebx,pfnCopyEdgesFromBufferEntry_1ws[-4][ebx*4]
2795: mov pTempEntry,ebx ;entry point into unrolled loop to copy desired
2796: ; chunk size
2797: sub ebx,ebx ;no scans after this
2798: @@:
2799: push ebx ;remember remaining scan count
2800:
2801: mov al,MM_C3 ;start by copying plane 3
2802: mov ebx,ulNextScan
2803:
2804: push ecx ;remember current temp buffer start
2805:
2806: mov dl,SEQ_DATA ;leave DX pointing to the Sequencer Data reg
2807:
2808: copy_from_buffer_plane_loop_1ws:
2809:
2810: ; Set Map Mask to enable writes to plane we're copying.
2811:
2812: out dx,al
2813:
2814: mov esi,ecx ;point to current plane's source byte
2815: add ecx,ulBlockHeight ;point to next plane's source byte
2816:
2817: mov edi,pDestAddr
2818:
2819: jmp pTempEntry ;copy the left edge
2820:
2821:
2822: ;-----------------------------------------------------------------------;
2823: ; Table of unrolled edge copy-from-buffer loop entry points. First entry
2824: ; point is to copy 1 byte, last entry point is to copy EDGE_CHUNK_SIZE
2825: ; bytes.
2826: ;-----------------------------------------------------------------------;
2827:
2828: pfnCopyEdgesFromBufferEntry_1ws label dword
2829: INDEX = 1
2830: rept EDGE_CHUNK_SIZE
2831: DEFINE_DD EDGE_FROM_BUFFER_1WS,%INDEX
2832: INDEX = INDEX+1
2833: endm
2834:
2835:
2836: ;-----------------------------------------------------------------------;
2837: ; Unrolled loop for copying a strip of edge bytes (1 wide) from the temp
2838: ; buffer.
2839: ;-----------------------------------------------------------------------;
2840:
2841: COPY_EDGE_FROM_BUFFER_1WS macro ENTRY_LABEL,ENTRY_INDEX
2842: &ENTRY_LABEL&ENTRY_INDEX&:
2843: mov ah,[esi] ;get byte to copy
2844: inc esi ;point to next source (temp buffer) byte
2845: xchg [edi],ah ;read before write so Bit Mask can operate
2846: ; VGA rotates during write
2847: add edi,ebx ;point to next dest (screen) scan
2848: endm ;-----------------------------------;
2849:
2850: ; EBX = scan line width
2851: ; ESI = source address to copy from (temp buffer)
2852: ; EDI = target address to copy to (screen)
2853: ; Bit Mask set to desired clipping
2854: ; Map Mask set to enable the desired plane for write
2855:
2856: align 4
2857: copy_edge_from_buf_full_chunk_1ws:
2858: UNROLL_LOOP COPY_EDGE_FROM_BUFFER_1WS, \
2859: EDGE_FROM_BUFFER_1WS,EDGE_CHUNK_SIZE
2860:
2861: ; Do next plane within this chunk, if any.
2862:
2863: shr al,1 ;advance to next plane
2864: jnz copy_from_buffer_plane_loop_1ws
2865:
2866: ; Remember where we left off, for next chunk.
2867:
2868: mov pDestAddr,edi
2869: pop ecx ;get back current temp buffer start
2870: add ecx,EDGE_CHUNK_SIZE ;point to next chunk's start
2871:
2872: ; Do next chunk within this bank block, if any.
2873:
2874: pop ebx ;retrieve remaining scan count
2875: and ebx,ebx ;any scans left?
2876: jnz copy_from_buffer_chunk_loop_1ws ;more scans to do
2877:
2878: PLAIN_RET
2879:
2880:
2881: ;-----------------------------------------------------------------------;
2882: ; Copies an edge from the screen (1 wide) to the temp buffer.
2883: ; Entry:
2884: ; ESI = source address
2885: ; pTempPlane = temp buffer from which to copy
2886: ; ulBlockHeight = # of bytes to copy per plane
2887: ; ulNextScan = scan width
2888: ; Source bank pointing to source
2889: ; Exit:
2890: ; DH = VGA_BASE SHR 8
2891: ; ESI = next source address
2892: ;
2893: ; Preserved: EBP
2894: ;-----------------------------------------------------------------------;
2895:
2896: align 4
2897: copy_screen_to_buffered_edge_1ws:
2898:
2899: mov pSrcAddr,esi
2900:
2901: ; Leave the GC Index pointing to the Read Map.
2902:
2903: mov edx,VGA_BASE + GRAF_ADDR
2904: mov al,GRAF_READ_MAP
2905: out dx,al
2906:
2907: mov ebx,ulBlockHeight
2908: SET_UP_UNROLL_VARS ebx,ecx,ebx,pfnCopyEdgeToTempEntry_1ws, \
2909: LOOP_UNROLL_SHIFT
2910: mov culTempCount,ebx ;remember # of unrolled loop iterations
2911: mov pTempEntry,ecx ;ditto for entry point
2912:
2913: mov ecx,ulNextScan
2914: mov edi,pTempPlane ;dest offset in temp buffer for plane 3 bytes.
2915: ;The rest of the planes are stored
2916: ; consecutively
2917: mov al,3 ;start by copying plane 3
2918: mov dl,GRAF_DATA ;leave DX pointing to the GC Data reg
2919: copy_edge_to_buffer_plane_loop_1ws:
2920: mov esi,pSrcAddr ;source pointer
2921:
2922: out dx,al ;set Read Map to plane we're copying from.
2923:
2924: mov ebx,culTempCount ;# of unrolled loop iterations
2925: jmp pTempEntry ;copy the edge bytes for this plane to the
2926: ; temp buffer
2927:
2928: ;-----------------------------------------------------------------------;
2929: ; Table of unrolled edge copy to temp buffer loop entry points.
2930: ;-----------------------------------------------------------------------;
2931:
2932: UNROLL_LOOP_ENTRY_TABLE pfnCopyEdgeToTempEntry_1WS, \
2933: EDGE_TO_TEMP_1WS, LOOP_UNROLL_COUNT
2934:
2935: ;-----------------------------------------------------------------------;
2936: ; Unrolled loop for copying edge bytes to the temp buffer.
2937: ;-----------------------------------------------------------------------;
2938:
2939: COPY_EDGE_TO_TEMP_1WS macro ENTRY_LABEL,ENTRY_INDEX
2940: &ENTRY_LABEL&ENTRY_INDEX&:
2941: mov ah,[esi] ;get byte to copy
2942: add esi,ecx ;point to next source scan
2943: mov [edi],ah ;copy byte to temp buffer
2944: inc edi ;point to next temp buffer byte
2945: endm ;-----------------------------------;
2946:
2947: ; EBX = count of unrolled loop iterations
2948: ; ECX = offset from end of one scan's fill to start of next
2949: ; ESI = source address to copy from (screen)
2950: ; EDI = target address to copy to (temp buffer)
2951: ; Read Map set to enable the desired plane for read
2952:
2953: align 4
2954: edge_to_buffer_loop_1ws:
2955: UNROLL_LOOP COPY_EDGE_TO_TEMP_1WS,EDGE_TO_TEMP_1WS, \
2956: LOOP_UNROLL_COUNT
2957: dec ebx
2958: jnz edge_to_buffer_loop_1ws
2959:
2960: dec al ;count down planes
2961: jns copy_edge_to_buffer_plane_loop_1ws
2962:
2963: PLAIN_RET
2964:
2965:
2966: ;-----------------------------------------------------------------------;
2967: ; Copies an edge from a 2-wide source to the destination on the screen.
2968: ; Entry:
2969: ; AH = bit mask setting for edge
2970: ; ESI = source address
2971: ; EDI = destination address
2972: ; ulBlockHeight = # of bytes to copy per plane
2973: ; ulNextScan = scan width
2974: ; ulCombineMask = masking to be applied before ORing the two source
2975: ; bytes together, to keep only the data needed in preparation
2976: ; for the VGA rotator doing its stuff
2977: ; Source readable, and destination readable and writable
2978: ; Exit:
2979: ; ESI = next source address
2980: ; EDI = next destination address
2981: ;
2982: ; Preserved: EBP
2983: ;-----------------------------------------------------------------------;
2984:
2985: align 4
2986: copy_edge_2ws:
2987: mov pSrcAddr,esi
2988: mov pDestAddr,edi
2989:
2990: ; Set the clip mask for this edge.
2991:
2992: mov edx,VGA_BASE + GRAF_ADDR
2993: mov al,GRAF_BIT_MASK
2994: out dx,ax
2995:
2996: ; Leave the GC Index pointing to the Read Map.
2997:
2998: mov al,GRAF_READ_MAP
2999: out dx,al
3000:
3001: mov ebx,ulBlockHeight
3002:
3003: mov ecx,offset copy_edge_rw_2ws_full_chunk
3004: ;entry point into unrolled loop assuming we do
3005: ; a full chunk the first time
3006:
3007: ; Copy the edge in a series of chunks.
3008:
3009: copy_edge_chunk_loop_2ws:
3010:
3011: sub ebx,EDGE_CHUNK_SIZE ;scans remaining after this chunk, assuming
3012: ; a full chunk
3013: jge short @F ;do a full chunk
3014: add ebx,EDGE_CHUNK_SIZE ;not a full chunk; process all remaining
3015: ; scans
3016: mov ecx,pfnCopyEdgeRWEntry_2ws[-4][ebx*4]
3017: ;entry point into unrolled loop to copy desired
3018: ; chunk size
3019: sub ebx,ebx ;no scans after this
3020: @@:
3021: push ebx ;remember remaining scan count
3022:
3023: mov eax,(MM_C3 SHL 8) + 3 ;start by copying plane 3
3024: mov ebx,ulNextScan
3025:
3026: copy_edge_plane_loop_2ws:
3027:
3028: push eax ;preserve plane info
3029:
3030: ; Set Read Map to enable reads from plane we're copying from.
3031:
3032: mov edx,VGA_BASE + GRAF_DATA
3033: out dx,al
3034:
3035: ; Set Map Mask to enable writes to plane we're copying.
3036:
3037: mov dl,SEQ_DATA
3038: mov al,ah
3039: out dx,al
3040:
3041: mov esi,pSrcAddr
3042: mov edi,pDestAddr
3043: mov edx,ulCombineMask
3044:
3045: jmp ecx ;copy the left edge
3046:
3047:
3048: ;-----------------------------------------------------------------------;
3049: ; Table of unrolled edge loop entry points. First entry point is to copy
3050: ; 1 byte, last entry point is to copy EDGE_CHUNK_SIZE bytes.
3051: ;-----------------------------------------------------------------------;
3052:
3053: pfnCopyEdgeRWEntry_2ws label dword
3054: INDEX = 1
3055: rept EDGE_CHUNK_SIZE
3056: DEFINE_DD EDGE_RW_2WS,%INDEX
3057: INDEX = INDEX+1
3058: endm
3059:
3060:
3061: ;-----------------------------------------------------------------------;
3062: ; Unrolled loop for copying a strip of edge bytes, with 2-wide source and
3063: ; destination both readable and writable.
3064: ;-----------------------------------------------------------------------;
3065:
3066: COPY_EDGE_RW_2WS macro ENTRY_LABEL,ENTRY_INDEX
3067: &ENTRY_LABEL&ENTRY_INDEX&:
3068: mov ax,[esi] ;get word to copy
3069: add esi,ebx ;point to next source scan
3070: and eax,edx ;mask in preparation for combining bytes
3071: or al,ah ;combine the desired parts of the bytes
3072: xchg [edi],al ;read before write so Bit Mask can operate
3073: ; VGA rotates during write
3074: add edi,ebx ;point to next dest scan
3075: endm ;-----------------------------------;
3076:
3077: ; EBX = scan line width
3078: ; EDX = mask to preserve desired portions of AH and AL before combining
3079: ; ESI = source address to copy from
3080: ; EDI = target address to copy to
3081: ; Bit Mask set to desired clipping
3082: ; Read Map and Map Mask set to enable the desired plane for read and write
3083:
3084: align 4
3085: copy_edge_rw_2ws_full_chunk:
3086: UNROLL_LOOP COPY_EDGE_RW_2WS,EDGE_RW_2WS,EDGE_CHUNK_SIZE
3087:
3088: ; Do next plane within this chunk, if any.
3089:
3090: pop eax ;retrieve plane info
3091:
3092: shr ah,1 ;advance to next plane
3093: dec eax ;count down planes
3094: jns copy_edge_plane_loop_2ws
3095:
3096: ; Remember where we left off, for the next chunk.
3097:
3098: mov pSrcAddr,esi
3099: mov pDestAddr,edi
3100:
3101: ; Do next chunk within this bank block, if any.
3102:
3103: pop ebx ;retrieve remaining scan count
3104: and ebx,ebx ;any scans left?
3105: jnz copy_edge_chunk_loop_2ws ;more scans to do
3106:
3107: PLAIN_RET
3108:
3109:
3110: ;-----------------------------------------------------------------------;
3111: ; Copies an edge from the temp buffer (2 wide) to the screen.
3112: ; Entry:
3113: ; AH = bit mask setting for edge
3114: ; EDI = destination address
3115: ; pTempPlane = temp buffer from which to copy
3116: ; ulBlockHeight = # of bytes to copy per plane
3117: ; ulNextScan = scan width
3118: ; Source and dest banks both pointing to destination
3119: ; ulCombineMask = masking to be applied before ORing the two source
3120: ; bytes together, to keep only the data needed in preparation
3121: ; for the VGA rotator doing its stuff
3122: ; Exit:
3123: ; EDI = next destination address
3124: ;
3125: ; Preserved: EBP
3126: ;-----------------------------------------------------------------------;
3127:
3128: align 4
3129: copy_buffered_edge_to_screen_2ws:
3130:
3131: mov pDestAddr,edi
3132:
3133: mov edx,VGA_BASE + GRAF_ADDR
3134: mov al,GRAF_BIT_MASK
3135: out dx,ax
3136:
3137: mov pTempEntry,offset copy_edge_from_buf_full_chunk_2ws
3138: ;entry point into unrolled loop, assuming the
3139: ; first chunk is full size
3140: mov ecx,pTempPlane ;temp buffer start (copy from here)
3141: mov ebx,ulBlockHeight
3142:
3143: ; Copy the edge in a series of chunks, to avoid flicker.
3144:
3145: copy_from_buffer_chunk_loop_2ws:
3146:
3147: sub ebx,EDGE_CHUNK_SIZE ;scans remaining after this chunk, assuming
3148: ; a full chunk
3149: jge short @F ;do a full chunk
3150: add ebx,EDGE_CHUNK_SIZE ;not a full chunk; process all remaining
3151: ; scans
3152: mov ebx,pfnCopyEdgesFromBufferEntry_2ws[-4][ebx*4]
3153: mov pTempEntry,ebx ;entry point into unrolled loop to copy final
3154: ; chunk size
3155: sub ebx,ebx ;no scans after this
3156: @@:
3157: push ebx ;remember remaining scan count
3158:
3159: mov al,MM_C3 ;start by copying plane 3
3160: mov ebx,ulNextScan
3161:
3162: push ecx ;remember current temp buffer start
3163:
3164: copy_from_buffer_plane_loop_2ws:
3165:
3166: ; Set Map Mask to enable writes to plane we're copying.
3167:
3168: mov edx,VGA_BASE + SEQ_DATA
3169: out dx,al
3170:
3171: push eax ;preserve plane info
3172:
3173: mov esi,ecx ;point to current plane's source word
3174: mov eax,ulBlockHeight
3175: lea ecx,[ecx+eax*2] ;point to next plane's source word
3176:
3177: mov edi,pDestAddr
3178: mov edx,ulCombineMask
3179:
3180: jmp pTempEntry ;copy the left edge
3181:
3182:
3183: ;-----------------------------------------------------------------------;
3184: ; Table of unrolled edge copy-from-buffer loop entry points. First entry
3185: ; point is to copy 1 byte, last entry point is to copy EDGE_CHUNK_SIZE
3186: ; bytes.
3187: ;-----------------------------------------------------------------------;
3188:
3189: pfnCopyEdgesFromBufferEntry_2WS label dword
3190: INDEX = 1
3191: rept EDGE_CHUNK_SIZE
3192: DEFINE_DD EDGE_FROM_BUFFER_2WS,%INDEX
3193: INDEX = INDEX+1
3194: endm
3195:
3196:
3197: ;-----------------------------------------------------------------------;
3198: ; Unrolled loop for copying a strip of edge bytes (1 wide) from the temp
3199: ; buffer.
3200: ;-----------------------------------------------------------------------;
3201:
3202: COPY_EDGE_FROM_BUFFER_2WS macro ENTRY_LABEL,ENTRY_INDEX
3203: &ENTRY_LABEL&ENTRY_INDEX&:
3204: mov ax,[esi] ;get word to copy
3205: add esi,2 ;point to next source (temp buffer) word
3206: and eax,edx ;mask in preparation for combining bytes
3207: or al,ah ;combine the desired parts of the bytes
3208: xchg [edi],al ;read before write so Bit Mask can operate
3209: ; VGA rotates during write
3210: add edi,ebx ;point to next dest (screen) scan
3211: endm ;-----------------------------------;
3212:
3213: ; EBX = scan line width
3214: ; EDX = mask to preserve desired portions of AH and AL before combining
3215: ; ESI = source address to copy from (temp buffer)
3216: ; EDI = target address to copy to (screen)
3217: ; Bit Mask set to desired clipping
3218: ; Map Mask set to enable the desired plane for write
3219:
3220: align 4
3221: copy_edge_from_buf_full_chunk_2ws:
3222: UNROLL_LOOP COPY_EDGE_FROM_BUFFER_2WS, \
3223: EDGE_FROM_BUFFER_2WS,EDGE_CHUNK_SIZE
3224:
3225: ; Do next plane within this chunk, if any.
3226:
3227: pop eax ;retrieve plane info
3228: shr al,1 ;advance to next plane
3229: jnz copy_from_buffer_plane_loop_2ws
3230:
3231: ; Remember where we left off, for next chunk.
3232:
3233: mov pDestAddr,edi
3234: pop ecx ;get back current temp buffer start
3235: add ecx,EDGE_CHUNK_SIZE*2 ;point to next chunk's start word
3236:
3237: ; Do next chunk within this bank block, if any.
3238:
3239: pop ebx ;retrieve remaining scan count
3240: and ebx,ebx ;any scans left?
3241: jnz copy_from_buffer_chunk_loop_2ws ;more scans to do
3242:
3243: PLAIN_RET
3244:
3245:
3246: ;-----------------------------------------------------------------------;
3247: ; Copies an edge from the screen (2 wide) to the temp buffer.
3248: ; Entry:
3249: ; ESI = source address
3250: ; pTempPlane = temp buffer from which to copy
3251: ; ulBlockHeight = # of bytes to copy per plane
3252: ; ulNextScan = scan width
3253: ; Source bank pointing to source
3254: ; Exit:
3255: ; ESI = next source address
3256: ;
3257: ; Preserved: EBP
3258: ;-----------------------------------------------------------------------;
3259:
3260: align 4
3261: copy_screen_to_buffered_edge_2ws:
3262:
3263: mov pSrcAddr,esi
3264:
3265: ; Leave the GC Index pointing to the Read Map.
3266:
3267: mov edx,VGA_BASE + GRAF_ADDR
3268: mov al,GRAF_READ_MAP
3269: out dx,al
3270:
3271: mov ebx,ulBlockHeight
3272: SET_UP_UNROLL_VARS ebx,ecx,ebx,pfnCopyEdgeToTempEntry_2ws, \
3273: LOOP_UNROLL_SHIFT
3274: mov culTempCount,ebx ;remember # of unrolled loop iterations
3275: mov pTempEntry,ecx ;ditto for entry point
3276:
3277: mov ecx,ulNextScan
3278: mov edi,pTempPlane ;dest offset in temp buffer for plane 3 bytes.
3279: ;The rest of the planes are stored
3280: ; consecutively
3281: mov eax,3 ;start by copying plane 3
3282: copy_edge_to_buf_pl_loop_2ws:
3283: mov esi,pSrcAddr ;source pointer
3284:
3285: mov edx,VGA_BASE + GRAF_DATA
3286: out dx,al ;set Read Map to plane from which we're copying
3287:
3288: mov ebx,culTempCount ;# of unrolled loop iterations
3289: jmp pTempEntry ;copy the edge bytes for this plane to the
3290: ; temp buffer
3291:
3292: ;-----------------------------------------------------------------------;
3293: ; Table of unrolled edge copy to temp buffer loop entry points.
3294: ;-----------------------------------------------------------------------;
3295:
3296: UNROLL_LOOP_ENTRY_TABLE pfnCopyEdgeToTempEntry_2WS, \
3297: EDGE_TO_TEMP_2WS, LOOP_UNROLL_COUNT
3298:
3299: ;-----------------------------------------------------------------------;
3300: ; Unrolled loop for copying edge bytes to the temp buffer.
3301: ;-----------------------------------------------------------------------;
3302:
3303: COPY_EDGE_TO_TEMP_2WS macro ENTRY_LABEL,ENTRY_INDEX
3304: &ENTRY_LABEL&ENTRY_INDEX&:
3305: mov dx,[esi] ;get byte to copy
3306: add esi,ecx ;point to next source scan
3307: mov [edi],dx ;copy byte to temp buffer
3308: add edi,2 ;point to next temp buffer byte
3309: endm ;-----------------------------------;
3310:
3311: ; EBX = count of unrolled loop iterations
3312: ; ECX = offset from end of one scan's fill to start of next
3313: ; ESI = source address to copy from (screen)
3314: ; EDI = target address to copy to (temp buffer)
3315: ; Read Map set to enable the desired plane for read
3316:
3317: align 4
3318: edge_to_buffer_loop_2ws:
3319: UNROLL_LOOP COPY_EDGE_TO_TEMP_2WS,EDGE_TO_TEMP_2WS, \
3320: LOOP_UNROLL_COUNT
3321: dec ebx
3322: jnz edge_to_buffer_loop_2ws
3323:
3324: dec eax ;count down planes
3325: jns copy_edge_to_buf_pl_loop_2ws
3326:
3327: PLAIN_RET
3328:
3329:
3330: ;-----------------------------------------------------------------------;
3331:
3332: endProc vNonAlignedSrcCopy
3333:
3334: _TEXT$04 ends
3335:
3336: end
3337:
3338:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.