![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vgablts.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 / vga256 / i386|
Return to vgablts.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256 / i386 |
1.1 root 1: ;---------------------------Module-Header------------------------------;
2: ; Module Name: vgablts.asm
3: ;
4: ; Copyright (c) 1992-1993 Microsoft Corporation
5: ;-----------------------------------------------------------------------;
6: ;-----------------------------------------------------------------------;
7: ; VOID vTrgBlt(PDEV * ppdev, ULONG culRcl, RECTL * prcl, MIX ulMix,
8: ; ULONG ulClr, POINTL * pptlBrush)
9: ; Input:
10: ; ppdev - pointer to PDEV for surface to which to draw
11: ; culRcl - # of rectangles to fill
12: ; prcl - pointer to list of rectangles to fill
13: ; ulMix - mix rop with which to fill
14: ; ulClr - color with which to fill
15: ; pptlBrush - not used
16: ;
17: ; Performs accelerated solid area fills for all mixes.
18: ;
19: ;-----------------------------------------------------------------------;
20: ;
21: ; Note: Assumes all rectangles have positive heights and widths. Will not
22: ; work properly if this is not the case.
23: ;
24: ;-----------------------------------------------------------------------;
25: ;
26: ; Note: Cases where the width of the whole bytes fill is equal to the
27: ; width of the bitmap could be sped up by using a single REP MOVS or REP
28: ; STOS, but how often does WIN32 do a fill that's the width of the screen?
29: ; Not very.
30: ;
31: ;-----------------------------------------------------------------------;
32:
33: comment $
34:
35: The overall approach of this module is to accept a list of rectangles to
36: fill, set up the VGA hardware for the desired fill, and then fill the
37: rectangles one at a time. Each rectangle fill is set up for everything
38: but vertical parameters, and then decomposed into the sections that
39: intersect each VGA bank; each section is drawn in turn. The drawing code
40: is heavily unrolled for performance, and vectors are set up so that the
41: drawing code appropriate for the desired fill is essentially threaded
42: together.
43:
44: commend $
45:
46: ;-----------------------------------------------------------------------;
47:
48: ; Set LOOP_UNROLL_SHIFT to the log2 of the number of times you want loops in
49: ; this module unrolled. For example, LOOP_UNROLL_SHIFT of 3 yields 2**3 = 8
50: ; times unrolling. This is the only thing you need to change to control
51: ; unrolling.
52:
53: LOOP_UNROLL_SHIFT equ 2
54:
55: ;-----------------------------------------------------------------------;
56:
57: .386
58:
59: ifndef DOS_PLATFORM
60: .model small,c
61: else
62: ifdef STD_CALL
63: .model small,c
64: else
65: .model small,pascal
66: endif; STD_CALL
67: endif; DOS_PLATFORM
68:
69: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
70: assume fs:nothing,gs:nothing
71:
72: .xlist
73: include stdcall.inc ;calling convention cmacros
74: include i386\strucs.inc
75: include i386\driver.inc
76: include i386\egavga.inc
77: include i386\unroll.inc
78: include i386\ropdefs.inc
79:
80: .list
81:
82: ;-----------------------------------------------------------------------;
83:
84: .data
85:
86: ;-----------------------------------------------------------------------;
87: ; Left edge clip masks for intrabyte start addresses 0 through 3.
88: ; Whole byte cases are flagged as 0ffh.
89: public jLeftMask
90: jLeftMask label byte
91: db 0ffh,0eh,0ch,08h
92:
93: ;-----------------------------------------------------------------------;
94: ; Right edge clip masks for intrabyte end addresses (non-inclusive)
95: ; 0 through 3. Whole byte cases are flagged as 0ffh.
96: public jRightMask
97: jRightMask label byte
98: db 0ffh,01h,03h,07h
99:
100: ;-----------------------------------------------------------------------;
101: ; Tables used to set up for the desired raster op. Note that entries for raster
102: ; ops that aren't handled here are generally correct, except that they ignore
103: ; need for inversion of the destination, which those rops require.
104:
105: ; Table used to force off the drawing color for R2_BLACK (0).
106: ; The first entry is ignored; there is no mix 0.
107: public jForceOffTable
108: jForceOffTable db 0
109: db 000h,0ffh,0ffh,0ffh,0ffh,0ffh,0ffh,0ffh
110: db 0ffh,0ffh,000h,0ffh,0ffh,0ffh,0ffh,0ffh
111:
112: ;-----------------------------------------------------------------------;
113: ; Table used to force on the drawing color for R2_NOT (Dn) and R2_WHITE (1).
114: ; The first entry is ignored; there is no mix 0.
115: public jForceOnTable
116: jForceOnTable db 0, 0,0,0,0,0,0ffh,0,0,0,0,0,0,0,0,0,0ffh
117:
118: ;-----------------------------------------------------------------------;
119: ; Table used to invert the passed-in drawing color for Pn mixes.
120: ; The first entry is ignored; there is no mix 0.
121: public jNotTable
122: jNotTable db 0, 0,0ffh,0ffh,0ffh,0,0,0,0ffh,0,0ffh,0,0ffh,0,0,0,0
123:
124: ;-----------------------------------------------------------------------;
125: ; Table of VGA ALU logical functions corresponding to mixes. Note that Dn is
126: ; handled as a separate preceding inversion pass when part of a more complex
127: ; mix.
128: ; The first entry is ignored; there is no mix 0.
129: public jALUFuncTable
130: jALUFuncTable db 0
131: db DR_SET,DR_AND,DR_AND,DR_SET
132: db DR_AND,DR_XOR,DR_XOR,DR_OR
133: db DR_AND,DR_XOR, 0,DR_OR
134: db DR_SET,DR_OR ,DR_OR ,DR_SET
135:
136: ;-----------------------------------------------------------------------;
137: ; 1 entries mark rops that require two passes, one to invert the destination
138: ; and then another to finish the rop.
139: ; The first entry is ignored; there is no mix 0.
140: public jInvertDest
141: jInvertDest db 0, 0,1,0,0,1,0,0,1,0,0,0,0,0,1,0,0
142:
143: ;-----------------------------------------------------------------------;
144: ; Table of routines to be called to draw edges, according to which edges are
145: ; partial and which edges are whole bytes.
146: align 4
147: pfnEdgeDrawing label dword
148: dd do_right_edge_bytes
149: dd do_both_edge_bytes
150: dd check_next_bank
151: dd do_left_edge_bytes
152:
153: ;-----------------------------------------------------------------------;
154: ; Table of pointers to tables used to find entries points in unrolled wide
155: ; whole byte code.
156:
157: align 4
158: pfnWideWholeRep label dword
159: dd pfnDrawWideW00Entry
160: dd pfnDrawWideW01Entry
161: dd pfnDrawWideW02Entry
162: dd pfnDrawWideW03Entry
163: dd pfnDrawWideW10Entry
164: dd pfnDrawWideW11Entry
165: dd pfnDrawWideW12Entry
166: dd pfnDrawWideW13Entry
167: dd pfnDrawWideW20Entry
168: dd pfnDrawWideW21Entry
169: dd pfnDrawWideW22Entry
170: dd pfnDrawWideW23Entry
171: dd pfnDrawWideW30Entry
172: dd pfnDrawWideW31Entry
173: dd pfnDrawWideW32Entry
174: dd pfnDrawWideW33Entry
175:
176: ;-----------------------------------------------------------------------;
177: ; Table of pointers to tables used to find entry points in narrow,
178: ; special-cased unrolled non-replace whole byte code.
179:
180: ; Note: The breakpoint where one should switch from special-casing to
181: ; REP MOVSB is purely a guess on my part. 5 seemed reasonable.
182:
183: align 4
184: pfnWholeBytesNonReplaceEntries label dword
185: dd 0 ;we never get a 0-wide case
186: dd pfnDraw1WideRWEntry
187: dd pfnDraw2WideRWEntry
188: dd pfnDraw3WideRWEntry
189: dd pfnDraw4WideRWEntry
190: MAX_NON_REPLACE_SPECIAL equ ($-pfnWholeBytesNonReplaceEntries)/4
191:
192: ;-----------------------------------------------------------------------;
193: ; Table of pointers to tables used to find entry points in narrow, special-
194: ; cased unrolled replace whole byte code.
195:
196: ; Note: The breakpoint where one should switch from special-casing to
197: ; REP STOS is purely a guess on my part. 8 seemed reasonable.
198:
199: ; Start address MOD 3 is 0.
200: align 4
201: pfnWholeBytesMod0ReplaceEntries label dword
202: dd 0 ;we never get a 0-wide case
203: dd pfnDraw1WideWEntry
204: dd pfnDraw2WideWEntry
205: dd pfnDraw3WideWEvenEntry
206: dd pfnDraw4WideWEntry
207: dd pfnDraw5WideWEvenEntry
208: dd pfnDraw6WideWMod3_0Entry
209: dd pfnDraw7WideWMod3_0Entry
210: dd pfnDraw8WideWMod3_0Entry
211: MAX_REPLACE_SPECIAL equ ($-pfnWholeBytesMod0ReplaceEntries)/4
212:
213: ; Start address MOD 3 is 1.
214: align 4
215: pfnWholeBytesMod1ReplaceEntries label dword
216: dd 0 ;we never get a 0-wide case
217: dd pfnDraw1WideWEntry
218: dd pfnDraw2WideWEntry
219: dd pfnDraw3WideWOddEntry
220: dd pfnDraw4WideWEntry
221: dd pfnDraw5WideWOddEntry
222: dd pfnDraw6WideWMod3_1Entry
223: dd pfnDraw7WideWMod3_1Entry
224: dd pfnDraw8WideWMod3_1Entry
225:
226: ; Start address MOD 3 is 2.
227: align 4
228: pfnWholeBytesMod2ReplaceEntries label dword
229: dd 0 ;we never get a 0-wide case
230: dd pfnDraw1WideWEntry
231: dd pfnDraw2WideWEntry
232: dd pfnDraw3WideWEvenEntry
233: dd pfnDraw4WideWEntry
234: dd pfnDraw5WideWEvenEntry
235: dd pfnDraw6WideWMod3_2Entry
236: dd pfnDraw7WideWMod3_2Entry
237: dd pfnDraw8WideWMod3_2Entry
238:
239: ; Start address MOD 3 is 3.
240: align 4
241: pfnWholeBytesMod3ReplaceEntries label dword
242: dd 0 ;we never get a 0-wide case
243: dd pfnDraw1WideWEntry
244: dd pfnDraw2WideWEntry
245: dd pfnDraw3WideWOddEntry
246: dd pfnDraw4WideWEntry
247: dd pfnDraw5WideWOddEntry
248: dd pfnDraw6WideWMod3_1Entry
249: dd pfnDraw7WideWMod3_3Entry
250: dd pfnDraw8WideWMod3_3Entry
251:
252: ; Master MOD 3 alignment look-up table for entry tables for four possible
253: ; alignments for narrow, special-cased unrolled replace whole byte code.
254: align 4
255: pfnWholeBytesReplaceMaster label dword
256: dd pfnWholeBytesMod0ReplaceEntries
257: dd pfnWholeBytesMod1ReplaceEntries
258: dd pfnWholeBytesMod2ReplaceEntries
259: dd pfnWholeBytesMod3ReplaceEntries
260:
261: ;-----------------------------------------------------------------------;
262:
263: .code
264:
265: ;-----------------------------------------------------------------------;
266:
267: cProc vTrgBlt,24,< \
268: uses esi edi ebx, \
269: ppdev: ptr, \
270: culRcl: dword, \
271: prcl: ptr RECTL, \
272: ulMix: dword, \
273: ulColor: dword, \
274: pptlBrsuh:ptr POINTL >
275:
276: local ulRowOffset :dword ;Offset from start of scan line of
277: ; first byte to fill
278: local ulWholeBytes :dword ;# of whole bytes to fill
279: local ulWholeDwords :dword ;# of whole dwords to fill
280: local pfnWholeFn :dword ;pointer to routine used to draw
281: ; whole bytes
282: local ulScanWidth :dword ;offset from start of one scan to start
283: ; of next
284: local ulNextScan :dword ;offset from end of one scan line's
285: ; fill to start of next
286: local ulCurrentTopScan :dword ;top scan line to fill in current bank
287: local ulMasks :dword ;low byte = right mask, high byte =
288: ; left mask
289: local ulBottomScan :dword ;bottom scan line of fill rectangle
290: local pfnDraw1WideVector :dword ;address at which to enter unrolled
291: ; edge loop
292: local jALUFunc :dword ;VGA ALU logical operation (SET, AND,
293: ; OR, or XOR)
294: local pfnStartDrawing :dword ;pointer to function to call to start
295: ; drawing
296: local pfnContinueDrawing :dword ;pointer to function to call to
297: ; continue drawing after doing whole
298: ; bytes
299: local ulLeftEdgeAdjust :dword ;used to bump the whole bytes start
300: ; address past the left edge when the
301: ; left edge is partial
302: local pfnWholeBytes :dword ;pointer to table of entry points
303: ; into unrolled loops for whole byte
304: ; filling
305: local jInvertDestFirst :dword ;1 if the rop requires a pass to invert
306: ; the destination before the normal
307: ; pass
308: local ulDrawingColor :dword ;color byte with which to fill,
309: ; replicated to a dword
310: local ppfnDrawEdgeTable :dword ;points to table to be used to look up
311: ; unrolled entry points for edge
312: ; bytes (pfnDraw1WideRWEntry or
313: ; pfnDraw1WideWEntry)
314:
315: ;-----------------------------------------------------------------------;
316: ; CLD is assumed on entry.
317: ;-----------------------------------------------------------------------;
318:
319: ;-----------------------------------------------------------------------;
320: ; Make sure there's something to draw; clip enumerations can be empty.
321: ;-----------------------------------------------------------------------;
322:
323: cmp culRcl,0 ;any rects to fill?
324: jz vTrgBlts_done ;no, we're done
325:
326:
327: ;-----------------------------------------------------------------------;
328: ; Set up variables that are constant for the entire time we're in this
329: ; module.
330: ;-----------------------------------------------------------------------;
331:
332: ;-----------------------------------------------------------------------;
333: ; Set up for the desired raster op.
334: ;-----------------------------------------------------------------------;
335:
336: sub ebx,ebx ;ignore any background mix; we're only
337: mov bl,byte ptr ulMix ; concerned with the foreground in this
338: ; module
339: cmp ebx,R2_NOP ;is this NOP?
340: jz vTrgBlts_done ;yes, we're done
341: mov al,jInvertDest[ebx] ;remember whether we need to
342: mov byte ptr jInvertDestFirst,al ; invert the destination before
343: ; finishing the rop
344: mov ah,byte ptr ulColor ;get the drawing color
345: and ah,jForceOffTable[ebx] ;force color to 0 if necessary
346: ; (R2_BLACK)
347: or ah,jForceOnTable[ebx] ;force color to 0ffh if necessary
348: ; (R2_WHITE, R2_NOT)
349: xor ah,jNotTable[ebx] ;invert color if necessary (any Pn mix)
350: ;at this point, CH has the color we
351: ; want to draw with; set up the VGA
352: ; hardware to draw with that color
353: mov al,ah ;replicate the drawing color to a dword
354: mov edx,eax
355: shl eax,16
356: mov ax,dx
357: mov ulDrawingColor,eax ;remember drawing color
358:
359: mov ppfnDrawEdgeTable,offset pfnDraw1WideWEntry
360: ;assume replace-type rop, so we can
361: ; draw edge bytes with the write-
362: ; without-read code pointed to by this
363: ; table
364: mov ah,jALUFuncTable[ebx] ;get the ALU logical function
365: and ah,ah ;is the logical function DR_SET?
366: .errnz DR_SET
367: jz short skip_ALU_set ;yes, don't have to set because that's
368: ; the VGA's default state
369: mov edx,VGA_BASE + GRAF_ADDR
370: mov al,GRAF_DATA_ROT
371: out dx,ax ;set the ALU logical function
372: mov ppfnDrawEdgeTable,offset pfnDraw1WideRWEntry
373: ;draw edge bytes with the code pointed
374: ; to by this table (read/write)
375: skip_ALU_set:
376: mov byte ptr jALUFunc,ah ;remember the ALU logical function
377:
378: ;-----------------------------------------------------------------------;
379: ; Fill the current rectangle with the specified raster op and color.
380: ;-----------------------------------------------------------------------;
381:
382: fill_rect_loop:
383:
384: ;-----------------------------------------------------------------------;
385: ; Set up variables that are constant from bank to bank during a single
386: ; fill.
387: ;-----------------------------------------------------------------------;
388:
389: ;-----------------------------------------------------------------------;
390: ; Set up masks and widths.
391: ;-----------------------------------------------------------------------;
392:
393: mov edi,prcl ;point to rectangle to fill
394: mov eax,[edi].yBottom
395: mov ulBottomScan,eax ;remember the bottom scan line of fill
396:
397: mov ebx,[edi].xRight ;right edge of fill (non-inclusive)
398: mov ecx,ebx
399: and ecx,011b ;intrabyte address of right edge
400: mov ah,jRightMask[ecx] ;right edge mask
401:
402: mov esi,[edi].xLeft ;left edge of fill (inclusive)
403: mov ecx,esi
404: shr ecx,2 ;/4 for start offset from left edge
405: ; of scan line
406: mov ulRowOffset,ecx ;remember offset from start of scan
407: ; line
408: sub ebx,esi ;width in pixels of fill
409:
410: and esi,011b ;intrabyte address of left edge
411: mov al,jLeftMask[esi] ;left edge mask
412:
413: dec ebx ;make inclusive on right
414: add ebx,esi ;inclusive width, starting counting at
415: ; the beginning of the left edge byte
416: shr ebx,2 ;width of fill in bytes touched - 1
417: jnz short more_than_1_byte ;more than 1 byte is involved
418:
419: ; Only one byte will be affected. Combine first/last masks.
420:
421: and al,ah ;we'll use first byte mask only
422: xor ah,ah ;want last byte mask to be 0
423: inc ebx ;so there's one count to subtract below
424: ; if this isn't a whole edge byte
425: more_than_1_byte:
426:
427: ; If all pixels in the left edge are altered, combine the first byte into the
428: ; whole byte count and clear the first byte mask, because we can handle solid
429: ; edge bytes faster as part of the whole bytes. Ditto for the right edge.
430:
431: sub ecx,ecx ;edge whole-status accumulator
432: cmp al,-1 ;is left edge a whole byte or partial?
433: adc ecx,ecx ;ECX=1 if left edge partial, 0 if whole
434: sub ebx,ecx ;if left edge partial, deduct it from
435: ; the whole bytes count
436: mov ulLeftEdgeAdjust,ecx ;for skipping over the left edge if
437: ; it's partial when pointing to the
438: ; whole bytes
439: and ah,ah ;is right edge mask 0, meaning this
440: ; fill is only 1 byte wide?
441: jz short save_masks ;yes, no need to do anything
442: cmp ah,-1 ;is right edge a whole byte or partial?
443: jnz short save_masks ;partial
444: add ecx,2 ;bit 1 of ECX=0 if right edge partial,
445: ; 1 if whole;
446: ;bit 1=0 if left edge partial, 1 whole
447: inc ebx ;if right edge whole, include it in the
448: ; whole bytes count
449: save_masks:
450: mov ulMasks,eax ;save left and right clip masks
451: mov ulWholeBytes,ebx ;save # of whole bytes
452:
453: mov ecx,pfnEdgeDrawing[ecx*4] ;set address of routine to draw
454: mov pfnContinueDrawing,ecx ; all partial (non-whole) edges
455:
456: and ebx,ebx ;any whole bytes?
457: jz short start_vec_set ;no
458: ;yes, so draw the whole bytes before
459: ; the edge bytes
460:
461: ; The whole bytes loop depends on the type of operation being done. If the
462: ; operation is one which uses DR_SET, then we can use a STOS-type operation,
463: ; else we have to use a MOVSB-type operation (to load the latches with the
464: ; existing contents of display memory to allow the ALUs to work).
465:
466: cmp byte ptr jALUFunc,DR_SET ;is it a replace-type rop?
467: jz short is_replace_type ;yes
468: ;no, set up for non-replace whole bytes
469: mov ecx,offset whole_bytes_non_replace_wide
470: ;assume too wide to special-case
471: cmp ebx,MAX_NON_REPLACE_SPECIAL ;too wide to special case?
472: jnb short start_vec_set ;yes
473: mov ecx,pfnWholeBytesNonReplaceEntries[ebx*4] ;no, point to entry
474: mov pfnWholeBytes,ecx ; table for width
475: mov ecx,offset whole_bytes_special
476: ;set up to call special routine to fill
477: ; whole bytes
478: jmp short start_vec_set
479:
480: align 4
481: is_replace_type: ;set up for replace-type rop
482: cmp ebx,MAX_REPLACE_SPECIAL ;too wide to special case?
483: jnb short is_wide_replace ;yes
484: ;narrow enough to special case. Look up
485: ; the entry table for the special case
486: ; base on the start alignment
487: mov ecx,ulRowOffset
488: add ecx,ulLeftEdgeAdjust ;left edge whole bytes start offset
489: and ecx,011b ;left edge whole bytes start alignment
490: ; MOD 3
491: mov ecx,pfnWholeBytesReplaceMaster[ecx*4] ;look up table of entry
492: ; tables for alignment
493: mov ecx,[ecx+ebx*4] ;look up entry table for width
494: mov pfnWholeBytes,ecx ; table for width
495: mov ecx,offset whole_bytes_special
496: ;set up to call special routine to fill
497: ; whole bytes
498: jmp short start_vec_set
499:
500: align 4
501: is_wide_replace: ;set up for wide replace-type op
502: ;Note: assumes there is at least one
503: ; full dword involved!
504: mov ecx,ulRowOffset
505: add ecx,ulLeftEdgeAdjust ;left edge whole bytes start offset
506: neg ecx
507: and ecx,011b
508: mov edx,ebx
509: sub edx,ecx ;ignore odd leading bytes
510: mov eax,edx
511: shr edx,2 ;# of whole dwords across (not counting
512: ; odd leading & trailing bytes)
513: mov ulWholeDwords,edx
514: and eax,011b ;# of odd (fractional) trailing bytes
515: shl ecx,2
516: or ecx,eax ;build a look-up index from the number
517: ; of leading and trailing bytes
518: mov ecx,pfnWideWholeRep[ecx*4] ;proper drawing handler for front/
519: mov pfnWholeBytes,ecx ; back alignment
520: mov ecx,offset whole_bytes_rep_wide
521: ;set up to call routine to perform wide
522: ; whole bytes fill
523: start_vec_set:
524: mov pfnStartDrawing,ecx ; all partial (non-whole) edges
525:
526: mov ecx,ppdev
527: mov eax,[ecx].pdev_lPlanarNextScan
528: mov ulScanWidth,eax ;local copy of scan line width
529: sub eax,ebx ;EAX = delta to next scan
530: mov ulNextScan,eax
531:
532:
533: ;-----------------------------------------------------------------------;
534: ; Fill this rectangle.
535: ;-----------------------------------------------------------------------;
536:
537: cmp byte ptr jInvertDestFirst,1
538: ;is this an invert-dest-plus-something-
539: ; else rop that requires two passes?
540: jz short do_invert_dest_rop ;yes, special case with two passes
541:
542: do_single_pass:
543: call draw_banks
544:
545:
546: ;-----------------------------------------------------------------------;
547: ; See if there are any more rectangles to fill.
548: ;-----------------------------------------------------------------------;
549:
550: add prcl,(size RECTL) ;point to the next rectangle, if there is one
551: dec culRcl ;count down the rectangles to fill
552: jnz fill_rect_loop
553:
554:
555: ;-----------------------------------------------------------------------;
556: ; We have filled all rectangles. Restore the VGA to its default state.
557: ;-----------------------------------------------------------------------;
558:
559: cmp byte ptr jALUfunc,DR_SET ;is the logical function already SET?
560: jnz short @F ;no, need to reset it
561: cRet vTrgBlt ;yes, no need to reset it
562:
563: align 4
564: @@:
565: mov edx,VGA_BASE + GRAF_ADDR
566: mov eax,(DR_SET shl 8) + GRAF_DATA_ROT ;set the logical function to
567: out dx,ax ; SET
568: vTrgBlts_done:
569: cRet vTrgBlt
570:
571:
572: ;-----------------------------------------------------------------------;
573: ; Handles rops that require two passes, the first being a destination
574: ; inversion pass.
575: ;-----------------------------------------------------------------------;
576:
577: align 4
578: do_invert_dest_rop:
579:
580: ; Set up the VGA's hardware for inversion
581:
582: mov eax,ulDrawingColor ;remember the normal drawing color
583: push eax
584: mov ulDrawingColor,-1 ;with XOR, this flips all bits
585:
586: mov edx,VGA_BASE + GRAF_ADDR
587: mov eax,(DR_XOR shl 8) + GRAF_DATA_ROT
588: out dx,ax ;logical function = XOR to invert
589:
590: ; Invert the destination
591:
592: call draw_banks
593:
594: ; Restore the VGA's hardware to the state required for the second pass.
595:
596: mov edx,VGA_BASE + GRAF_ADDR
597: mov ah,byte ptr jALUFunc
598: mov al,GRAF_DATA_ROT
599: out dx,ax ;set the ALU logical function back to
600: ; proper state for the rest of the rop
601:
602: pop eax
603: mov ulDrawingColor,eax ;restore the normal drawing color
604:
605: ; Perform the second pass to finish the rop.
606:
607: jmp do_single_pass
608:
609:
610: ;-----------------------------------------------------------------------;
611: ; Fills all banks in the current fill rectangle. Called once per fill
612: ; rectangle, except for destination-inversion-plus-something-else rops.
613: ;-----------------------------------------------------------------------;
614:
615: align 4
616: draw_banks:
617:
618: ;-----------------------------------------------------------------------;
619: ; Map in the bank containing the top scan to fill, if it's not mapped in
620: ; already.
621: ;-----------------------------------------------------------------------;
622:
623: mov edi,prcl ;point to rectangle to fill
624: mov ecx,ppdev ;point to PDEV
625: mov eax,[edi].yTop ;top scan line of fill
626: mov ulCurrentTopScan,eax ;this will be the fill top in 1st bank
627:
628: cmp eax,[ecx].pdev_rcl1PlanarClip.yTop ;is fill top less than
629: ; current bank?
630: jl short map_init_bank ;yes, map in proper bank
631: cmp eax,[ecx].pdev_rcl1PlanarClip.yBottom ;fill top greater than
632: ; current bank?
633: jl short init_bank_mapped ;no, proper bank already mapped
634: map_init_bank:
635:
636: ; Map in the bank containing the top scan line of the fill.
637:
638: ptrCall <dword ptr [ecx].pdev_pfnPlanarControl>,<ecx,eax,JustifyTop>
639:
640: init_bank_mapped:
641:
642: ;-----------------------------------------------------------------------;
643: ; Main loop for processing fill in each bank.
644: ;-----------------------------------------------------------------------;
645:
646: ; Compute the starting address and scan line count for the initial bank.
647:
648: mov eax,ppdev ;point to PDEV
649: mov ebx,ulBottomScan ;bottom of destination rectangle
650: cmp ebx,[eax].pdev_rcl1PlanarClip.yBottom
651: ;which comes first, the bottom of the
652: ; dest rect or the bottom of the
653: ; current bank?
654: jl short BottomScanSet ;fill bottom comes first, so draw to
655: ; that; this is the last bank in fill
656: mov ebx,[eax].pdev_rcl1PlanarClip.yBottom
657: ;bank bottom comes first; draw to
658: ; bottom of bank
659: BottomScanSet:
660: mov edi,ulCurrentTopScan ;top scan line to fill in current bank
661: sub ebx,edi ;# of scans to fill in bank
662: imul edi,ulScanWidth ;offset of starting scan line
663:
664: ; Note that the start of the bitmap will change each time through the
665: ; bank loop, because the start of the bitmap is varied to map the
666: ; desired scan line to the banking window.
667:
668: add edi,[eax].pdev_pvBitmapStart ;start of scan in bitmap
669: add edi,ulRowOffset ;EDI = start offset of fill in bitmap
670:
671: ; We have computed the starting address and scan count. Time to start drawing
672: ; in the initial bank.
673:
674: jmp pfnStartDrawing
675:
676:
677: ;-----------------------------------------------------------------------;
678: ; Whole byte fills.
679: ;-----------------------------------------------------------------------;
680:
681: ;-----------------------------------------------------------------------;
682: ; Handles non-replace whole byte fills wider than the maximum special
683: ; case width.
684: ;
685: ; The destination is not involved, so a STOS (or equivalent) can be used
686: ; (no read needed before write).
687: ;-----------------------------------------------------------------------;
688:
689: align 4
690: whole_bytes_rep_wide:
691: push ebx ;save scan count
692: push edi ;save starting address
693:
694: mov eax,pfnWholeBytes ;point to entry table for unrolled
695: ; loop for whole byte width
696: SET_UP_UNROLL_VARS ebx,ecx, ebx,[eax], LOOP_UNROLL_SHIFT
697: add edi,ulLeftEdgeAdjust ;point to first whole byte to fill
698: mov esi,ulWholeDwords ;whole dwords width
699: mov edx,ulNextScan ;offset from end of one scan line to
700: ; start of next
701: mov eax,ulDrawingColor ;each byte is color with which to fill
702:
703: call ecx ;draw the wide whole bytes
704:
705: pop edi ;restore screen pointer
706: pop ebx ;restore fill scan count
707: jmp pfnContinueDrawing ;either keep drawing or we're done
708:
709:
710: ;-----------------------------------------------------------------------;
711: ; Handles both replace and non-replace whole byte fills narrow enough to
712: ; special case.
713: ;-----------------------------------------------------------------------;
714:
715: align 4
716: whole_bytes_special:
717: push ebx ;save scan count
718: push edi ;save starting address
719:
720: mov eax,pfnWholeBytes ;point to entry table for unrolled
721: ; loop for whole byte width
722: SET_UP_UNROLL_VARS ebx,edx, ebx,[eax], LOOP_UNROLL_SHIFT
723: add edi,ulLeftEdgeAdjust ;point to first whole byte to fill
724: mov ecx,ulScanWidth ;offset to next scan line
725: mov eax,ulDrawingColor ;each byte is color with which to fill
726:
727: call edx ;draw the whole bytes
728:
729: pop edi ;restore screen pointer
730: pop ebx ;restore fill scan count
731: jmp pfnContinueDrawing ;either keep drawing or we're done
732:
733:
734: ;-----------------------------------------------------------------------;
735: ; Handles non-replace whole byte fills wider than the maximum special case
736: ; width.
737: ;
738: ; The destination is involved, so a MOVSB (or equivalent) must be
739: ; performed in order to do a read before write to give the ALUs something
740: ; to work with.
741: ;-----------------------------------------------------------------------;
742:
743: align 4
744: whole_bytes_non_replace_wide:
745: push ebx ;save scan count
746: push edi ;save starting address
747:
748: add edi,ulLeftEdgeAdjust ;point to first whole byte to fill
749: mov esi,ulWholeBytes ;whole bytes width
750: mov edx,ulNextScan ;offset from end of one scan line to
751: ; start of next
752: mov eax,ulDrawingColor ;each byte is color with which to fill
753:
754: ;-----------------------------------------------------------------------;
755: ; 5-or-wider read before write loop.
756: ;
757: ; Entry:
758: ; EAX = # of bytes to fill across scan line (needed only by 5-or-wider
759: ; handler)
760: ; EBX = unrolled loop count
761: ; EDX = offset from end of one scan line to the start of the next next
762: ; EDI = start offset
763: ;
764: ; EBX, ECX, ESI, EDI modified. All other registers preserved.
765:
766: ; 5-or-wider read/write.
767:
768: draw_wide_rw_loop:
769: mov ecx,esi
770: @@:
771: mov ah,[edi] ;latch the target address. The data read
772: ; doesn't matter
773: mov [edi],al ;merge the drawing color with the latched
774: ; target address according to the selected ALU
775: ; function, and write the result to display
776: ; memory
777: inc edi ;point to the next byte
778: dec ecx
779: jnz @B
780: add edi,edx
781: dec ebx
782: jnz draw_wide_rw_loop
783:
784: pop edi ;restore screen pointer
785: pop ebx ;restore fill scan count
786: jmp pfnContinueDrawing ;either keep drawing or we're done
787:
788:
789: ;-----------------------------------------------------------------------;
790: ; Process any left/right columns that that have to be done.
791: ;
792: ; Currently:
793: ; EBX = height to fill, in scans
794: ; EDI --> first byte of left edge
795: ;-----------------------------------------------------------------------;
796:
797: ;-----------------------------------------------------------------------;
798: ; Handle case where both edges are partial (non-whole) bytes. We don't
799: ; have to read before write because we're using the Map Mask, not the
800: ; Bit Mask.
801: ;-----------------------------------------------------------------------;
802: align 4
803: public do_both_edge_bytes
804: do_both_edge_bytes:
805:
806: ; Set up variables for entering unrolled loop.
807:
808: mov al,byte ptr ulMasks ;this will become the clip mask for the
809: ; left edge
810: mov edx,VGA_BASE + SEQ_DATA ;SEQ_INDEX already points to Map Mask
811: out dx,al ;set Map Mask for left edge
812:
813: mov ecx,ppfnDrawEdgeTable
814: SET_UP_UNROLL_VARS ebx,edx, ebx,[ecx], LOOP_UNROLL_SHIFT
815: mov pfnDraw1WideVector,edx
816:
817: mov ecx,ulScanWidth ;offset from one scan to next
818:
819: mov esi,ulWholeBytes ;ESI = # of whole bytes
820: lea esi,[esi+edi+1] ;--> start for right edge
821: mov eax,ulDrawingColor ;each byte is color with which to fill
822:
823: push ebx ;preserve scan line count
824: call edx ;jump into the unrolled loop to draw
825: pop ebx ;restore scan line count
826:
827: mov edi,esi ;point to first right edge byte
828: mov al,byte ptr ulMasks+1 ;this will become the Bit Mask for the
829: ; right edge
830: mov edx,VGA_BASE + SEQ_DATA ;SEQ_INDEX already points to Map Mask
831: out dx,al ;set Map Mask for left edge
832:
833: mov eax,ulDrawingColor ;each byte is color with which to fill
834:
835: push offset edges_done ;return here
836: jmp pfnDraw1WideVector ;jump into the unrolled loop to draw
837:
838: ;-----------------------------------------------------------------------;
839: ; Handle case where only the left edge is partial (non-whole).
840: ;-----------------------------------------------------------------------;
841: align 4
842: do_left_edge_bytes:
843:
844: ; Set up variables for entering unrolled loop.
845:
846: mov ecx,ppfnDrawEdgeTable
847: SET_UP_UNROLL_VARS ebx,esi, ebx,[ecx], LOOP_UNROLL_SHIFT
848:
849: mov ecx,ulScanWidth ;offset from one scan to next
850: mov al,byte ptr ulMasks ;this will become the Bit Mask for the
851: ; left edge
852: mov edx,VGA_BASE + SEQ_DATA ;SEQ_INDEX already points to Map Mask
853: out dx,al ;set Map Mask for left edge
854:
855: mov eax,ulDrawingColor ;each byte is color with which to fill
856:
857: push offset edges_done ;return here
858: jmp esi ;jump into the unrolled loop to draw
859:
860: ;-----------------------------------------------------------------------;
861: ; Handle case where only the right edge is partial (non-whole).
862: ;-----------------------------------------------------------------------;
863: align 4
864: do_right_edge_bytes:
865:
866: ; Set up variables for entering unrolled loop.
867:
868: mov ecx,ppfnDrawEdgeTable
869: SET_UP_UNROLL_VARS ebx,esi, ebx,[ecx], LOOP_UNROLL_SHIFT
870:
871: mov ecx,ulScanWidth ;offset from one scan to next
872: add edi,ulWholeBytes ;--> start for right edge (remember,
873: ; left edge is whole, so the left edge
874: ; byte is included in the whole byte
875: ; count)
876: mov al,byte ptr ulMasks+1 ;this will become the Bit Mask for the
877: ; right edge
878: mov edx,VGA_BASE + SEQ_DATA ;SEQ_INDEX already points to Map Mask
879: out dx,al ;set Map Mask for right edge
880:
881: mov eax,ulDrawingColor ;each byte is color with which to fill
882:
883: call esi ;jump into the unrolled loop to draw
884:
885: ;-----------------------------------------------------------------------;
886: ; We have done all partial edges.
887: ;-----------------------------------------------------------------------;
888:
889: edges_done:
890:
891: mov edx,VGA_BASE + SEQ_DATA ;SEQ_INDEX already points to Map Mask
892: mov al,MM_ALL ;restore the default Map Mask of all
893: out dx,al ; planes enabled
894:
895: ;-----------------------------------------------------------------------;
896: ; See if there are any more banks to process.
897: ;-----------------------------------------------------------------------;
898:
899: check_next_bank:
900:
901: mov edi,ppdev
902: mov eax,[edi].pdev_rcl1PlanarClip.yBottom ;is the fill bottom in
903: cmp ulBottomScan,eax ; the current bank?
904: jle short banks_done ;yes, so we're done
905: ;no, map in the next bank and fill it
906: mov ulCurrentTopScan,eax ;remember where the top of the bank
907: ; we're about to map in is (same as
908: ; bottom of bank we just did)
909:
910: ptrCall <dword ptr [edi].pdev_pfnPlanarControl>,<edi,eax,JustifyTop>
911: ;map in the bank
912:
913: ; Compute the starting address and scan line count in this bank.
914:
915: mov eax,ppdev ;EAX->target surface
916: mov ebx,ulBottomScan ;bottom of destination rectangle
917: cmp ebx,[eax].pdev_rcl1PlanarClip.yBottom
918: ;which comes first, the bottom of the
919: ; dest rect or the bottom of the
920: ; current bank?
921: jl short BottomScanSet2 ;fill bottom comes first, so draw to
922: ; that; this is the last bank in fill
923: mov ebx,[eax].pdev_rcl1PlanarClip.yBottom
924: ;bank bottom comes first; draw to
925: ; bottom of bank
926: BottomScanSet2:
927: mov edi,ulCurrentTopScan ;top scan line to fill in current bank
928: sub ebx,edi ;# of scans to fill in bank
929: imul edi,ulScanWidth ;offset of starting scan line
930:
931: ; Note that the start of the bitmap will change each time through the
932: ; bank loop, because the start of the bitmap is varied to map the
933: ; desired scan line to the banking window.
934:
935: add edi,[eax].pdev_pvBitmapStart ;start of scan in bitmap
936: add edi,ulRowOffset ;EDI = start offset of fill in bitmap
937:
938: ; Draw in the new bank.
939:
940: jmp pfnStartDrawing
941:
942:
943: ;-----------------------------------------------------------------------;
944: ; Done with all banks in this fill.
945:
946: banks_done:
947: retn
948:
949: endProc vTrgBlt
950:
951:
952: ;-----------------------------------------------------------------------;
953: ; Unrolled loops.
954: ; There are two kinds of unrolled loops: read-before-write (to load the
955: ; latches), and write-only (for replace-type rops).
956: ;-----------------------------------------------------------------------;
957:
958:
959: ;-----------------------------------------------------------------------;
960: ; Unrolled drawing stuff for cases where read before write is required,
961: ; to load the latches.
962: ;-----------------------------------------------------------------------;
963:
964: ; Tables of entry points into unrolled 1-, 2-, 3-, and 4-wide, and 5-or-wider
965: ; read before write loops.
966:
967: UNROLL_LOOP_ENTRY_TABLE pfnDraw1WideRWEntry,RW1,LOOP_UNROLL_COUNT
968: UNROLL_LOOP_ENTRY_TABLE pfnDraw2WideRWEntry,RW2,LOOP_UNROLL_COUNT
969: UNROLL_LOOP_ENTRY_TABLE pfnDraw3WideRWEntry,RW3,LOOP_UNROLL_COUNT
970: UNROLL_LOOP_ENTRY_TABLE pfnDraw4WideRWEntry,RW4,LOOP_UNROLL_COUNT
971:
972: ;-----------------------------------------------------------------------;
973: ; Unrolled 1-, 2-, 3-, and 4-wide read before write drawing loops.
974: ;
975: ; Entry:
976: ; AL = drawing color
977: ; EBX = unrolled loop count
978: ; ECX = scan line width in bytes
979: ; EDI = start offset
980: ;
981: ; EBX, EDI modified. All other registers preserved.
982:
983: ;-----------------------------------------------------------------------;
984: ; Macro to draw one read before write byte, then advance to next scan line.
985:
986: DRAW_1_WIDE_RW macro ENTRY_LABEL,ENTRY_INDEX
987: &ENTRY_LABEL&ENTRY_INDEX&:
988: mov ah,[edi] ;latch the target address. The data read
989: ; doesn't matter
990: mov [edi],al ;merge the drawing color with the latched
991: ; target address according to the selected ALU
992: ; function, and write the result to display
993: ; memory
994: add edi,ecx ;point to the next scan line
995: endm ;-----------------------------------;
996:
997: ; 1-wide read/write.
998:
999: align 4
1000: draw_1_wide_rw_loop proc near
1001: UNROLL_LOOP DRAW_1_WIDE_RW,RW1,LOOP_UNROLL_COUNT
1002: dec ebx
1003: jnz draw_1_wide_rw_loop
1004:
1005: ret
1006:
1007: draw_1_wide_rw_loop endp
1008:
1009: ;-----------------------------------------------------------------------;
1010: ; Macro to draw two read before write bytes, then advance to next scan line.
1011:
1012: DRAW_2_WIDE_RW macro ENTRY_LABEL,ENTRY_INDEX
1013: &ENTRY_LABEL&ENTRY_INDEX&:
1014: mov ah,[edi] ;see 1-wide RW case for comments
1015: mov [edi],al
1016: mov ah,[edi+1]
1017: mov [edi+1],al
1018: add edi,ecx ;point to the next scan line
1019: endm ;-----------------------------------;
1020:
1021: ; 2-wide read/write.
1022:
1023: align 4
1024: draw_2_wide_rw_loop proc near
1025: UNROLL_LOOP DRAW_2_WIDE_RW,RW2,LOOP_UNROLL_COUNT
1026: dec ebx
1027: jnz draw_2_wide_rw_loop
1028:
1029: ret
1030:
1031: draw_2_wide_rw_loop endp
1032:
1033: ;-----------------------------------------------------------------------;
1034: ; Macro to draw three read before write bytes, then advance to next scan line.
1035:
1036: DRAW_3_WIDE_RW macro ENTRY_LABEL,ENTRY_INDEX
1037: &ENTRY_LABEL&ENTRY_INDEX&:
1038: mov ah,[edi] ;see 1-wide RW case for comments
1039: mov [edi],al
1040: mov ah,[edi+1]
1041: mov [edi+1],al
1042: mov ah,[edi+2]
1043: mov [edi+2],al
1044: add edi,ecx ;point to the next scan line
1045: endm ;-----------------------------------;
1046:
1047: ; 3-wide read/write.
1048:
1049: align 4
1050: draw_3_wide_rw_loop proc near
1051: UNROLL_LOOP DRAW_3_WIDE_RW,RW3,LOOP_UNROLL_COUNT
1052: dec ebx
1053: jnz draw_3_wide_rw_loop
1054:
1055: ret
1056:
1057: draw_3_wide_rw_loop endp
1058:
1059: ;-----------------------------------------------------------------------;
1060: ; Macro to draw three read before write bytes, then advance to next scan line.
1061:
1062: DRAW_4_WIDE_RW macro ENTRY_LABEL,ENTRY_INDEX
1063: &ENTRY_LABEL&ENTRY_INDEX&:
1064: mov ah,[edi] ;see 1-wide RW case for comments
1065: mov [edi],al
1066: mov ah,[edi+1]
1067: mov [edi+1],al
1068: mov ah,[edi+2]
1069: mov [edi+2],al
1070: mov ah,[edi+3]
1071: mov [edi+3],al
1072: add edi,ecx ;point to the next scan line
1073: endm ;-----------------------------------;
1074:
1075: ; 4-wide read/write.
1076:
1077: align 4
1078: draw_4_wide_rw_loop proc near
1079: UNROLL_LOOP DRAW_4_WIDE_RW,RW4,LOOP_UNROLL_COUNT
1080: dec ebx
1081: jnz draw_4_wide_rw_loop
1082:
1083: ret
1084:
1085: draw_4_wide_rw_loop endp
1086:
1087: ;-----------------------------------------------------------------------;
1088: ; Unrolled drawing stuff (unrolled to reduce jumps to speed things up),
1089: ; for cases where read before write is NOT required.
1090: ;-----------------------------------------------------------------------;
1091:
1092: ; Tables of entry points into unrolled 1-, 2-, 3-, and 4-wide write-only loops.
1093: ; Note that there may be separate entry tables for various alignments of a
1094: ; specific width, in cases where performance can be improved by using different
1095: ; code for different alignments.
1096:
1097: UNROLL_LOOP_ENTRY_TABLE pfnDraw1WideWEntry,W1,LOOP_UNROLL_COUNT
1098: UNROLL_LOOP_ENTRY_TABLE pfnDraw2WideWEntry,W2,LOOP_UNROLL_COUNT
1099: UNROLL_LOOP_ENTRY_TABLE pfnDraw3WideWEvenEntry,W3_EVEN,LOOP_UNROLL_COUNT
1100: UNROLL_LOOP_ENTRY_TABLE pfnDraw3WideWOddEntry,W3_ODD,LOOP_UNROLL_COUNT
1101: UNROLL_LOOP_ENTRY_TABLE pfnDraw4WideWEntry,W4,LOOP_UNROLL_COUNT
1102: UNROLL_LOOP_ENTRY_TABLE pfnDraw5WideWEvenEntry,W5_EVEN,LOOP_UNROLL_COUNT
1103: UNROLL_LOOP_ENTRY_TABLE pfnDraw5WideWOddEntry,W5_ODD,LOOP_UNROLL_COUNT
1104: UNROLL_LOOP_ENTRY_TABLE pfnDraw6WideWMod3_0Entry,W6_MOD3_0,LOOP_UNROLL_COUNT
1105: UNROLL_LOOP_ENTRY_TABLE pfnDraw6WideWMod3_1Entry,W6_MOD3_1,LOOP_UNROLL_COUNT
1106: UNROLL_LOOP_ENTRY_TABLE pfnDraw6WideWMod3_2Entry,W6_MOD3_2,LOOP_UNROLL_COUNT
1107: UNROLL_LOOP_ENTRY_TABLE pfnDraw7WideWMod3_0Entry,W7_MOD3_0,LOOP_UNROLL_COUNT
1108: UNROLL_LOOP_ENTRY_TABLE pfnDraw7WideWMod3_1Entry,W7_MOD3_1,LOOP_UNROLL_COUNT
1109: UNROLL_LOOP_ENTRY_TABLE pfnDraw7WideWMod3_2Entry,W7_MOD3_2,LOOP_UNROLL_COUNT
1110: UNROLL_LOOP_ENTRY_TABLE pfnDraw7WideWMod3_3Entry,W7_MOD3_3,LOOP_UNROLL_COUNT
1111: UNROLL_LOOP_ENTRY_TABLE pfnDraw8WideWMod3_0Entry,W8_MOD3_0,LOOP_UNROLL_COUNT
1112: UNROLL_LOOP_ENTRY_TABLE pfnDraw8WideWMod3_1Entry,W8_MOD3_1,LOOP_UNROLL_COUNT
1113: UNROLL_LOOP_ENTRY_TABLE pfnDraw8WideWMod3_2Entry,W8_MOD3_2,LOOP_UNROLL_COUNT
1114: UNROLL_LOOP_ENTRY_TABLE pfnDraw8WideWMod3_3Entry,W8_MOD3_3,LOOP_UNROLL_COUNT
1115:
1116:
1117: ;-----------------------------------------------------------------------;
1118: ; Unrolled 1-, 2-, 3-, and 4-wide write-only edge-drawing loops.
1119: ;
1120: ; Entry:
1121: ; EAX = fill color, replicated four times
1122: ; EBX = unrolled loop count
1123: ; ECX = scan line width in bytes
1124: ; EDI = start offset
1125: ;
1126: ; EBX, EDI modified. All other registers preserved.
1127:
1128: ;-----------------------------------------------------------------------;
1129: ; Macro to draw one write-only byte, then advance to next scan line.
1130:
1131: DRAW_1_WIDE_W macro ENTRY_LABEL,ENTRY_INDEX
1132: &ENTRY_LABEL&ENTRY_INDEX&:
1133: mov [edi],al ;draw the pixel
1134: add edi,ecx ;point to the next scan line
1135: endm ;-----------------------------------;
1136:
1137: ; 1-wide write-only.
1138:
1139: align 4
1140: draw_1_wide_w_loop proc near
1141: UNROLL_LOOP DRAW_1_WIDE_W,W1,LOOP_UNROLL_COUNT
1142: dec ebx
1143: jnz draw_1_wide_w_loop
1144:
1145: ret
1146:
1147: draw_1_wide_w_loop endp
1148:
1149: ;-----------------------------------------------------------------------;
1150: ; Macro to draw two write-only bytes, then advance to next scan line.
1151:
1152: DRAW_2_WIDE_W macro ENTRY_LABEL,ENTRY_INDEX
1153: &ENTRY_LABEL&ENTRY_INDEX&:
1154: mov [edi],ax
1155: add edi,ecx ;point to the next scan line
1156: endm ;-----------------------------------;
1157:
1158: ; 2-wide write-only.
1159:
1160: align 4
1161: draw_2_wide_w_loop proc near
1162: UNROLL_LOOP DRAW_2_WIDE_W,W2,LOOP_UNROLL_COUNT
1163: dec ebx
1164: jnz draw_2_wide_w_loop
1165:
1166: ret
1167:
1168: draw_2_wide_w_loop endp
1169:
1170: ;-----------------------------------------------------------------------;
1171: ; Macro to draw three write-only bytes, then advance to next scan line.
1172: ; Optimized for even start address.
1173:
1174: DRAW_3_WIDE_W_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1175: &ENTRY_LABEL&ENTRY_INDEX&:
1176: mov [edi],ax
1177: mov [edi+2],al
1178: add edi,ecx ;point to the next scan line
1179: endm ;-----------------------------------;
1180:
1181: ; 3-wide write-only, starting at an even address.
1182:
1183: align 4
1184: draw_3_wide_w_even_loop proc near
1185: UNROLL_LOOP DRAW_3_WIDE_W_EVEN,W3_EVEN,LOOP_UNROLL_COUNT
1186: dec ebx
1187: jnz draw_3_wide_w_even_loop
1188:
1189: ret
1190:
1191: draw_3_wide_w_even_loop endp
1192:
1193: ;-----------------------------------------------------------------------;
1194: ; Macro to draw three write-only bytes, then advance to next scan line.
1195: ; Optimized for odd start address.
1196:
1197: DRAW_3_WIDE_W_ODD macro ENTRY_LABEL,ENTRY_INDEX
1198: &ENTRY_LABEL&ENTRY_INDEX&:
1199: mov [edi],al
1200: mov [edi+1],ax
1201: add edi,ecx ;point to the next scan line
1202: endm ;-----------------------------------;
1203:
1204: ; 3-wide write-only, starting at an odd address.
1205:
1206: align 4
1207: draw_3_wide_w_odd_loop proc near
1208: UNROLL_LOOP DRAW_3_WIDE_W_ODD,W3_ODD,LOOP_UNROLL_COUNT
1209: dec ebx
1210: jnz draw_3_wide_w_odd_loop
1211:
1212: ret
1213:
1214: draw_3_wide_w_odd_loop endp
1215:
1216:
1217: ;-----------------------------------------------------------------------;
1218: ; Macro to draw four write-only bytes, then advance to next scan line.
1219:
1220: DRAW_4_WIDE_W macro ENTRY_LABEL,ENTRY_INDEX
1221: &ENTRY_LABEL&ENTRY_INDEX&:
1222: mov [edi],eax
1223: add edi,ecx ;point to the next scan line
1224: endm ;-----------------------------------;
1225:
1226: ; 4-wide write-only.
1227:
1228: align 4
1229: draw_4_wide_w_loop proc near
1230: UNROLL_LOOP DRAW_4_WIDE_W,W4,LOOP_UNROLL_COUNT
1231: dec ebx
1232: jnz draw_4_wide_w_loop
1233:
1234: ret
1235:
1236: draw_4_wide_w_loop endp
1237:
1238:
1239: ;-----------------------------------------------------------------------;
1240: ; Macro to draw five write-only bytes, then advance to next scan line.
1241: ; Optimized for even start address.
1242:
1243: DRAW_5_WIDE_W_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1244: &ENTRY_LABEL&ENTRY_INDEX&:
1245: mov [edi],eax
1246: mov [edi+4],al
1247: add edi,ecx ;point to the next scan line
1248: endm ;-----------------------------------;
1249:
1250: ; 5-wide write-only, starting at an even address.
1251:
1252: align 4
1253: draw_5_wide_w_even_loop proc near
1254: UNROLL_LOOP DRAW_5_WIDE_W_EVEN,W5_EVEN,LOOP_UNROLL_COUNT
1255: dec ebx
1256: jnz draw_5_wide_w_even_loop
1257:
1258: ret
1259:
1260: draw_5_wide_w_even_loop endp
1261:
1262:
1263: ;-----------------------------------------------------------------------;
1264: ; Macro to draw five write-only bytes, then advance to next scan line.
1265: ; Optimized for odd start address.
1266:
1267: DRAW_5_WIDE_W_ODD macro ENTRY_LABEL,ENTRY_INDEX
1268: &ENTRY_LABEL&ENTRY_INDEX&:
1269: mov [edi],al
1270: mov [edi+1],eax
1271: add edi,ecx ;point to the next scan line
1272: endm ;-----------------------------------;
1273:
1274: ; 5-wide write-only, starting at an odd address.
1275:
1276: align 4
1277: draw_5_wide_w_odd_loop proc near
1278: UNROLL_LOOP DRAW_5_WIDE_W_ODD,W5_ODD,LOOP_UNROLL_COUNT
1279: dec ebx
1280: jnz draw_5_wide_w_odd_loop
1281:
1282: ret
1283:
1284: draw_5_wide_w_odd_loop endp
1285:
1286:
1287: ;-----------------------------------------------------------------------;
1288: ; Macro to draw six write-only bytes, then advance to next scan line.
1289: ; Optimized for start address MOD 3 == 0.
1290:
1291: DRAW_6_WIDE_W_MOD3_0 macro ENTRY_LABEL,ENTRY_INDEX
1292: &ENTRY_LABEL&ENTRY_INDEX&:
1293: mov [edi],eax
1294: mov [edi+4],ax
1295: add edi,ecx ;point to the next scan line
1296: endm ;-----------------------------------;
1297:
1298: ; 6-wide write-only, starting at MOD 3 == 0.
1299:
1300: align 4
1301: draw_6_wide_w_mod3_0_loop proc near
1302: UNROLL_LOOP DRAW_6_WIDE_W_MOD3_0,W6_MOD3_0,LOOP_UNROLL_COUNT
1303: dec ebx
1304: jnz draw_6_wide_w_mod3_0_loop
1305:
1306: ret
1307:
1308: draw_6_wide_w_mod3_0_loop endp
1309:
1310:
1311: ;-----------------------------------------------------------------------;
1312: ; Macro to draw six write-only bytes, then advance to next scan line.
1313: ; Optimized for start address MOD 3 == 1 or 3.
1314:
1315: DRAW_6_WIDE_W_MOD3_1 macro ENTRY_LABEL,ENTRY_INDEX
1316: &ENTRY_LABEL&ENTRY_INDEX&:
1317: mov [edi],al
1318: mov [edi+1],eax
1319: mov [edi+5],al
1320: add edi,ecx ;point to the next scan line
1321: endm ;-----------------------------------;
1322:
1323: ; 6-wide write-only, starting at MOD 3 == 1 or 3.
1324:
1325: align 4
1326: draw_6_wide_w_mod3_1_loop proc near
1327: UNROLL_LOOP DRAW_6_WIDE_W_MOD3_1,W6_MOD3_1,LOOP_UNROLL_COUNT
1328: dec ebx
1329: jnz draw_6_wide_w_mod3_1_loop
1330:
1331: ret
1332:
1333: draw_6_wide_w_mod3_1_loop endp
1334:
1335:
1336: ;-----------------------------------------------------------------------;
1337: ; Macro to draw six write-only bytes, then advance to next scan line.
1338: ; Optimized for start address MOD 3 == 2.
1339:
1340: DRAW_6_WIDE_W_MOD3_2 macro ENTRY_LABEL,ENTRY_INDEX
1341: &ENTRY_LABEL&ENTRY_INDEX&:
1342: mov [edi],ax
1343: mov [edi+2],eax
1344: add edi,ecx ;point to the next scan line
1345: endm ;-----------------------------------;
1346:
1347: ; 6-wide write-only, starting at MOD 3 == 2.
1348:
1349: align 4
1350: draw_6_wide_w_mod3_2_loop proc near
1351: UNROLL_LOOP DRAW_6_WIDE_W_MOD3_2,W6_MOD3_2,LOOP_UNROLL_COUNT
1352: dec ebx
1353: jnz draw_6_wide_w_mod3_2_loop
1354:
1355: ret
1356:
1357: draw_6_wide_w_mod3_2_loop endp
1358:
1359:
1360: ;-----------------------------------------------------------------------;
1361: ; Macro to draw seven write-only bytes, then advance to next scan line.
1362: ; Optimized for start address MOD 3 == 0.
1363:
1364: DRAW_7_WIDE_W_MOD3_0 macro ENTRY_LABEL,ENTRY_INDEX
1365: &ENTRY_LABEL&ENTRY_INDEX&:
1366: mov [edi],eax
1367: mov [edi+4],ax
1368: mov [edi+6],al
1369: add edi,ecx ;point to the next scan line
1370: endm ;-----------------------------------;
1371:
1372: ; 7-wide write-only, starting at MOD 3 == 0.
1373:
1374: align 4
1375: draw_7_wide_w_mod3_0_loop proc near
1376: UNROLL_LOOP DRAW_7_WIDE_W_MOD3_0,W7_MOD3_0,LOOP_UNROLL_COUNT
1377: dec ebx
1378: jnz draw_7_wide_w_mod3_0_loop
1379:
1380: ret
1381:
1382: draw_7_wide_w_mod3_0_loop endp
1383:
1384:
1385: ;-----------------------------------------------------------------------;
1386: ; Macro to draw seven write-only bytes, then advance to next scan line.
1387: ; Optimized for start address MOD 3 == 1.
1388:
1389: DRAW_7_WIDE_W_MOD3_1 macro ENTRY_LABEL,ENTRY_INDEX
1390: &ENTRY_LABEL&ENTRY_INDEX&:
1391: mov [edi],al
1392: mov [edi+1],ax
1393: mov [edi+3],eax
1394: add edi,ecx ;point to the next scan line
1395: endm ;-----------------------------------;
1396:
1397: ; 7-wide write-only, starting at MOD 3 == 0.
1398:
1399: align 4
1400: draw_7_wide_w_mod3_1_loop proc near
1401: UNROLL_LOOP DRAW_7_WIDE_W_MOD3_1,W7_MOD3_1,LOOP_UNROLL_COUNT
1402: dec ebx
1403: jnz draw_7_wide_w_mod3_1_loop
1404:
1405: ret
1406:
1407: draw_7_wide_w_mod3_1_loop endp
1408:
1409:
1410: ;-----------------------------------------------------------------------;
1411: ; Macro to draw seven write-only bytes, then advance to next scan line.
1412: ; Optimized for start address MOD 3 == 2.
1413:
1414: DRAW_7_WIDE_W_MOD3_2 macro ENTRY_LABEL,ENTRY_INDEX
1415: &ENTRY_LABEL&ENTRY_INDEX&:
1416: mov [edi],ax
1417: mov [edi+2],eax
1418: mov [edi+6],al
1419: add edi,ecx ;point to the next scan line
1420: endm ;-----------------------------------;
1421:
1422: ; 7-wide write-only, starting at MOD 3 == 2.
1423:
1424: align 4
1425: draw_7_wide_w_mod3_2_loop proc near
1426: UNROLL_LOOP DRAW_7_WIDE_W_MOD3_2,W7_MOD3_2,LOOP_UNROLL_COUNT
1427: dec ebx
1428: jnz draw_7_wide_w_mod3_2_loop
1429:
1430: ret
1431:
1432: draw_7_wide_w_mod3_2_loop endp
1433:
1434:
1435: ;-----------------------------------------------------------------------;
1436: ; Macro to draw seven write-only bytes, then advance to next scan line.
1437: ; Optimized for start address MOD 3 == 3.
1438:
1439: DRAW_7_WIDE_W_MOD3_3 macro ENTRY_LABEL,ENTRY_INDEX
1440: &ENTRY_LABEL&ENTRY_INDEX&:
1441: mov [edi],al
1442: mov [edi+1],eax
1443: mov [edi+5],ax
1444: add edi,ecx ;point to the next scan line
1445: endm ;-----------------------------------;
1446:
1447: ; 7-wide write-only, starting at MOD 3 == 3.
1448:
1449: align 4
1450: draw_7_wide_w_mod3_3_loop proc near
1451: UNROLL_LOOP DRAW_7_WIDE_W_MOD3_3,W7_MOD3_3,LOOP_UNROLL_COUNT
1452: dec ebx
1453: jnz draw_7_wide_w_mod3_3_loop
1454:
1455: ret
1456:
1457: draw_7_wide_w_mod3_3_loop endp
1458:
1459:
1460: ;-----------------------------------------------------------------------;
1461: ; Macro to draw eight write-only bytes, then advance to next scan line.
1462: ; Optimized for start address MOD 3 == 0.
1463:
1464: DRAW_8_WIDE_W_MOD3_0 macro ENTRY_LABEL,ENTRY_INDEX
1465: &ENTRY_LABEL&ENTRY_INDEX&:
1466: mov [edi],eax
1467: mov [edi+4],eax
1468: add edi,ecx ;point to the next scan line
1469: endm ;-----------------------------------;
1470:
1471: ; 8-wide write-only, starting at MOD 3 == 0.
1472:
1473: align 4
1474: draw_8_wide_w_mod3_0_loop proc near
1475: UNROLL_LOOP DRAW_8_WIDE_W_MOD3_0,W8_MOD3_0,LOOP_UNROLL_COUNT
1476: dec ebx
1477: jnz draw_8_wide_w_mod3_0_loop
1478:
1479: ret
1480:
1481: draw_8_wide_w_mod3_0_loop endp
1482:
1483:
1484: ;-----------------------------------------------------------------------;
1485: ; Macro to draw eight write-only bytes, then advance to next scan line.
1486: ; Optimized for start address MOD 3 == 1.
1487:
1488: DRAW_8_WIDE_W_MOD3_1 macro ENTRY_LABEL,ENTRY_INDEX
1489: &ENTRY_LABEL&ENTRY_INDEX&:
1490: mov [edi],al
1491: mov [edi+1],ax
1492: mov [edi+3],eax
1493: mov [edi+7],al
1494: add edi,ecx ;point to the next scan line
1495: endm ;-----------------------------------;
1496:
1497: ; 8-wide write-only, starting at MOD 3 == 0.
1498:
1499: align 4
1500: draw_8_wide_w_mod3_1_loop proc near
1501: UNROLL_LOOP DRAW_8_WIDE_W_MOD3_1,W8_MOD3_1,LOOP_UNROLL_COUNT
1502: dec ebx
1503: jnz draw_8_wide_w_mod3_1_loop
1504:
1505: ret
1506:
1507: draw_8_wide_w_mod3_1_loop endp
1508:
1509:
1510: ;-----------------------------------------------------------------------;
1511: ; Macro to draw eight write-only bytes, then advance to next scan line.
1512: ; Optimized for start address MOD 3 == 2.
1513:
1514: DRAW_8_WIDE_W_MOD3_2 macro ENTRY_LABEL,ENTRY_INDEX
1515: &ENTRY_LABEL&ENTRY_INDEX&:
1516: mov [edi],ax
1517: mov [edi+2],eax
1518: mov [edi+6],ax
1519: add edi,ecx ;point to the next scan line
1520: endm ;-----------------------------------;
1521:
1522: ; 8-wide write-only, starting at MOD 3 == 2.
1523:
1524: align 4
1525: draw_8_wide_w_mod3_2_loop proc near
1526: UNROLL_LOOP DRAW_8_WIDE_W_MOD3_2,W8_MOD3_2,LOOP_UNROLL_COUNT
1527: dec ebx
1528: jnz draw_8_wide_w_mod3_2_loop
1529:
1530: ret
1531:
1532: draw_8_wide_w_mod3_2_loop endp
1533:
1534:
1535: ;-----------------------------------------------------------------------;
1536: ; Macro to draw eight write-only bytes, then advance to next scan line.
1537: ; Optimized for start address MOD 3 == 3.
1538:
1539: DRAW_8_WIDE_W_MOD3_3 macro ENTRY_LABEL,ENTRY_INDEX
1540: &ENTRY_LABEL&ENTRY_INDEX&:
1541: mov [edi],al
1542: mov [edi+1],eax
1543: mov [edi+5],ax
1544: mov [edi+7],al
1545: add edi,ecx ;point to the next scan line
1546: endm ;-----------------------------------;
1547:
1548: ; 8-wide write-only, starting at MOD 3 == 3.
1549:
1550: align 4
1551: draw_8_wide_w_mod3_3_loop proc near
1552: UNROLL_LOOP DRAW_8_WIDE_W_MOD3_3,W8_MOD3_3,LOOP_UNROLL_COUNT
1553: dec ebx
1554: jnz draw_8_wide_w_mod3_3_loop
1555:
1556: ret
1557:
1558: draw_8_wide_w_mod3_3_loop endp
1559:
1560: ;-----------------------------------------------------------------------;
1561: ; Unrolled loop stuff for wide replace-type rops (arbitrary width).
1562: ;-----------------------------------------------------------------------;
1563:
1564: ; Tables of entry points into unrolled wide write-only loops.
1565: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW00Entry,W_00,LOOP_UNROLL_COUNT
1566: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW01Entry,W_01,LOOP_UNROLL_COUNT
1567: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW02Entry,W_02,LOOP_UNROLL_COUNT
1568: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW03Entry,W_03,LOOP_UNROLL_COUNT
1569: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW10Entry,W_10,LOOP_UNROLL_COUNT
1570: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW11Entry,W_11,LOOP_UNROLL_COUNT
1571: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW12Entry,W_12,LOOP_UNROLL_COUNT
1572: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW13Entry,W_13,LOOP_UNROLL_COUNT
1573: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW20Entry,W_20,LOOP_UNROLL_COUNT
1574: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW21Entry,W_21,LOOP_UNROLL_COUNT
1575: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW22Entry,W_22,LOOP_UNROLL_COUNT
1576: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW23Entry,W_23,LOOP_UNROLL_COUNT
1577: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW30Entry,W_30,LOOP_UNROLL_COUNT
1578: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW31Entry,W_31,LOOP_UNROLL_COUNT
1579: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW32Entry,W_32,LOOP_UNROLL_COUNT
1580: UNROLL_LOOP_ENTRY_TABLE pfnDrawWideW33Entry,W_33,LOOP_UNROLL_COUNT
1581:
1582: ;-----------------------------------------------------------------------;
1583: ; Macro to draw n write-only bytes, 0 leading bytes, 0 trailing bytes,
1584: ; then advance to next scan line.
1585:
1586: DRAW_WIDE_W_00 macro ENTRY_LABEL,ENTRY_INDEX
1587: &ENTRY_LABEL&ENTRY_INDEX&:
1588: mov ecx,esi ;# of whole dwords
1589: rep stosd ;fill all whole bytes as dwords
1590: add edi,edx ;point to the next scan line
1591: endm ;-----------------------------------;
1592:
1593: ; N-wide write-only, 0 leading bytes, 0 trailing bytes.
1594: ; EAX = 0ffffh
1595: ; EBX = count of scans to fill
1596: ; EDX = offset from end of one scan's fill to start of next
1597: ; ESI = # of dwords to fill
1598: ; EDI = target address to fill
1599:
1600: align 4
1601: draw_wide_w_00_loop proc near
1602: UNROLL_LOOP DRAW_WIDE_W_00,W_00,LOOP_UNROLL_COUNT
1603: dec ebx
1604: jnz draw_wide_w_00_loop
1605:
1606: ret
1607:
1608: draw_wide_w_00_loop endp
1609:
1610:
1611: ;-----------------------------------------------------------------------;
1612: ; Macro to draw n write-only bytes, 0 leading bytes, 1 trailing byte,
1613: ; then advance to next scan line.
1614:
1615: DRAW_WIDE_W_01 macro ENTRY_LABEL,ENTRY_INDEX
1616: &ENTRY_LABEL&ENTRY_INDEX&:
1617: mov ecx,esi ;# of whole dwords
1618: rep stosd ;fill whole bytes as dwords
1619: mov [edi],al ;fill the trailing byte
1620: inc edi
1621: add edi,edx ;point to the next scan line
1622: endm ;-----------------------------------;
1623:
1624: ; N-wide write-only, 0 leading bytes, 1 trailing byte.
1625: ; EAX = # of dwords to fill
1626: ; EBX = count of scans to fill
1627: ; EDX = offset from end of one scan's fill to start of next
1628: ; ESI = # of dwords to fill
1629: ; EDI = target address to fill
1630:
1631: align 4
1632: draw_wide_w_01_loop proc near
1633: UNROLL_LOOP DRAW_WIDE_W_01,W_01,LOOP_UNROLL_COUNT
1634: dec ebx
1635: jnz draw_wide_w_01_loop
1636:
1637: ret
1638:
1639: draw_wide_w_01_loop endp
1640:
1641:
1642: ;-----------------------------------------------------------------------;
1643: ; Macro to draw n write-only bytes, 0 leading bytes, 2 trailing bytes,
1644: ; then advance to next scan line.
1645:
1646: DRAW_WIDE_W_02 macro ENTRY_LABEL,ENTRY_INDEX
1647: &ENTRY_LABEL&ENTRY_INDEX&:
1648: mov ecx,esi ;# of whole dwords
1649: rep stosd ;fill whole bytes as dwords
1650: mov [edi],ax ;fill the trailing word
1651: add edi,2
1652: add edi,edx ;point to the next scan line
1653: endm ;-----------------------------------;
1654:
1655: ; N-wide write-only, 0 leading bytes, 2 trailing byte.
1656: ; EAX = # of dwords to fill
1657: ; EBX = count of scans to fill
1658: ; EDX = offset from end of one scan's fill to start of next
1659: ; ESI = # of dwords to fill
1660: ; EDI = target address to fill
1661:
1662: align 4
1663: draw_wide_w_02_loop proc near
1664: UNROLL_LOOP DRAW_WIDE_W_02,W_02,LOOP_UNROLL_COUNT
1665: dec ebx
1666: jnz draw_wide_w_02_loop
1667:
1668: ret
1669:
1670: draw_wide_w_02_loop endp
1671:
1672:
1673: ;-----------------------------------------------------------------------;
1674: ; Macro to draw n write-only bytes, 0 leading bytes, 3 trailing bytes,
1675: ; then advance to next scan line.
1676:
1677: DRAW_WIDE_W_03 macro ENTRY_LABEL,ENTRY_INDEX
1678: &ENTRY_LABEL&ENTRY_INDEX&:
1679: mov ecx,esi ;# of whole dwords
1680: rep stosd ;fill whole bytes as dwords
1681: mov [edi],ax ;fill the leading word
1682: mov [edi+2],al ;fill the trailing byte
1683: add edi,3
1684: add edi,edx ;point to the next scan line
1685: endm ;-----------------------------------;
1686:
1687: ; N-wide write-only, 0 leading bytes, 3 trailing bytes.
1688: ; EAX = # of dwords to fill
1689: ; EBX = count of scans to fill
1690: ; EDX = offset from end of one scan's fill to start of next
1691: ; ESI = # of dwords to fill
1692: ; EDI = target address to fill
1693:
1694: align 4
1695: draw_wide_w_03_loop proc near
1696: UNROLL_LOOP DRAW_WIDE_W_03,W_03,LOOP_UNROLL_COUNT
1697: dec ebx
1698: jnz draw_wide_w_03_loop
1699:
1700: ret
1701:
1702: draw_wide_w_03_loop endp
1703:
1704:
1705: ;-----------------------------------------------------------------------;
1706: ; Macro to draw n write-only bytes, 1 leading byte, 0 trailing bytes,
1707: ; then advance to next scan line.
1708:
1709: DRAW_WIDE_W_10 macro ENTRY_LABEL,ENTRY_INDEX
1710: &ENTRY_LABEL&ENTRY_INDEX&:
1711: mov [edi],al ;fill the leading byte
1712: inc edi
1713: mov ecx,esi ;# of whole dwords
1714: rep stosd ;fill all whole bytes as dwords
1715: add edi,edx ;point to the next scan line
1716: endm ;-----------------------------------;
1717:
1718: ; N-wide write-only, 1 leading byte, 0 trailing bytes.
1719: ; EAX = # of dwords to fill
1720: ; EBX = count of scans to fill
1721: ; EDX = offset from end of one scan's fill to start of next
1722: ; ESI = # of dwords to fill
1723: ; EDI = target address to fill
1724:
1725: align 4
1726: draw_wide_w_10_loop proc near
1727: UNROLL_LOOP DRAW_WIDE_W_10,W_10,LOOP_UNROLL_COUNT
1728: dec ebx
1729: jnz draw_wide_w_10_loop
1730:
1731: ret
1732:
1733: draw_wide_w_10_loop endp
1734:
1735:
1736: ;-----------------------------------------------------------------------;
1737: ; Macro to draw n write-only bytes, 1 leading byte, 1 trailing byte,
1738: ; then advance to next scan line.
1739:
1740: DRAW_WIDE_W_11 macro ENTRY_LABEL,ENTRY_INDEX
1741: &ENTRY_LABEL&ENTRY_INDEX&:
1742: mov [edi],al ;fill the leading byte
1743: inc edi
1744: mov ecx,esi ;# of whole dwords
1745: rep stosd ;fill whole bytes as dwords
1746: mov [edi],al ;fill the trailing byte
1747: inc edi
1748: add edi,edx ;point to the next scan line
1749: endm ;-----------------------------------;
1750:
1751: ; N-wide write-only, 1 leading bytes, 1 trailing byte.
1752: ; EAX = # of dwords to fill
1753: ; EBX = count of scans to fill
1754: ; EDX = offset from end of one scan's fill to start of next
1755: ; ESI = # of dwords to fill
1756: ; EDI = target address to fill
1757:
1758: align 4
1759: draw_wide_w_11_loop proc near
1760: UNROLL_LOOP DRAW_WIDE_W_11,W_11,LOOP_UNROLL_COUNT
1761: dec ebx
1762: jnz draw_wide_w_11_loop
1763:
1764: ret
1765:
1766: draw_wide_w_11_loop endp
1767:
1768:
1769: ;-----------------------------------------------------------------------;
1770: ; Macro to draw n write-only bytes, 1 leading byte, 2 trailing bytes,
1771: ; then advance to next scan line.
1772:
1773: DRAW_WIDE_W_12 macro ENTRY_LABEL,ENTRY_INDEX
1774: &ENTRY_LABEL&ENTRY_INDEX&:
1775: mov [edi],al ;fill the leading byte
1776: inc edi
1777: mov ecx,esi ;# of whole dwords
1778: rep stosd ;fill whole bytes as dwords
1779: mov [edi],ax ;fill the trailing word
1780: add edi,2
1781: add edi,edx ;point to the next scan line
1782: endm ;-----------------------------------;
1783:
1784: ; N-wide write-only, 1 leading bytes, 2 trailing byte.
1785: ; EAX = # of dwords to fill
1786: ; EBX = count of scans to fill
1787: ; EDX = offset from end of one scan's fill to start of next
1788: ; ESI = # of dwords to fill
1789: ; EDI = target address to fill
1790:
1791: align 4
1792: draw_wide_w_12_loop proc near
1793: UNROLL_LOOP DRAW_WIDE_W_12,W_12,LOOP_UNROLL_COUNT
1794: dec ebx
1795: jnz draw_wide_w_12_loop
1796:
1797: ret
1798:
1799: draw_wide_w_12_loop endp
1800:
1801:
1802: ;-----------------------------------------------------------------------;
1803: ; Macro to draw n write-only bytes, 1 leading byte, 3 trailing bytes,
1804: ; then advance to next scan line.
1805:
1806: DRAW_WIDE_W_13 macro ENTRY_LABEL,ENTRY_INDEX
1807: &ENTRY_LABEL&ENTRY_INDEX&:
1808: mov [edi],al ;fill the leading byte
1809: inc edi
1810: mov ecx,esi ;# of whole dwords
1811: rep stosd ;fill whole bytes as dwords
1812: mov [edi],ax ;fill the trailing word
1813: mov [edi+2],al ;fill the trailing byte
1814: add edi,3
1815: add edi,edx ;point to the next scan line
1816: endm ;-----------------------------------;
1817:
1818: ; N-wide write-only, 0 leading bytes, 3 trailing bytes.
1819: ; EAX = # of dwords to fill
1820: ; EBX = count of scans to fill
1821: ; EDX = offset from end of one scan's fill to start of next
1822: ; ESI = # of dwords to fill
1823: ; EDI = target address to fill
1824:
1825: align 4
1826: draw_wide_w_13_loop proc near
1827: UNROLL_LOOP DRAW_WIDE_W_13,W_13,LOOP_UNROLL_COUNT
1828: dec ebx
1829: jnz draw_wide_w_13_loop
1830:
1831: ret
1832:
1833: draw_wide_w_13_loop endp
1834:
1835:
1836: ;-----------------------------------------------------------------------;
1837: ; Macro to draw n write-only bytes, 2 leading bytes, 0 trailing bytes,
1838: ; then advance to next scan line.
1839:
1840: DRAW_WIDE_W_20 macro ENTRY_LABEL,ENTRY_INDEX
1841: &ENTRY_LABEL&ENTRY_INDEX&:
1842: mov [edi],ax ;fill the leading word
1843: add edi,2
1844: mov ecx,esi ;# of whole dwords
1845: rep stosd ;fill all whole bytes as dwords
1846: add edi,edx ;point to the next scan line
1847: endm ;-----------------------------------;
1848:
1849: ; N-wide write-only, 2 leading bytes, 0 trailing bytes.
1850: ; EAX = # of dwords to fill
1851: ; EBX = count of scans to fill
1852: ; EDX = offset from end of one scan's fill to start of next
1853: ; ESI = # of dwords to fill
1854: ; EDI = target address to fill
1855:
1856: align 4
1857: draw_wide_w_20_loop proc near
1858: UNROLL_LOOP DRAW_WIDE_W_20,W_20,LOOP_UNROLL_COUNT
1859: dec ebx
1860: jnz draw_wide_w_20_loop
1861:
1862: ret
1863:
1864: draw_wide_w_20_loop endp
1865:
1866:
1867: ;-----------------------------------------------------------------------;
1868: ; Macro to draw n write-only bytes, 2 leading bytes, 1 trailing byte,
1869: ; then advance to next scan line.
1870:
1871: DRAW_WIDE_W_21 macro ENTRY_LABEL,ENTRY_INDEX
1872: &ENTRY_LABEL&ENTRY_INDEX&:
1873: mov [edi],ax ;fill the leading word
1874: add edi,2
1875: mov ecx,esi ;# of whole dwords
1876: rep stosd ;fill whole bytes as dwords
1877: mov [edi],al ;fill the trailing byte
1878: inc edi
1879: add edi,edx ;point to the next scan line
1880: endm ;-----------------------------------;
1881:
1882: ; N-wide write-only, 2 leading bytess, 1 trailing byte.
1883: ; EAX = # of dwords to fill
1884: ; EBX = count of scans to fill
1885: ; EDX = offset from end of one scan's fill to start of next
1886: ; ESI = # of dwords to fill
1887: ; EDI = target address to fill
1888:
1889: align 4
1890: draw_wide_w_21_loop proc near
1891: UNROLL_LOOP DRAW_WIDE_W_21,W_21,LOOP_UNROLL_COUNT
1892: dec ebx
1893: jnz draw_wide_w_21_loop
1894:
1895: ret
1896:
1897: draw_wide_w_21_loop endp
1898:
1899:
1900: ;-----------------------------------------------------------------------;
1901: ; Macro to draw n write-only bytes, 2 leading bytes, 2 trailing bytes,
1902: ; then advance to next scan line.
1903:
1904: DRAW_WIDE_W_22 macro ENTRY_LABEL,ENTRY_INDEX
1905: &ENTRY_LABEL&ENTRY_INDEX&:
1906: mov [edi],ax ;fill the leading word
1907: add edi,2
1908: mov ecx,esi ;# of whole dwords
1909: rep stosd ;fill whole bytes as dwords
1910: mov [edi],ax ;fill the trailing word
1911: add edi,2
1912: add edi,edx ;point to the next scan line
1913: endm ;-----------------------------------;
1914:
1915: ; N-wide write-only, 2 leading bytess, 2 trailing byte.
1916: ; EAX = # of dwords to fill
1917: ; EBX = count of scans to fill
1918: ; EDX = offset from end of one scan's fill to start of next
1919: ; ESI = # of dwords to fill
1920: ; EDI = target address to fill
1921:
1922: align 4
1923: draw_wide_w_22_loop proc near
1924: UNROLL_LOOP DRAW_WIDE_W_22,W_22,LOOP_UNROLL_COUNT
1925: dec ebx
1926: jnz draw_wide_w_22_loop
1927:
1928: ret
1929:
1930: draw_wide_w_22_loop endp
1931:
1932:
1933: ;-----------------------------------------------------------------------;
1934: ; Macro to draw n write-only bytes, 2 leading bytes, 3 trailing bytes,
1935: ; then advance to next scan line.
1936:
1937: DRAW_WIDE_W_23 macro ENTRY_LABEL,ENTRY_INDEX
1938: &ENTRY_LABEL&ENTRY_INDEX&:
1939: mov [edi],ax ;fill the leading word
1940: add edi,2
1941: mov ecx,esi ;# of whole dwords
1942: rep stosd ;fill whole bytes as dwords
1943: mov [edi],ax ;fill the trailing word
1944: mov [edi+2],al ;fill the trailing byte
1945: add edi,3
1946: add edi,edx ;point to the next scan line
1947: endm ;-----------------------------------;
1948:
1949: ; N-wide write-only, 0 leading bytes, 3 trailing bytes.
1950: ; EAX = # of dwords to fill
1951: ; EBX = count of scans to fill
1952: ; EDX = offset from end of one scan's fill to start of next
1953: ; ESI = # of dwords to fill
1954: ; EDI = target address to fill
1955:
1956: align 4
1957: draw_wide_w_23_loop proc near
1958: UNROLL_LOOP DRAW_WIDE_W_23,W_23,LOOP_UNROLL_COUNT
1959: dec ebx
1960: jnz draw_wide_w_23_loop
1961:
1962: ret
1963:
1964: draw_wide_w_23_loop endp
1965:
1966:
1967: ;-----------------------------------------------------------------------;
1968: ; Macro to draw n write-only bytes, 3 leading bytes, 0 trailing bytes,
1969: ; then advance to next scan line.
1970:
1971: DRAW_WIDE_W_30 macro ENTRY_LABEL,ENTRY_INDEX
1972: &ENTRY_LABEL&ENTRY_INDEX&:
1973: mov [edi],al ;fill the leading byte
1974: mov [edi+1],ax ;fill the leading word
1975: add edi,3
1976: mov ecx,esi ;# of whole dwords
1977: rep stosd ;fill all whole bytes as dwords
1978: add edi,edx ;point to the next scan line
1979: endm ;-----------------------------------;
1980:
1981: ; N-wide write-only, 3 leading bytes, 0 trailing bytes.
1982: ; EAX = # of dwords to fill
1983: ; EBX = count of scans to fill
1984: ; EDX = offset from end of one scan's fill to start of next
1985: ; ESI = # of dwords to fill
1986: ; EDI = target address to fill
1987:
1988: align 4
1989: draw_wide_w_30_loop proc near
1990: UNROLL_LOOP DRAW_WIDE_W_30,W_30,LOOP_UNROLL_COUNT
1991: dec ebx
1992: jnz draw_wide_w_30_loop
1993:
1994: ret
1995:
1996: draw_wide_w_30_loop endp
1997:
1998:
1999: ;-----------------------------------------------------------------------;
2000: ; Macro to draw n write-only bytes, 3 leading bytes, 1 trailing byte,
2001: ; then advance to next scan line.
2002:
2003: DRAW_WIDE_W_31 macro ENTRY_LABEL,ENTRY_INDEX
2004: &ENTRY_LABEL&ENTRY_INDEX&:
2005: mov [edi],al ;fill the leading byte
2006: mov [edi+1],ax ;fill the leading word
2007: add edi,3
2008: mov ecx,esi ;# of whole dwords
2009: rep stosd ;fill whole bytes as dwords
2010: mov [edi],al ;fill the trailing byte
2011: inc edi
2012: add edi,edx ;point to the next scan line
2013: endm ;-----------------------------------;
2014:
2015: ; N-wide write-only, 3 leading bytess, 1 trailing byte.
2016: ; EAX = # of dwords to fill
2017: ; EBX = count of scans to fill
2018: ; EDX = offset from end of one scan's fill to start of next
2019: ; ESI = # of dwords to fill
2020: ; EDI = target address to fill
2021:
2022: align 4
2023: draw_wide_w_31_loop proc near
2024: UNROLL_LOOP DRAW_WIDE_W_31,W_31,LOOP_UNROLL_COUNT
2025: dec ebx
2026: jnz draw_wide_w_31_loop
2027:
2028: ret
2029:
2030: draw_wide_w_31_loop endp
2031:
2032:
2033: ;-----------------------------------------------------------------------;
2034: ; Macro to draw n write-only bytes, 3 leading bytes, 2 trailing bytes,
2035: ; then advance to next scan line.
2036:
2037: DRAW_WIDE_W_32 macro ENTRY_LABEL,ENTRY_INDEX
2038: &ENTRY_LABEL&ENTRY_INDEX&:
2039: mov [edi],al ;fill the leading byte
2040: mov [edi+1],ax ;fill the leading word
2041: add edi,3
2042: mov ecx,esi ;# of whole dwords
2043: rep stosd ;fill whole bytes as dwords
2044: mov [edi],ax ;fill the trailing word
2045: add edi,2
2046: add edi,edx ;point to the next scan line
2047: endm ;-----------------------------------;
2048:
2049: ; N-wide write-only, 3 leading bytess, 2 trailing byte.
2050: ; EAX = # of dwords to fill
2051: ; EBX = count of scans to fill
2052: ; EDX = offset from end of one scan's fill to start of next
2053: ; ESI = # of dwords to fill
2054: ; EDI = target address to fill
2055:
2056: align 4
2057: draw_wide_w_32_loop proc near
2058: UNROLL_LOOP DRAW_WIDE_W_32,W_32,LOOP_UNROLL_COUNT
2059: dec ebx
2060: jnz draw_wide_w_32_loop
2061:
2062: ret
2063:
2064: draw_wide_w_32_loop endp
2065:
2066:
2067: ;-----------------------------------------------------------------------;
2068: ; Macro to draw n write-only bytes, 3 leading bytes, 3 trailing bytes,
2069: ; then advance to next scan line.
2070:
2071: DRAW_WIDE_W_33 macro ENTRY_LABEL,ENTRY_INDEX
2072: &ENTRY_LABEL&ENTRY_INDEX&:
2073: mov [edi],al ;fill the leading byte
2074: mov [edi+1],ax ;fill the leading word
2075: add edi,3
2076: mov ecx,esi ;# of whole dwords
2077: rep stosd ;fill whole bytes as dwords
2078: mov [edi],ax ;fill the trailing word
2079: mov [edi+2],al ;fill the trailing byte
2080: add edi,3
2081: add edi,edx ;point to the next scan line
2082: endm ;-----------------------------------;
2083:
2084: ; N-wide write-only, 0 leading bytes, 3 trailing bytes.
2085: ; EAX = # of dwords to fill
2086: ; EBX = count of scans to fill
2087: ; EDX = offset from end of one scan's fill to start of next
2088: ; ESI = # of dwords to fill
2089: ; EDI = target address to fill
2090:
2091: align 4
2092: draw_wide_w_33_loop proc near
2093: UNROLL_LOOP DRAW_WIDE_W_33,W_33,LOOP_UNROLL_COUNT
2094: dec ebx
2095: jnz draw_wide_w_33_loop
2096:
2097: ret
2098:
2099: draw_wide_w_33_loop endp
2100:
2101: end
2102:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.