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