![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to patblt.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 patblt.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 root 1: ;-----------------------------------------------------------------------;
2:
3: ; Set LOOP_UNROLL_SHIFT to the log2 of the number of times you want loops in
4: ; this module unrolled. For example, LOOP_UNROLL_SHIFT of 3 yields 2**3 = 8
5: ; times unrolling. This is the only thing you need to change to control
6: ; unrolling.
7:
8: LOOP_UNROLL_SHIFT equ 2
9:
10: ;-----------------------------------------------------------------------;
11:
12: ; This delay is necessitated by a bug in the ATI Ultra when running in
13: ; VGA mode.
14:
15: SLOW_OUT macro
16: push ecx
17: pop ecx
18: out dx,ax
19: endm
20:
21: .386
22:
23: ifndef DOS_PLATFORM
24: .model small,c
25: else
26: ifdef STD_CALL
27: .model small,c
28: else
29: .model small,pascal
30: endif; STD_CALL
31: endif; DOS_PLATFORM
32:
33: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
34: assume fs:nothing,gs:nothing
35:
36: .xlist
37: include stdcall.inc ;calling convention cmacros
38: include i386\egavga.inc
39: include i386\strucs.inc
40: include i386\unroll.inc
41: include i386\ropdefs.inc
42: include i386\display.inc ; Display specific structures
43:
44: .list
45:
46: ;-----------------------------------------------------------------------;
47:
48: .data
49:
50: ;
51: ; We share some tables with vgablts.asm
52: ;
53:
54: extrn jALUFuncTable :byte
55: extrn jLeftMask :byte
56: extrn jRightMask :byte
57: extrn jForceOnTable :byte
58: extrn jNotTable :byte
59: extrn jInvertDest :byte
60: extrn jForceOffTable :byte
61: extrn vTrgBlt@20 :dword
62:
63: ;-----------------------------------------------------------------------;
64: ; Table of routines to be called to draw edges, according to which edges are
65: ; partial and which edges are whole bytes.
66: align 4
67: public pfnEdgeDrawing
68: pfnEdgeDrawing label dword
69: dd edge_byte_setup
70: dd edge_byte_setup
71: dd check_next_bank
72: dd edge_byte_setup
73:
74: ;-----------------------------------------------------------------------;
75: ; Table of pointers to tables used to find entries points in unrolled wide
76: ; whole byte code.
77:
78: align 4
79: public pfnWideWholeRep
80: pfnWideWholeRep label dword
81: dd pfnDrawWide00Entry
82: dd pfnDrawWide01Entry
83: dd pfnDrawWide10Entry
84: dd pfnDrawWide11Entry
85:
86: ;-----------------------------------------------------------------------;
87: ; Table of pointers to tables used to find entry points in narrow, special-
88: ; cased unrolled replace whole byte code.
89:
90: ; Note: The breakpoint where one should switch from special-casing to
91: ; REP STOS is purely a guess on my part. 8 seemed reasonable.
92:
93: ; Start address MOD 2 is 0.
94: align 4
95: public pfnWholeBytesMod0Entries
96: pfnWholeBytesMod0Entries label dword
97: dd 0 ;we never get a 0-wide case
98: dd pfnDraw1WideEvenEntry
99: dd pfnDraw2WideEvenEntry
100: dd pfnDraw3WideEvenEntry
101: dd pfnDraw4WideEvenEntry
102: dd pfnDraw5WideEvenEntry
103: dd pfnDraw6WideEvenEntry
104: dd pfnDraw7WideEvenEntry
105: dd pfnDraw8WideEvenEntry
106: MAX_REPLACE_SPECIAL equ ($-pfnWholeBytesMod0Entries)/4
107:
108: ; Start address MOD 2 is 1.
109: align 4
110: public pfnWholeBytesMod1Entries
111: pfnWholeBytesMod1Entries label dword
112: dd 0 ;we never get a 0-wide case
113: dd pfnDraw1WideOddEntry
114: dd pfnDraw2WideOddEntry
115: dd pfnDraw3WideOddEntry
116: dd pfnDraw4WideOddEntry
117: dd pfnDraw5WideOddEntry
118: dd pfnDraw6WideOddEntry
119: dd pfnDraw7WideOddEntry
120: dd pfnDraw8WideOddEntry
121:
122:
123: ;-----------------------------------------------------------------------;
124: ; Table of pointers to tables used to find entries points in narrow, special-
125: ; cased unrolled non-replace whole byte code.
126:
127: ; Note: The breakpoint where one should switch from special-casing to
128: ; REP MOVSB is purely a guess on my part. 5 seemed reasonable.
129:
130: align 4
131: pfnWholeBytesNonReplace label dword
132: dd 0 ;we never get a 0-wide case
133: dd pfnDraw1RWEntry
134: dd pfnDraw2RWEntry
135: dd pfnDraw3RWEntry
136: dd pfnDraw4RWEntry
137: MAX_NON_REPLACE_SPECIAL equ ($-pfnWholeBytesNonReplace)/4
138:
139: ; Master MOD 2 alignment look-up table for entry tables for two possible
140: ; alignments for narrow, special-cased unrolled replace whole byte code.
141: align 4
142: public pfnWholeBytesSpecial
143: pfnWholeBytesSpecial label dword
144: dd pfnWholeBytesMod0Entries
145: dd pfnWholeBytesMod1Entries
146:
147: .code
148:
149: ;=============================================================================
150:
151: _TEXT$01 SEGMENT DWORD USE32 PUBLIC 'CODE'
152: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
153:
154: cProc vMonoPatBlt,24,< \
155: uses esi edi ebx, \
156: pdsurf: ptr DEVSURF, \
157: culRcl: dword, \
158: prcl: ptr RECTL, \
159: ulMix: dword, \
160: pBrush: ptr oem_brush_def, \
161: pBrushOrg: ptr POINTL >
162:
163: local ulRowOffset :dword ;Offset from start of scan line
164: ; first byte to fill
165: local ulWholeBytes :dword ;# of whole bytes to fill
166: local ulWholeWords :dword ;# of whole words to fill excluding
167: ;leading and/or trailing bytes
168: local pfnWholeFn :dword ;pointer to routine used to draw
169: ; whole bytes
170: local ulScanWidth :dword ;offset from start of one scan to start
171: ; of next
172: local ulNextScan :dword ;offset from end of one scan line's
173: ; fill to start of next
174: local ulCurrentTopScan :dword ;top scan line to fill in current bank
175: local ulMasks :dword ;low byte = right mask, high byte =
176: ; left mask
177: local ulBottomScan :dword ;bottom scan line of fill rectangle
178:
179: local jALUFunc :dword ;VGA ALU logical operation (SET, AND,
180: ; OR, or XOR)
181: local pfnStartDrawing :dword ;pointer to function to call to start
182: ; drawing
183: local pfnContinueDrawing :dword ;pointer to function to call to
184: ; continue drawing after doing whole
185: ; bytes
186: local ulLeftEdgeAdjust :dword ;used to bump the whole bytes start
187: ; address past the left edge when the
188: ; left edge is partial
189: local pfnWholeBytes :dword ;pointer to table of entry points
190: ; into unrolled loops for whole byte
191: ; filling
192: local ulSpecialBytes ;If we are doing a special case wide
193: ; fill, this will be the width of the
194: ; fill. We need this so we can properly
195: ; increment to the next line.
196: local ulVbNextScan :dword ;Offset from the end of the current
197: ; wide fill drawing operation to the
198: ; top of the next venetian blind line
199: local fdInvertDestFirst :dword;1 if the rop requires a pass to invert
200: ; the destination before the normal
201: ; pass
202:
203: local ulPatternOrgY: dword ;Local copy of the pattern offset Y
204:
205: local ulVbBlindCount :dword ;Temp Height of pattern.
206:
207: local ulVbTopScan :dword ;slats in our blinds
208:
209: local ulVbStartScan :dword ;Current to slat
210:
211: local pUlVbPattern:dword ;inner loop pattern pointer
212:
213: local pUlPattern:dword ;current pattern with proper Y offset
214:
215: local ulVbMask ;Inversion mask for partial edges
216:
217: local ulVbYRound ;
218:
219: local ulVbYShift ;
220:
221: local RotatedPat[32]:byte ;Aligned pattern buffer
222:
223: local ulFgClr:dword ;Local copy of the foreground color
224:
225: local ulBkClr:dword ;Local copy of the background color
226:
227: local pfnWesTrick:dword ;Pointer to the desired inner loop
228: ; wes trick code. While we are doing
229: ; a ROP to full bytes, this will point
230: ; to do_wide_wes_trick otherwise it
231: ; will point to do_edge_wes_trick for
232: ; the edge cases
233: cld
234:
235: ;-----------------------------------------------------------------------;
236: ; Make sure there's something to draw; clip enumerations can be empty.
237: ;-----------------------------------------------------------------------;
238:
239: cmp culRcl,0 ;any rects to fill?
240: jz vMonoPatBlts_done ;no, we're done
241:
242: mov esi,pBrush ;point to the brush
243:
244: xor eax,eax
245: mov al,[esi + oem_brush_fg]
246: mov ulFgClr,eax ;Make local copy of the fg color
247:
248: mov al,[esi + oem_brush_bg]
249: mov ulBkClr,eax ;Make local copy of the bk color
250:
251: ;-----------------------------------------------------------------------;
252: ; Set up for the desired raster op.
253: ;-----------------------------------------------------------------------;
254: sub ebx,ebx ;ignore any background mix; we're only
255: mov bl,byte ptr ulMix ; concerned with the foreground in this
256: ; module
257: cmp ebx,R2_NOP ;is this NOP?
258: jz vMonoPatBlts_done ;yes, we're done
259: sub eax,eax ;we want a dword
260: mov al,jInvertDest[ebx] ;remember whether we need to invert the
261: mov fdInvertDestFirst,eax ; destination before finishing the rop
262: mov eax,ulFgClr
263: and al,jForceOffTable[ebx] ;force color to 0 if necessary
264: ; (R2_BLACK)
265: or al,jForceOnTable[ebx] ;force color to 0ffh if necessary
266: ; (R2_WHITE, R2_NOT)
267: xor al,jNotTable[ebx] ;invert color if necessary (any Pn mix)
268: ;at this point, CH has the color we
269: ; want to draw with; set up the VGA
270: ; hardware to draw with that color
271: mov ulFgClr,eax
272:
273: mov eax,ulBkClr
274: and al,jForceOffTable[ebx] ;force color to 0 if necessary
275: ; (R2_BLACK)
276: or al,jForceOnTable[ebx] ;force color to 0ffh if necessary
277: ; (R2_WHITE, R2_NOT)
278: xor al,jNotTable[ebx] ;invert color if necessary (any Pn mix)
279: ;at this point, CH has the color we
280: ; want to draw with; set up the VGA
281: ; hardware to draw with that color
282: mov ulBkClr,eax
283:
284: mov ah,jALUFuncTable[ebx] ;get the ALU logical function
285: and ah,ah ;is the logical function DR_SET?
286: .errnz DR_SET
287: jz short skip_ALU_set ;yes, don't have to set because that's
288: ; the VGA's default state
289: mov edx,VGA_BASE + GRAF_ADDR
290: mov al,GRAF_DATA_ROT
291: SLOW_OUT ;set the ALU logical function
292: skip_ALU_set:
293: mov byte ptr jALUFunc,ah ;remember the ALU logical function
294:
295: ;-----------------------------------------------------------------------;
296: ; Set up variables that are constant for the entire time we're in this
297: ; module.
298: ;-----------------------------------------------------------------------;
299: mov edx,pBrushOrg ;point to the brush origin
300:
301: mov ecx,[edx].ptl_x
302: and ecx,15 ;eax mod 16
303:
304: mov eax,[edx].ptl_y
305: mov ulPatternOrgY,eax
306:
307: ;We are now going to make a copy of our rotated copy of our pattern.
308: ;The reason that we do this is because we may be called with several
309: ;rectangles and we don't really want to rotate the pattern data for
310: ;each rectangle. We copy this rectangle to be double high so that
311: ;we can incorperate our Y offest later without having to worry
312: ;about running off the end of the pattern.
313:
314: lea edi,RotatedPat ;Pattern Dest
315: mov esi,[esi + oem_brush_pmono] ;Pattern Src
316: or cl,cl
317: jnz rotate_and_expand
318:
319: INDEX=0
320: rept 4 ;patterns are 16x8
321: mov eax,[esi+INDEX]
322: mov [edi+INDEX],eax
323: mov [edi+16+INDEX],eax
324: INDEX=INDEX+4
325: endm ;-----------------
326: jmp fill_rect_loop
327:
328: rotate_and_expand:
329: INDEX=0
330: rept 8 ;patterns are 16x8
331: mov ah,[esi+INDEX] ;load bytes for shift
332: mov al,[esi+1+INDEX] ;convert from little to big endian
333: ror ax,cl ;shift into position
334: mov [edi+INDEX],ah ;save result
335: mov [edi+1+INDEX],al
336: mov [edi+16+INDEX],ah ;save result to second copy
337: mov [edi+17+INDEX],al
338: INDEX=INDEX+2
339: endm ;-----------------
340:
341:
342: fill_rect_loop:
343: ;-----------------------------------------------------------------------;
344: ; Set up masks and widths.
345: ;-----------------------------------------------------------------------;
346: mov edi,prcl ;point to rectangle to fill
347:
348: sub eax,eax
349: mov ulLeftEdgeAdjust,eax ;initalize variable
350: mov ulSpecialBytes,eax ;initalize variable
351:
352: mov eax,[edi].yBottom
353: mov ulBottomScan,eax ;remember the bottom scan line of fill
354:
355: mov ebx,[edi].xRight ;right edge of fill (non-inclusive)
356: mov ecx,ebx
357: and ecx,0111b ;intrabyte address of right edge
358: mov ah,jRightMask[ecx] ;right edge mask
359:
360: mov esi,[edi].xLeft ;left edge of fill (inclusive)
361: mov ecx,esi
362: shr ecx,3 ;/8 for start offset from left edge
363: ; of scan line
364: mov ulRowOffset,ecx ;remember offset from start of scan
365: ; line
366: sub ebx,esi ;width in pixels of fill
367:
368: and esi,0111b ;intrabyte address of left edge
369: mov al,jLeftMask[esi] ;left edge mask
370:
371: dec ebx ;make inclusive on right
372: add ebx,esi ;inclusive width, starting counting at
373: ; the beginning of the left edge byte
374: shr ebx,3 ;width of fill in bytes touched - 1
375: jnz short more_than_1_byte ;more than 1 byte is involved
376:
377: ; Only one byte will be affected. Combine first/last masks.
378:
379: and al,ah ;we'll use first byte mask only
380: xor ah,ah ;want last byte mask to be 0
381: inc ebx ;so there's one count to subtract below
382: ; if this isn't a whole edge byte
383: more_than_1_byte:
384:
385: ; If all pixels in the left edge are altered, combine the first byte into the
386: ; whole byte count and clear the first byte mask, because we can handle solid
387: ; edge bytes faster as part of the whole bytes. Ditto for the right edge.
388:
389: sub ecx,ecx ;edge whole-status accumulator
390: cmp al,-1 ;is left edge a whole byte or partial?
391: adc ecx,ecx ;ECX=1 if left edge partial, 0 if whole
392: sub ebx,ecx ;if left edge partial, deduct it from
393: ; the whole bytes count
394: mov ulLeftEdgeAdjust,ecx ;for skipping over the left edge if
395: ; it's partial when pointing to the
396: ; whole bytes
397: and ah,ah ;is right edge mask 0, meaning this
398: ; fill is only 1 byte wide?
399: jz short save_masks ;yes, no need to do anything
400: cmp ah,-1 ;is right edge a whole byte or partial?
401: jnz short save_masks ;partial
402: mov ah,0 ;
403: add ecx,2 ;bit 1 of ECX=0 if right edge partial,
404: ; 1 if whole;
405: ;bit 1=0 if left edge partial, 1 whole
406: inc ebx ;if right edge whole, include it in the
407: ; whole bytes count
408: save_masks:
409: mov ulMasks,eax ;save left and right clip masks
410: mov ulWholeBytes,ebx ;save # of whole bytes
411:
412: mov ecx,pfnEdgeDrawing[ecx*4] ;set address of routine to draw
413: mov pfnContinueDrawing,ecx ; all partial (non-whole) edges
414:
415: and ebx,ebx ;any whole bytes?
416: jz start_vec_set ;no
417: ;yes, so draw the whole bytes before
418: ; the edge bytes
419:
420: ; The whole bytes loop depends on the type of operation being done. If the
421: ; operation is one which uses DR_SET, then we can use a STOS-type operation,
422: ; else we have to use a MOVSB-type operation (to load the latches with the
423: ; existing contents of display memory to allow the ALUs to work).
424: cmp byte ptr jALUFunc,DR_SET ;is it a replace-type rop?
425: jz short is_replace_type ;yes
426: ;no, set up for non-replace whole bytes
427: mov ecx,offset non_replace_wide
428:
429: cmp ebx,MAX_NON_REPLACE_SPECIAL ;too wide to special case?
430: jb short non_replace_spec ;nope
431:
432: lea eax,pfnDrawRWWideEntry ;assume too wide to special-case
433: mov pfnWholeBytes,eax ; table for width
434:
435: jmp short start_vec_set
436:
437: align 4
438: non_replace_spec:
439:
440: mov eax,pfnWholeBytesNonReplace[ebx*4] ;no, point to entry
441: mov pfnWholeBytes,eax ; table for width
442: mov ulSpecialBytes,ebx
443: ;narrow enough to special case. Look up
444: ; the entry table for the special case
445: ; base on the start alignment
446:
447: jmp short start_vec_set
448:
449: align 4
450: is_replace_type: ;set up for replace-type rop
451: cmp ebx,MAX_REPLACE_SPECIAL ;too wide to special case?
452: jnb short is_wide_replace ;yes
453:
454: mov ulSpecialBytes,ebx
455: ;narrow enough to special case. Look up
456: ; the entry table for the special case
457: ; base on the start alignment
458: mov ecx,ulRowOffset
459: add ecx,ulLeftEdgeAdjust ;left edge whole bytes start offset
460: and ecx,01b ;left edge whole bytes start alignment
461: ; MOD 2
462: mov ecx,pfnWholeBytesSpecial[ecx*4] ;look up table of entry
463: ; tables for alignment
464: mov ecx,[ecx+ebx*4] ;look up entry table for width
465: mov pfnWholeBytes,ecx ; table for width
466: mov ecx,offset whole_bytes_rep_wide
467:
468: jmp short start_vec_set
469:
470: align 4
471: is_wide_replace: ;set up for wide replace-type op
472: ;Note: assumes there is at least one
473: ; full word involved!
474: mov ecx,ulRowOffset
475: add ecx,ulLeftEdgeAdjust ;left edge whole bytes start offset
476: neg ecx
477: and ecx,01b
478: mov edx,ebx
479: sub edx,ecx ;ignore odd leading bytes
480: mov eax,edx
481: shr edx,1 ;# of whole words across (not counting
482: ; odd leading & trailing bytes)
483: mov ulWholeWords,edx
484: and eax,01b ;# of odd (fractional) trailing bytes
485: add ecx,ecx
486: or ecx,eax ;build a look-up index from the number
487: ; of leading and trailing bytes
488: mov ecx,pfnWideWholeRep[ecx*4] ;proper drawing handler for front/
489: mov pfnWholeBytes,ecx ; back alignment
490: mov ecx,offset whole_bytes_rep_wide
491: ;set up to call routine to perform wide
492: ; whole bytes fill
493:
494: start_vec_set:
495: mov pfnStartDrawing,ecx ; all partial (non-whole) edges
496:
497: mov ecx,pdsurf
498: mov eax,[ecx].dsurf_lNextScan
499: mov ulScanWidth,eax ;local copy of scan line width
500: sub eax,ebx ;EAX = delta to next scan
501: mov ulNextScan,eax
502:
503: mov esi,pBrush
504: mov eax,[esi+oem_brush_height]
505: dec eax
506: mov ulVbYRound,eax
507: mov al,[esi + oem_brush_yshft] ; blind to the next.
508: mov ulVbYShift,eax
509:
510: mov cl,al
511: mov eax,UlScanWidth
512: shl eax,cl ;ulNextScan * 8
513: mov ulVbNextScan,eax ;
514:
515: cmp fdInvertDestFirst,1 ;is this an invert-dest-plus-something-
516: ; else rop that requires two passes?
517: jnz short do_single_pass
518:
519: lea eax,vTrgBlt@20
520: ptrCall <eax>,<pdsurf, culRcl, prcl, R2_NOT, -1>
521:
522: mov ah,byte ptr jALUFunc ;reset the ALU logical function
523: mov edx,VGA_BASE + GRAF_ADDR
524: mov al,GRAF_DATA_ROT
525: SLOW_OUT ;set the ALU logical function
526:
527: do_single_pass:
528: call draw_banks
529:
530: ;-----------------------------------------------------------------------;
531: ; See if there are any more rectangles to fill.
532: ;-----------------------------------------------------------------------;
533:
534: add prcl,(size RECTL) ;point to the next rectangle, if there is one
535: dec culRcl ;count down the rectangles to fill
536: jnz fill_rect_loop
537:
538:
539: ;-----------------------------------------------------------------------;
540: ; We have filled all rectangles. Restore the VGA to its default state.
541: ;-----------------------------------------------------------------------;
542:
543: mov edx,VGA_BASE + GRAF_ADDR
544: mov eax,0000h + GRAF_ENAB_SR ;disable set/reset
545: out dx,ax
546: mov eax,GRAF_MODE + ((M_PROC_WRITE + M_DATA_READ) SHL 8)
547: out dx,ax ;restore read mode 0 and write mode 0
548: mov eax,(DR_SET shl 8) + GRAF_DATA_ROT ;set the logical function to
549: out dx,ax ; SET
550: vMonoPatBlts_done:
551: cRet vMonoPatBlt
552:
553: ;-----------------------------------------------------------------------;
554: ; Fills all banks in the current fill rectangle. Called once per fill
555: ; rectangle, except for destination-inversion-plus-something-else rops.
556: ;-----------------------------------------------------------------------;
557:
558: align 4
559: draw_banks:
560:
561: ;-----------------------------------------------------------------------;
562: ; Map in the bank containing the top scan to fill, if it's not mapped in
563: ; already.
564: ;-----------------------------------------------------------------------;
565:
566: mov edi,prcl ;point to rectangle to fill
567: mov ecx,pdsurf ;point to surface
568: mov eax,[edi].yTop ;top scan line of fill
569: mov ulCurrentTopScan,eax ;this will be the fill top in 1st bank
570:
571: cmp eax,[ecx].dsurf_rcl1WindowClip.yTop ;is fill top less than
572: ; current bank?
573: jl short map_init_bank ;yes, map in proper bank
574: cmp eax,[ecx].dsurf_rcl1WindowClip.yBottom ;fill top greater than
575: ; current bank?
576: jl short init_bank_mapped ;no, proper bank already mapped
577: map_init_bank:
578:
579: ; Map in the bank containing the top scan line of the fill.
580:
581: ptrCall <dword ptr [ecx].dsurf_pfnBankControl>,<ecx,eax,JustifyTop>
582:
583: init_bank_mapped:
584:
585: ;-----------------------------------------------------------------------;
586: ; Main loop for processing fill in each bank.
587: ;-----------------------------------------------------------------------;
588:
589: ; Compute the starting address and scan line count for the initial bank.
590:
591: mov eax,pdsurf ;EAX->target surface
592: mov ebx,ulBottomScan ;bottom of destination rectangle
593: cmp ebx,[eax].dsurf_rcl1WindowClip.yBottom
594: ;which comes first, the bottom of the
595: ; dest rect or the bottom of the
596: ; current bank?
597: jl short BottomScanSet ;fill bottom comes first, so draw to
598: ; that; this is the last bank in fill
599: mov ebx,[eax].dsurf_rcl1WindowClip.yBottom
600: ;bank bottom comes first; draw to
601: ; bottom of bank
602: BottomScanSet:
603: mov edi,ulCurrentTopScan ;top scan line to fill in current bank
604: sub ebx,edi ;# of scans to fill in bank
605: imul edi,ulScanWidth ;offset of starting scan line
606:
607: ; Note that the start of the bitmap will change each time through the
608: ; bank loop, because the start of the bitmap is varied to map the
609: ; desired scan line to the banking window.
610:
611: add edi,[eax].dsurf_pvBitmapStart ;start of scan in bitmap
612: add edi,ulRowOffset ;EDI = start offset of fill in bitmap
613:
614: ; We have computed the starting address and scan count. Time to start drawing
615: ; in the initial bank.
616:
617: mov esi,pBrush ;edx = min(PatternHeight,BltHeight)
618: mov ecx,[esi + oem_brush_height]
619: sub ecx,ebx
620: sbb edx,edx
621: and edx,ecx
622: add edx,ebx
623: mov ulVbBlindCount,edx
624:
625: ; Brush alignment. We need to look at pptlBrush
626:
627: mov eax,ulCurrentTopScan ;top scan line to fill in current bank
628: sub eax,ulPatternOrgY ;
629:
630: jns short pos_y_offset ;
631: neg eax ;
632: and eax,7 ;-eax mod 8
633: neg eax ;
634: add eax,8 ;
635: jmp short save_pat_pointer
636: pos_y_offset:
637: and eax,7 ;eax mod 8
638: save_pat_pointer:
639: add eax,eax ;Y Offset * PatternWidth (2 bytes)
640:
641: lea edx,RotatedPat ;Pattern Dest
642: add eax,edx
643: mov pulPattern,eax ;Drawing code uses this as the
644: ;source for the pattern
645:
646: jmp pfnStartDrawing
647:
648:
649: ;-----------------------------------------------------------------------;
650: ; Whole byte fills.
651: ;-----------------------------------------------------------------------;
652:
653: ;-----------------------------------------------------------------------;
654: ; Handles non-replace whole byte fills wider than the maximum special
655: ; case width.
656: ;
657: ; The destination is not involved, so a STOS (or equivalent) can be used
658: ; (no read needed before write).
659: ;-----------------------------------------------------------------------;
660:
661: align 4
662: public whole_bytes_rep_wide
663: whole_bytes_rep_wide:
664: push ebx ;save scan count
665: push edi ;save starting address
666:
667: add edi,ulLeftEdgeAdjust ;point to first whole byte to fill
668:
669: mov edx,VGA_BASE + GRAF_ADDR
670: mov eax,GRAF_MODE + ((M_COLOR_WRITE + M_COLOR_READ) SHL 8)
671: out dx,ax ;write mode 2
672: mov eax,ulBkClr ;Set the write mode to write mode
673: mov [edi],al ; three after we load the latches
674: mov al,[edi] ; with our background color
675:
676: mov al,GRAF_SET_RESET ;Set the foreground color
677: out dx,al ; into set/reset
678: inc edx
679: in al,dx
680: and eax,0f0h
681: or eax,ulFgClr
682: out dx,al
683: dec edx
684:
685: mov eax,GRAF_MODE + ((M_AND_WRITE + M_COLOR_READ) SHL 8)
686: out dx,ax ;write mode 3 so we can do the masking
687: ; without OUTs, read mode 1 so we can
688: ; read 0xFF from memory always, for
689: ; ANDing (because Color Don't Care is
690: ; all zeros)
691:
692: mov esi,pulPattern ; pointer to pattern bits
693: mov ax,[esi] ; into place
694: add esi,2
695: mov pulVbPattern,esi
696:
697:
698: mov ulVbTopScan,ebx ;our pattern is 8 high so we don't
699: add ebx,ulVbYRound ;Calc the number of lines to do
700: mov ecx,ulVbyShift
701: shr ebx,cl ;only need to go through the code
702: ; count/8 times. We will handle any
703: ; extra lines at the bottom
704: ; (ulVbTopScan mod 8) in our loops.
705: mov edx,pfnWholeBytes
706: push ulVbBlindCount
707:
708: public wide_bytes_loop
709: wide_bytes_loop:
710: SET_UP_UNROLL_VARS ebx, ecx, ebx, [edx], LOOP_UNROLL_SHIFT
711:
712: mov esi,ulWholeWords ;number of aligned word writes
713: mov edx,ulVbNextScan ;offset from end of one scan line to
714: ; start of next the same scan line
715: ; in the next pattern.
716: sub edx,ulWholeBytes
717: add edx,ulSpecialBytes
718:
719:
720: ; eax = rotated pattern
721: ; ebx = unrolled count
722: ; ecx = routine address
723: ; edx = ulVbNextScan
724: ; esi = ulFvWholeWords
725: ; edi = pDest
726: ;
727: push edi ;save out dest pointer
728: call ecx ;draw the wide whole bytes
729: pop edi ;restore out dest pointer
730:
731: add edi,ulScanWidth ;advance to next scan line
732:
733: dec ulVbBlindCount
734: jz short wide_bytes_end
735:
736: mov eax,ulVbTopScan ;restore scan count
737: dec eax ;Subtract off completed top line
738: mov ulVbTopScan,eax
739: add eax,ulVbYRound ;Calc the number of lines to do
740: mov ecx,ulVbyShift
741: shr eax,cl ;for this venetian blind pass
742: mov ebx,eax ;including any partial patterns
743: ; at the bottom
744:
745: mov esi,pulVbPattern ;Pattern data
746: mov ax,[esi] ;get pattern word
747: add esi,2
748: mov pulVbPattern,esi ;save pattern pointer for later
749:
750: mov edx,pfnWholeBytes
751:
752: jmp short wide_bytes_loop
753:
754: wide_bytes_end:
755: pop ulVbBlindCount
756: pop edi ;restore screen pointer
757: pop ebx ;restore fill scan count
758:
759: mov edx,VGA_BASE + GRAF_ADDR ;restore proper read/write modes
760: mov eax,GRAF_MODE + ((M_PROC_WRITE + M_DATA_READ) SHL 8)
761: out dx,ax
762:
763: jmp pfnContinueDrawing ;either keep drawing or we're done
764:
765:
766: ;-----------------------------------------------------------------------;
767: ; Handle case where both edges are partial (non-whole) bytes.
768: ;-----------------------------------------------------------------------;
769:
770: align 4
771: public non_replace_wide
772: non_replace_wide:
773: push ebx ;Save line count
774: push edi ;Save Dest Addr
775:
776: add edi,ulLeftEdgeAdjust ;point to first whole byte to fill
777:
778: lea eax,do_wide_wes_trick
779: mov pfnWesTrick,eax
780:
781: mov ecx,ulFgClr
782: xor ecx,ulBkClr ;mask = ulBkClr ^ ulFgClr
783:
784: mov ah,cl ;sre = !mask
785: not ah ;Set/Reset Enable
786: mov edx,EGA_BASE+GRAF_ADDR
787: mov al,GRAF_ENAB_SR
788: out dx,ax ;Set Set/Reset Enable bits
789:
790: mov ah,byte ptr ulBkClr ;Set/Reset = background color
791: mov al,GRAF_SET_RESET
792: out dx,ax
793:
794: mov eax,GRAF_MODE + ((M_PROC_WRITE + M_COLOR_READ) SHL 8)
795: out dx,ax ; Set Read Mode 0
796:
797: ;save the width count and pfn here
798:
799: call wes_trick
800:
801: mov edx,EGA_BASE+SEQ_DATA
802: mov eax,0fh
803: out dx,al
804:
805: mov edx,EGA_BASE+GRAF_ADDR
806: mov eax,GRAF_MODE + ((M_PROC_WRITE + M_DATA_READ) SHL 8)
807: out dx,ax
808:
809: mov eax,GRAF_ENAB_SR
810: out dx,ax ;Reset Set/Reset Enable bits
811:
812: pop edi
813: pop ebx
814:
815: jmp pfnContinueDrawing ;either keep drawing or we're done
816:
817: ;-----------------------------------------------------------------------;
818: ; Process any left/right columns that that have to be done.
819: ;
820: ; Currently:
821: ; EBX = height to fill, in scans
822: ; EDI --> first byte of left edge
823: ;-----------------------------------------------------------------------;
824:
825:
826: ;-----------------------------------------------------------------------;
827: ; Handle case where both edges are partial (non-whole) bytes.
828: ;-----------------------------------------------------------------------;
829:
830: align 4
831: public edge_byte_setup
832: edge_byte_setup:
833: lea eax,do_edge_wes_trick
834: mov pfnWesTrick,eax
835:
836: mov ecx,ulFgClr
837: xor ecx,ulBkClr ;mask = ulBkClr ^ ulFgClr
838:
839: mov ah,cl ;sre = !mask
840: not ah ;Set/Reset Enable
841: mov edx,EGA_BASE+GRAF_ADDR
842: mov al,GRAF_ENAB_SR
843: out dx,ax ;Set Set/Reset Enable bits
844:
845: mov ah,byte ptr ulBkClr ;Set/Reset = foreground color
846: mov al,GRAF_SET_RESET
847: out dx,ax
848:
849: mov eax,ulLeftEdgeAdjust
850: or eax,eax
851: jz short do_right_edge
852:
853: mov eax,ulMasks ;Get Left/Right edge Masks
854: mov ah,al
855: mov al,GRAF_BIT_MASK
856: mov edx,EGA_BASE+GRAF_ADDR
857: out dx,ax
858:
859: inc pulPattern ;Adjust Pattern rotation
860:
861: push ebx ;Save line count
862: push edi ;Save Dest Addr
863: call wes_trick
864: pop edi
865: pop ebx
866:
867: mov eax,ulMasks ;restore Left/Right edge Masks
868: dec pulPattern ;Adjust Pattern rotation
869:
870: do_right_edge:
871: mov eax,ulMasks ;Get Left/Right edge Masks
872: and ah,0ffh
873: jz edge_done
874:
875: mov al,GRAF_BIT_MASK
876: mov edx,EGA_BASE+GRAF_ADDR
877: out dx,ax
878:
879: add edi,ulLeftEdgeAdjust ;point to first whole byte to fill
880: add edi,ulWholeBytes ;point to right edge byte to fill
881: call wes_trick
882:
883: edge_done:
884: mov edx,EGA_BASE+SEQ_DATA
885: mov eax,0fh
886: out dx,al
887:
888: mov edx,EGA_BASE+GRAF_ADDR
889: mov eax,GRAF_BIT_MASK+0ff00h
890: out dx,ax
891:
892: mov eax,GRAF_ENAB_SR
893: out dx,ax ;Reset Set/Reset Enable bits
894:
895:
896: ;-----------------------------------------------------------------------;
897: ; See if there are any more banks to process.
898: ;-----------------------------------------------------------------------;
899:
900: public check_next_bank
901: check_next_bank:
902:
903: mov edi,pdsurf
904: mov eax,[edi].dsurf_rcl1WindowClip.yBottom ;is the fill bottom in
905: cmp ulBottomScan,eax ; the current bank?
906: jle short banks_done ;yes, so we're done
907: ;no, map in the next bank and fill it
908: mov ulCurrentTopScan,eax ;remember where the top of the bank
909: ; we're about to map in is (same as
910: ; bottom of bank we just did)
911:
912: ptrCall <dword ptr [edi].dsurf_pfnBankControl>,<edi,eax,JustifyTop>
913: ;map in the bank
914:
915: ; Compute the starting address and scan line count in this bank.
916:
917: mov eax,pdsurf ;EAX->target surface
918: mov ebx,ulBottomScan ;bottom of destination rectangle
919: cmp ebx,[eax].dsurf_rcl1WindowClip.yBottom
920: ;which comes first, the bottom of the
921: ; dest rect or the bottom of the
922: ; current bank?
923: jl short BottomScanSet2 ;fill bottom comes first, so draw to
924: ; that; this is the last bank in fill
925: mov ebx,[eax].dsurf_rcl1WindowClip.yBottom
926: ;bank bottom comes first; draw to
927: ; bottom of bank
928: BottomScanSet2:
929: mov edi,ulCurrentTopScan ;top scan line to fill in current bank
930: sub ebx,edi ;# of scans to fill in bank
931: imul edi,ulScanWidth ;offset of starting scan line
932:
933: ; Note that the start of the bitmap will change each time through the
934: ; bank loop, because the start of the bitmap is varied to map the
935: ; desired scan line to the banking window.
936:
937: add edi,[eax].dsurf_pvBitmapStart ;start of scan in bitmap
938: add edi,ulRowOffset ;EDI = start offset of fill in bitmap
939:
940: ; We have computed the starting address and scan count. Time to start drawing
941: ; in the initial bank.
942:
943: mov esi,pBrush ;edx = min(PatternHeight,BltHeight)
944: mov ecx,[esi + oem_brush_height]
945: sub ecx,ebx
946: sbb edx,edx
947: and edx,ecx
948: add edx,ebx
949: mov ulVbBlindCount,edx
950:
951: ; Brush alignment. We need to look at pptlBrush
952:
953: mov eax,ulCurrentTopScan ;top scan line to fill in current bank
954: sub eax,ulPatternOrgY ;
955:
956: jns short pos_y_offset1 ;
957: neg eax ;
958: and eax,7 ;-eax mod 8
959: neg eax ;
960: add eax,8 ;
961: jmp short save_pat_pointer1
962: pos_y_offset1:
963: and eax,7 ;eax mod 8
964: save_pat_pointer1:
965: add eax,eax ;Y Offset * PatternWidth (2 bytes)
966:
967: lea edx,RotatedPat ;Pattern Dest
968: add eax,edx
969: mov pulPattern,eax ;Drawing code uses this as the
970: ;source for the pattern
971:
972: ; Draw in the new bank.
973:
974: jmp pfnStartDrawing
975:
976:
977: ;-----------------------------------------------------------------------;
978: ; Done with all banks in this fill.
979:
980: public banks_done
981: banks_done:
982: PLAIN_RET
983:
984: endProc vMonoPatBlt
985:
986: ;----------------------------------------------------------------------------
987: ; Wes Trick Setup code. This code decides if this is a one or a two pass
988: ; operation.
989: ;----------------------------------------------------------------------------
990: align 4
991: public wes_trick
992: wes_trick:
993: mov esi,pfnWesTrick
994:
995: mov ecx,ulFgClr ;
996: mov eax,ecx ;
997: xor ecx,ulBkClr ;mask = ulBkClr ^ ulFgClr
998:
999: mov edx,EGA_BASE+SEQ_DATA ;Index should be pointing to the
1000: ; plane mask (2)
1001: mov ch,cl
1002: not ch ;Set/Reset Enable bits
1003: and cl,al ;ulFgdColor & mask
1004: or cl,al
1005: jz short check_bk_bits ;if zero - one background pass
1006:
1007: mov ulVbMask,0 ;We do not want to invert the
1008: ;foreground pass
1009: or ch,cl
1010: mov al,ch
1011: out dx,al ;Enable Planes for First Pass
1012:
1013: push ecx
1014: push edi ;Save our Dest pointer
1015: push ebx ;Save our count
1016: call esi ;Draw the foreground pass
1017: pop ebx ;restore the line count
1018: pop edi ;restore the dest pointer
1019: pop eax ;Restore bk mask
1020: mov esi,pfnWesTrick
1021:
1022:
1023: check_bk_bits:
1024: not al
1025: and al,MM_ALL
1026: jnz short @f
1027: ret
1028: @@:
1029: mov ulVbMask,-1 ;We do not want to invert the
1030: mov edx,EGA_BASE+SEQ_DATA ;Index should be pointing to the
1031: ; plane mask (2)
1032: out dx,al
1033: jmp esi
1034:
1035: ;--------------------------------------------------------------------------
1036: ; Do the edges here.
1037: ;--------------------------------------------------------------------------
1038:
1039: align 4
1040: public do_edge_wes_trick
1041: do_edge_wes_trick:
1042: ; ebx = line count
1043: ; edi = dest
1044:
1045: mov ulVbTopScan,ebx ;Mod 8 our count for the venetian blind
1046: add ebx,ulVbYRound ;Calc the number of lines to do
1047: mov ecx,ulVbyShift
1048: shr ebx,cl
1049:
1050: mov esi,pulPattern
1051: mov ax,[esi] ;get pattern into place
1052: add esi,2 ;patterns stored as words
1053: xor eax,ulVbMask ;Invert the pattern if we are doing
1054: ; a background pass
1055:
1056: push ulVbBlindCount
1057: ; Set up variables for entering unrolled loop.
1058: wes_trick_loop:
1059: SET_UP_UNROLL_VARS ebx,edx, ebx,pfnDraw1WideEntry, LOOP_UNROLL_SHIFT
1060:
1061: mov ecx,ulVbNextScan ;offset from one scan to next
1062:
1063: push edi ;save dest pointer
1064: call edx ;jump into the unrolled loop to draw
1065: pop edi ;restore dest pointer
1066:
1067: add edi,ulScanWidth ;move to next scan line
1068:
1069: dec ulVbBlindCount
1070: jz short wes_trick_loop_done ;jz if we are finished
1071:
1072: mov eax,ulVbTopScan ;restore scan count
1073: dec eax ;Subtract off completed top line
1074: mov ulVbTopScan,eax ;save for next loop
1075: add eax,ulVbYRound ;Calc the number of lines to do
1076: mov ecx,ulVbyShift ;for this venetian blind pass
1077: shr eax,cl ;including any partial patterns
1078: mov ebx,eax ;at the bottom
1079:
1080:
1081: mov ax,[esi]
1082: add esi,2 ;point to the next pattern line
1083: xor eax,ulVbMask ;Invert the pattern if we are doing
1084: ; a background pass
1085:
1086: jmp short wes_trick_loop
1087:
1088: align 4
1089: wes_trick_loop_done:
1090: pop ulVbBlindCount
1091: ret
1092:
1093: ;--------------------------------------------------------------------------
1094: ; Do the middle bytes here for blts with rops.
1095: ;--------------------------------------------------------------------------
1096:
1097: align 4
1098: public do_wide_wes_trick
1099: do_wide_wes_trick:
1100: ; ebx = line count
1101: ; edi = dest
1102:
1103: mov ulVbTopScan,ebx ;Mod 8 our count for the venetian blind
1104: add ebx,ulVbYRound ;Calc the number of lines to do
1105: mov ecx,ulVbyShift
1106: shr ebx,cl
1107:
1108: mov esi,pulPattern
1109: mov al,[esi] ;get pattern into place
1110: add esi,2 ;patterns stored as words
1111: mov pulVbPattern,esi
1112: xor eax,ulVbMask ;Invert the pattern if we are doing
1113: ; a background pass
1114:
1115: push ulVbBlindCount
1116:
1117: mov edx,pfnWholeBytes
1118:
1119: ; Set up variables for entering unrolled loop.
1120: wide_wes_trick_loop:
1121:
1122: SET_UP_UNROLL_VARS ebx,ecx,ebx,[edx], LOOP_UNROLL_SHIFT
1123:
1124: mov esi,ulWholeBytes
1125: mov edx,ulVbNextScan ;offset from one scan to next
1126: sub edx,esi
1127: add edx,ulSpecialBytes
1128:
1129: push edi ;save dest pointer
1130: call ecx ;jump into the unrolled loop to draw
1131: pop edi ;restore dest pointer
1132:
1133: add edi,ulScanWidth ;move to next scan line
1134:
1135: dec ulVbBlindCount
1136: jz short wide_wes_trick_loop_done ;jz if we are finished
1137:
1138: mov eax,ulVbTopScan ;restore scan count
1139: dec eax ;Subtract off completed top line
1140: mov ulVbTopScan,eax ;save for next loop
1141: add eax,ulVbYRound ;Calc the number of lines to do
1142: mov ecx,ulVbyShift ;for this venetian blind pass
1143: shr eax,cl ;including any partial patterns
1144: mov ebx,eax ;at the bottom
1145:
1146:
1147: mov esi,pulVbPattern
1148: mov al,[esi] ;get pattern word
1149: add esi,2 ;point to the next pattern line
1150: mov pulVbPattern,esi
1151: xor eax,ulVbMask ;Invert the pattern if we are doing
1152: ; a background pass
1153:
1154: mov edx,pfnWholeBytes
1155: jmp short wide_wes_trick_loop
1156:
1157: align 4
1158: wide_wes_trick_loop_done:
1159: pop ulVbBlindCount
1160: ret
1161:
1162: ;-----------------------------------------------------------------------;
1163: ; Unrolled loops.
1164: ;-----------------------------------------------------------------------;
1165:
1166: ;-----------------------------------------------------------------------;
1167: ; Unrolled loop stuff for wide replace-type rops (arbitrary width).
1168: ;-----------------------------------------------------------------------;
1169:
1170: ; Tables of entry points into unrolled wide write-only loops.
1171: UNROLL_LOOP_ENTRY_TABLE pfnDrawWide00Entry,W00,LOOP_UNROLL_COUNT
1172: UNROLL_LOOP_ENTRY_TABLE pfnDrawWide01Entry,W01,LOOP_UNROLL_COUNT
1173: UNROLL_LOOP_ENTRY_TABLE pfnDrawWide10Entry,W10,LOOP_UNROLL_COUNT
1174: UNROLL_LOOP_ENTRY_TABLE pfnDrawWide11Entry,W11,LOOP_UNROLL_COUNT
1175:
1176: ;-----------------------------------------------------------------------;
1177: ; Macro to draw n bytes, 0 leading bytes, 0 trailing bytes, then advance
1178: ; to next scan line.
1179:
1180: DRAW_WIDE_00 macro ENTRY_LABEL,ENTRY_INDEX
1181: &ENTRY_LABEL&ENTRY_INDEX&:
1182: mov ecx,esi ;# of whole words
1183: rep stosw ;fill all whole bytes as dwords
1184: add edi,edx ;point to the next scan line
1185: endm ;-----------------------------------;
1186:
1187: ; N-wide write-only, 0 leading bytes, 0 trailing bytes.
1188: ; EAX = Pattern Byte
1189: ; EBX = count of scans to fill ((total scans/ pattern height) + partial)
1190: ; EDX = offset from end of one scan's fill to start of next similar line
1191: ; ESI = pattern data
1192: ; EDI = target address to fill
1193:
1194: align 4
1195: draw_wide_00_loop proc near
1196: UNROLL_LOOP DRAW_WIDE_00,W00,LOOP_UNROLL_COUNT
1197: dec ebx
1198: jnz draw_wide_00_loop
1199:
1200: ret
1201:
1202: draw_wide_00_loop endp
1203:
1204:
1205: ;-----------------------------------------------------------------------;
1206: ; Macro to draw n bytes, 0 leading bytes, 0 trailing bytes, then advance
1207: ; to next scan line.
1208:
1209: DRAW_WIDE_01 macro ENTRY_LABEL,ENTRY_INDEX
1210: &ENTRY_LABEL&ENTRY_INDEX&:
1211: mov ecx,esi ;# of whole words
1212: rep stosw ;fill all whole bytes as dwords
1213: mov [edi],al ;trailing byte
1214: inc edi
1215: add edi,edx ;point to the next scan line
1216: endm ;-----------------------------------;
1217:
1218: ; N-wide write-only, 0 leading bytes, 0 trailing bytes.
1219: ; EAX = Pattern Byte
1220: ; EBX = count of scans to fill ((total scans/ pattern height) + partial)
1221: ; EDX = offset from end of one scan's fill to start of next similar line
1222: ; ESI = pattern data
1223: ; EDI = target address to fill
1224:
1225: align 4
1226: draw_wide_01_loop proc near
1227: UNROLL_LOOP DRAW_WIDE_01,W01,LOOP_UNROLL_COUNT
1228: dec ebx
1229: jnz draw_wide_01_loop
1230: ret
1231:
1232: draw_wide_01_loop endp
1233:
1234:
1235: ;-----------------------------------------------------------------------;
1236: ; Macro to draw n bytes, 0 leading bytes, 0 trailing bytes, then advance
1237: ; to next scan line.
1238:
1239: DRAW_WIDE_10 macro ENTRY_LABEL,ENTRY_INDEX
1240: &ENTRY_LABEL&ENTRY_INDEX&:
1241: mov [edi],ah ;do leading byte
1242: inc edi ;advance poitner
1243: mov ecx,esi ;# of whole words
1244: rep stosw ;fill all whole bytes as dwords
1245: add edi,edx ;point to the next scan line
1246: endm ;-----------------------------------;
1247:
1248: ; N-wide write-only, 0 leading bytes, 0 trailing bytes.
1249: ; EAX = Pattern Byte
1250: ; EBX = count of scans to fill ((total scans/ pattern height) + partial)
1251: ; EDX = offset from end of one scan's fill to start of next similar line
1252: ; ESI = pattern data
1253: ; EDI = target address to fill
1254:
1255: align 4
1256: draw_wide_10_loop proc near
1257: UNROLL_LOOP DRAW_WIDE_10,W10,LOOP_UNROLL_COUNT
1258: dec ebx
1259: jnz draw_wide_10_loop
1260: ret
1261:
1262: draw_wide_10_loop endp
1263:
1264: ;-----------------------------------------------------------------------;
1265: ; Macro to draw n bytes, 0 leading bytes, 0 trailing bytes, then advance
1266: ; to next scan line.
1267:
1268: DRAW_WIDE_11 macro ENTRY_LABEL,ENTRY_INDEX
1269: &ENTRY_LABEL&ENTRY_INDEX&:
1270: mov [edi],ah ;do leading byte
1271: inc edi ;advance poitner
1272: mov ecx,esi ;# of whole words
1273: rep stosw ;fill all whole bytes as dwords
1274: mov [edi],al ;trailing byte
1275: inc edi
1276: add edi,edx ;point to the next scan line
1277: endm ;-----------------------------------;
1278:
1279: ; N-wide write-only, 0 leading bytes, 0 trailing bytes.
1280: ; EAX = Pattern Byte
1281: ; EBX = count of scans to fill ((total scans/ pattern height) + partial)
1282: ; EDX = offset from end of one scan's fill to start of next similar line
1283: ; ESI = pattern data
1284: ; EDI = target address to fill
1285:
1286: align 4
1287: draw_wide_11_loop proc near
1288: UNROLL_LOOP DRAW_WIDE_11,W11,LOOP_UNROLL_COUNT
1289: dec ebx
1290: jnz draw_wide_11_loop
1291: ret
1292:
1293: draw_wide_11_loop endp
1294:
1295: ;-----------------------------------------------------------------------;
1296: ; Unrolled drawing stuff (unrolled to reduce jumps to speed things up),
1297: ; for cases where read before write is NOT required.
1298: ;-----------------------------------------------------------------------;
1299:
1300: ; Tables of entry points into unrolled 1-, 2-, 3-, and 4-wide write-only loops.
1301: ; Note that there may be separate entry tables for various alignments of a
1302: ; specific width, in cases where performance can be improved by using different
1303: ; code for different alignments.
1304:
1305: UNROLL_LOOP_ENTRY_TABLE pfnDraw1WideEvenEntry,W1_EVEN,LOOP_UNROLL_COUNT
1306: UNROLL_LOOP_ENTRY_TABLE pfnDraw1WideOddEntry,W1_ODD,LOOP_UNROLL_COUNT
1307: UNROLL_LOOP_ENTRY_TABLE pfnDraw2WideEvenEntry,W2_EVEN,LOOP_UNROLL_COUNT
1308: UNROLL_LOOP_ENTRY_TABLE pfnDraw2WideOddEntry,W2_ODD,LOOP_UNROLL_COUNT
1309: UNROLL_LOOP_ENTRY_TABLE pfnDraw3WideEvenEntry,W3_EVEN,LOOP_UNROLL_COUNT
1310: UNROLL_LOOP_ENTRY_TABLE pfnDraw3WideOddEntry,W3_ODD,LOOP_UNROLL_COUNT
1311: UNROLL_LOOP_ENTRY_TABLE pfnDraw4WideEvenEntry,W4_EVEN,LOOP_UNROLL_COUNT
1312: UNROLL_LOOP_ENTRY_TABLE pfnDraw4WideOddEntry,W4_ODD,LOOP_UNROLL_COUNT
1313: UNROLL_LOOP_ENTRY_TABLE pfnDraw5WideEvenEntry,W5_EVEN,LOOP_UNROLL_COUNT
1314: UNROLL_LOOP_ENTRY_TABLE pfnDraw5WideOddEntry,W5_ODD,LOOP_UNROLL_COUNT
1315: UNROLL_LOOP_ENTRY_TABLE pfnDraw6WideEvenEntry,W6_EVEN,LOOP_UNROLL_COUNT
1316: UNROLL_LOOP_ENTRY_TABLE pfnDraw6WideOddEntry,W6_ODD,LOOP_UNROLL_COUNT
1317: UNROLL_LOOP_ENTRY_TABLE pfnDraw7WideEvenEntry,W7_EVEN,LOOP_UNROLL_COUNT
1318: UNROLL_LOOP_ENTRY_TABLE pfnDraw7WideOddEntry,W7_ODD,LOOP_UNROLL_COUNT
1319: UNROLL_LOOP_ENTRY_TABLE pfnDraw8WideEvenEntry,W8_EVEN,LOOP_UNROLL_COUNT
1320: UNROLL_LOOP_ENTRY_TABLE pfnDraw8WideOddEntry,W8_ODD,LOOP_UNROLL_COUNT
1321:
1322: ;-----------------------------------------------------------------------;
1323: ; Unrolled 1-, 2-, 3-, and 4-wide write-only edge-drawing loops.
1324: ;
1325: ; Entry:
1326: ; AL/AX/EAX = pixel mask (if AX or EAX, then 0xFFFF or 0xFFFFFFFF)
1327: ; EBX = unrolled loop count
1328: ; ECX = scan line width in bytes
1329: ; EDI = start offset
1330: ;
1331: ; EBX, EDI modified. All other registers preserved.
1332:
1333: ;-----------------------------------------------------------------------;
1334: ; Macro to draw one write-only byte, then advance to next scan line.
1335:
1336: DRAW_1_WIDE_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1337: &ENTRY_LABEL&ENTRY_INDEX&:
1338: mov [edi],al ;we always read 0xFF, so AL is written
1339: ; as-is; because we're in write mode 3,
1340: ; AL becomes the Bit Mask
1341: add edi,edx ;point to the next scan line
1342: endm ;-----------------------------------;
1343:
1344: ; 1-wide write-only.
1345:
1346: align 4
1347: draw_1_wide_even_loop proc near
1348: UNROLL_LOOP DRAW_1_WIDE_EVEN,W1_EVEN,LOOP_UNROLL_COUNT
1349: dec ebx
1350: jnz draw_1_wide_even_loop
1351:
1352: ret
1353:
1354: draw_1_wide_even_loop endp
1355:
1356: DRAW_1_WIDE_ODD macro ENTRY_LABEL,ENTRY_INDEX
1357: &ENTRY_LABEL&ENTRY_INDEX&:
1358: mov [edi],ah ;we always read 0xFF, so AL is written
1359: ; as-is; because we're in write mode 3,
1360: ; AL becomes the Bit Mask
1361: add edi,edx ;point to the next scan line
1362: endm ;-----------------------------------;
1363:
1364: ; 1-wide write-only.
1365:
1366: align 4
1367: draw_1_wide_odd_loop proc near
1368: UNROLL_LOOP DRAW_1_WIDE_ODD,W1_ODD,LOOP_UNROLL_COUNT
1369: dec ebx
1370: jnz draw_1_wide_odd_loop
1371:
1372: ret
1373:
1374: draw_1_wide_odd_loop endp
1375:
1376: ;-----------------------------------------------------------------------;
1377: ; Macro to draw two write-only bytes, then advance to next scan line.
1378:
1379: DRAW_2_WIDE_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1380: &ENTRY_LABEL&ENTRY_INDEX&:
1381: mov [edi],ax
1382: add edi,edx ;point to the next scan line
1383: endm ;-----------------------------------;
1384:
1385: ; 2-wide write-only.
1386:
1387: align 4
1388: draw_2_wide_even_loop proc near
1389: UNROLL_LOOP DRAW_2_WIDE_EVEN,W2_EVEN,LOOP_UNROLL_COUNT
1390: dec ebx
1391: jnz draw_2_wide_even_loop
1392:
1393: ret
1394:
1395: draw_2_wide_even_loop endp
1396:
1397: DRAW_2_WIDE_ODD macro ENTRY_LABEL,ENTRY_INDEX
1398: &ENTRY_LABEL&ENTRY_INDEX&:
1399: mov [edi],ah
1400: mov [edi+1],al
1401: add edi,edx ;point to the next scan line
1402: endm ;-----------------------------------;
1403:
1404: ; 2-wide write-only.
1405:
1406: align 4
1407: draw_2_wide_odd_loop proc near
1408: UNROLL_LOOP DRAW_2_WIDE_ODD,W2_ODD,LOOP_UNROLL_COUNT
1409: dec ebx
1410: jnz draw_2_wide_odd_loop
1411:
1412: ret
1413:
1414: draw_2_wide_odd_loop endp
1415:
1416: ;-----------------------------------------------------------------------;
1417: ; Macro to draw three write-only bytes, then advance to next scan line.
1418: ; Optimized for even start address.
1419:
1420: DRAW_3_WIDE_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1421: &ENTRY_LABEL&ENTRY_INDEX&:
1422: mov [edi],ax
1423: mov [edi+2],al
1424: add edi,edx ;point to the next scan line
1425: endm ;-----------------------------------;
1426:
1427: ; 3-wide write-only, starting at an even address.
1428:
1429: align 4
1430: draw_3_wide_even_loop proc near
1431: UNROLL_LOOP DRAW_3_WIDE_EVEN,W3_EVEN,LOOP_UNROLL_COUNT
1432: dec ebx
1433: jnz draw_3_wide_even_loop
1434:
1435: ret
1436:
1437: draw_3_wide_even_loop endp
1438:
1439: ;-----------------------------------------------------------------------;
1440: ; Macro to draw three write-only bytes, then advance to next scan line.
1441: ; Optimized for odd start address.
1442:
1443: DRAW_3_WIDE_ODD macro ENTRY_LABEL,ENTRY_INDEX
1444: &ENTRY_LABEL&ENTRY_INDEX&:
1445: mov [edi],ah
1446: mov [edi+1],ax
1447: add edi,edx ;point to the next scan line
1448: endm ;-----------------------------------;
1449:
1450: ; 3-wide write-only, starting at an odd address.
1451:
1452: align 4
1453: draw_3_wide_odd_loop proc near
1454: UNROLL_LOOP DRAW_3_WIDE_ODD,W3_ODD,LOOP_UNROLL_COUNT
1455: dec ebx
1456: jnz draw_3_wide_odd_loop
1457:
1458: ret
1459:
1460: draw_3_wide_odd_loop endp
1461:
1462:
1463: ;-----------------------------------------------------------------------;
1464: ; Macro to draw three write-only bytes, then advance to next scan line.
1465: ; Optimized for even start address.
1466:
1467: DRAW_4_WIDE_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1468: &ENTRY_LABEL&ENTRY_INDEX&:
1469: mov [edi],ax
1470: mov [edi+2],ax
1471: add edi,edx ;point to the next scan line
1472: endm ;-----------------------------------;
1473:
1474: ; 4-wide write-only, starting at an even address.
1475:
1476: align 4
1477: draw_4_wide_even_loop proc near
1478: UNROLL_LOOP DRAW_4_WIDE_EVEN,W4_EVEN,LOOP_UNROLL_COUNT
1479: dec ebx
1480: jnz draw_4_wide_even_loop
1481:
1482: ret
1483:
1484: draw_4_wide_even_loop endp
1485:
1486: ;-----------------------------------------------------------------------;
1487: ; Macro to draw three write-only bytes, then advance to next scan line.
1488: ; Optimized for odd start address.
1489:
1490: DRAW_4_WIDE_ODD macro ENTRY_LABEL,ENTRY_INDEX
1491: &ENTRY_LABEL&ENTRY_INDEX&:
1492: mov [edi],ah
1493: mov [edi+1],ax
1494: mov [edi+3],al
1495: add edi,edx ;point to the next scan line
1496: endm ;-----------------------------------;
1497:
1498: ; 4-wide write-only, starting at an odd address.
1499:
1500: align 4
1501: draw_4_wide_odd_loop proc near
1502: UNROLL_LOOP DRAW_4_WIDE_ODD,W4_ODD,LOOP_UNROLL_COUNT
1503: dec ebx
1504: jnz draw_4_wide_odd_loop
1505:
1506: ret
1507:
1508: draw_4_wide_odd_loop endp
1509:
1510: ;-----------------------------------------------------------------------;
1511: ; Macro to draw three write-only bytes, then advance to next scan line.
1512: ; Optimized for even start address.
1513:
1514: DRAW_5_WIDE_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1515: &ENTRY_LABEL&ENTRY_INDEX&:
1516: mov [edi],ax
1517: mov [edi+2],ax
1518: mov [edi+4],al
1519: add edi,edx ;point to the next scan line
1520: endm ;-----------------------------------;
1521:
1522: ; 5-wide write-only, starting at an even address.
1523:
1524: align 4
1525: draw_5_wide_even_loop proc near
1526: UNROLL_LOOP DRAW_5_WIDE_EVEN,W5_EVEN,LOOP_UNROLL_COUNT
1527: dec ebx
1528: jnz draw_5_wide_even_loop
1529:
1530: ret
1531:
1532: draw_5_wide_even_loop endp
1533:
1534: ;-----------------------------------------------------------------------;
1535: ; Macro to draw three write-only bytes, then advance to next scan line.
1536: ; Optimized for odd start address.
1537:
1538: DRAW_5_WIDE_ODD macro ENTRY_LABEL,ENTRY_INDEX
1539: &ENTRY_LABEL&ENTRY_INDEX&:
1540: mov [edi],ah
1541: mov [edi+1],ax
1542: mov [edi+3],ax
1543: add edi,edx ;point to the next scan line
1544: endm ;-----------------------------------;
1545:
1546: ; 5-wide write-only, starting at an odd address.
1547:
1548: align 4
1549: draw_5_wide_odd_loop proc near
1550: UNROLL_LOOP DRAW_5_WIDE_ODD,W5_ODD,LOOP_UNROLL_COUNT
1551: dec ebx
1552: jnz draw_5_wide_odd_loop
1553:
1554: ret
1555:
1556: draw_5_wide_odd_loop endp
1557:
1558: ;-----------------------------------------------------------------------;
1559: ; Macro to draw three write-only bytes, then advance to next scan line.
1560: ; Optimized for even start address.
1561:
1562: DRAW_6_WIDE_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1563: &ENTRY_LABEL&ENTRY_INDEX&:
1564: mov [edi],ax
1565: mov [edi+2],ax
1566: mov [edi+4],ax
1567: add edi,edx ;point to the next scan line
1568: endm ;-----------------------------------;
1569:
1570: ; 6-wide write-only, starting at an even address.
1571:
1572: align 4
1573: draw_6_wide_even_loop proc near
1574: UNROLL_LOOP DRAW_6_WIDE_EVEN,W6_EVEN,LOOP_UNROLL_COUNT
1575: dec ebx
1576: jnz draw_6_wide_even_loop
1577:
1578: ret
1579:
1580: draw_6_wide_even_loop endp
1581:
1582: ;-----------------------------------------------------------------------;
1583: ; Macro to draw three write-only bytes, then advance to next scan line.
1584: ; Optimized for odd start address.
1585:
1586: DRAW_6_WIDE_ODD macro ENTRY_LABEL,ENTRY_INDEX
1587: &ENTRY_LABEL&ENTRY_INDEX&:
1588: mov [edi],ah
1589: mov [edi+1],ax
1590: mov [edi+3],ax
1591: mov [edi+5],al
1592: add edi,edx ;point to the next scan line
1593: endm ;-----------------------------------;
1594:
1595: ; 6-wide write-only, starting at an odd address.
1596:
1597: align 4
1598: draw_6_wide_odd_loop proc near
1599: UNROLL_LOOP DRAW_6_WIDE_ODD,W6_ODD,LOOP_UNROLL_COUNT
1600: dec ebx
1601: jnz draw_6_wide_odd_loop
1602:
1603: ret
1604:
1605: draw_6_wide_odd_loop endp
1606:
1607: ;-----------------------------------------------------------------------;
1608: ; Macro to draw three write-only bytes, then advance to next scan line.
1609: ; Optimized for even start address.
1610:
1611: DRAW_7_WIDE_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1612: &ENTRY_LABEL&ENTRY_INDEX&:
1613: mov [edi],ax
1614: mov [edi+2],ax
1615: mov [edi+4],ax
1616: mov [edi+6],al
1617: add edi,edx ;point to the next scan line
1618: endm ;-----------------------------------;
1619:
1620: ; 7-wide write-only, starting at an even address.
1621:
1622: align 4
1623: draw_7_wide_even_loop proc near
1624: UNROLL_LOOP DRAW_7_WIDE_EVEN,W7_EVEN,LOOP_UNROLL_COUNT
1625: dec ebx
1626: jnz draw_7_wide_even_loop
1627:
1628: ret
1629:
1630: draw_7_wide_even_loop endp
1631:
1632: ;-----------------------------------------------------------------------;
1633: ; Macro to draw three write-only bytes, then advance to next scan line.
1634: ; Optimized for odd start address.
1635:
1636: DRAW_7_WIDE_ODD macro ENTRY_LABEL,ENTRY_INDEX
1637: &ENTRY_LABEL&ENTRY_INDEX&:
1638: mov [edi],ah
1639: mov [edi+1],ax
1640: mov [edi+3],ax
1641: mov [edi+5],ax
1642: add edi,edx ;point to the next scan line
1643: endm ;-----------------------------------;
1644:
1645: ; 7-wide write-only, starting at an odd address.
1646:
1647: align 4
1648: draw_7_wide_odd_loop proc near
1649: UNROLL_LOOP DRAW_7_WIDE_ODD,W7_ODD,LOOP_UNROLL_COUNT
1650: dec ebx
1651: jnz draw_7_wide_odd_loop
1652:
1653: ret
1654:
1655: draw_7_wide_odd_loop endp
1656:
1657: ;-----------------------------------------------------------------------;
1658: ; Macro to draw three write-only bytes, then advance to next scan line.
1659: ; Optimized for even start address.
1660:
1661: DRAW_8_WIDE_EVEN macro ENTRY_LABEL,ENTRY_INDEX
1662: &ENTRY_LABEL&ENTRY_INDEX&:
1663: mov [edi],ax
1664: mov [edi+2],ax
1665: mov [edi+4],ax
1666: mov [edi+6],ax
1667: add edi,edx ;point to the next scan line
1668: endm ;-----------------------------------;
1669:
1670: ; 8-wide write-only, starting at an even address.
1671:
1672: align 4
1673: draw_8_wide_even_loop proc near
1674: UNROLL_LOOP DRAW_8_WIDE_EVEN,W8_EVEN,LOOP_UNROLL_COUNT
1675: dec ebx
1676: jnz draw_8_wide_even_loop
1677:
1678: ret
1679:
1680: draw_8_wide_even_loop endp
1681:
1682: ;-----------------------------------------------------------------------;
1683: ; Macro to draw three write-only bytes, then advance to next scan line.
1684: ; Optimized for odd start address.
1685:
1686: DRAW_8_WIDE_ODD macro ENTRY_LABEL,ENTRY_INDEX
1687: &ENTRY_LABEL&ENTRY_INDEX&:
1688: mov [edi],ah
1689: mov [edi+1],ax
1690: mov [edi+3],ax
1691: mov [edi+5],ax
1692: mov [edi+7],al
1693: add edi,edx ;point to the next scan line
1694: endm ;-----------------------------------;
1695:
1696: ; 8-wide write-only, starting at an odd address.
1697:
1698: align 4
1699: draw_8_wide_odd_loop proc near
1700: UNROLL_LOOP DRAW_8_WIDE_ODD,W8_ODD,LOOP_UNROLL_COUNT
1701: dec ebx
1702: jnz draw_8_wide_odd_loop
1703:
1704: ret
1705:
1706: draw_8_wide_odd_loop endp
1707:
1708: ;-----------------------------------------------------------------------;
1709: ; Unrolled 1-, 2-, 3-, and 4-wide read before write drawing loops.
1710: ;
1711: ; Entry:
1712: ; AL = pixel mask
1713: ; EBX = unrolled loop count
1714: ; ECX = scan line width in bytes
1715: ; EDI = start offset
1716: ;
1717: ; EBX, EDI modified. All other registers preserved.
1718:
1719: UNROLL_LOOP_ENTRY_TABLE pfnDraw1WideEntry,RW1,LOOP_UNROLL_COUNT
1720:
1721: ;-----------------------------------------------------------------------;
1722: ; Macro to draw one read before write byte, then advance to next scan line.
1723:
1724: DRAW_1_WIDE macro ENTRY_LABEL,ENTRY_INDEX
1725: &ENTRY_LABEL&ENTRY_INDEX&:
1726: mov dh,[edi] ;load latches w/o destroying our data
1727: mov [edi],al ;write out our byte
1728: add edi,ecx ;move to the next blind
1729: endm ;-----------------------------------;
1730:
1731: ; 1-wide read/write.
1732:
1733: align 4
1734: draw_1_wide_loop proc near
1735: UNROLL_LOOP DRAW_1_WIDE,RW1,LOOP_UNROLL_COUNT
1736: dec ebx
1737: jnz draw_1_wide_loop
1738:
1739: ret
1740:
1741: draw_1_wide_loop endp
1742:
1743: ; Tables of entry points into unrolled 1-, 2-, 3-, and 4-wide, and 5-or-wider
1744: ; read before write loops.
1745:
1746: UNROLL_LOOP_ENTRY_TABLE pfnDraw1RWEntry,RWW1,LOOP_UNROLL_COUNT
1747: UNROLL_LOOP_ENTRY_TABLE pfnDraw2RWEntry,RWW2,LOOP_UNROLL_COUNT
1748: UNROLL_LOOP_ENTRY_TABLE pfnDraw3RWEntry,RWW3,LOOP_UNROLL_COUNT
1749: UNROLL_LOOP_ENTRY_TABLE pfnDraw4RWEntry,RWW4,LOOP_UNROLL_COUNT
1750: UNROLL_LOOP_ENTRY_TABLE pfnDrawRWWideEntry,RWWIDE,LOOP_UNROLL_COUNT
1751:
1752:
1753: ;-----------------------------------------------------------------------;
1754: ; Unrolled 1-, 2-, 3-, and 4-wide read before write drawing loops.
1755: ;
1756: ; Entry:
1757: ; AL = pixel mask
1758: ; EBX = unrolled loop count
1759: ; ECX = scan line width in bytes
1760: ; EDI = start offset
1761: ;
1762: ; EBX, EDI modified. All other registers preserved.
1763:
1764: ;-----------------------------------------------------------------------;
1765: ; Macro to draw one read before write byte, then advance to next scan line.
1766:
1767: DRAW_1_WIDE_RW macro ENTRY_LABEL,ENTRY_INDEX
1768: &ENTRY_LABEL&ENTRY_INDEX&:
1769: mov ah,[edi]
1770: mov [edi],al
1771: add edi,edx ;point to the next scan line
1772: endm ;-----------------------------------;
1773:
1774: ; 1-wide read/write.
1775:
1776: align 4
1777: draw_1_wide_rop_loop proc near
1778: UNROLL_LOOP DRAW_1_WIDE_RW,RWW1,LOOP_UNROLL_COUNT
1779: dec ebx
1780: jnz draw_1_wide_rop_loop
1781:
1782: ret
1783:
1784: draw_1_wide_rop_loop endp
1785:
1786: ;-----------------------------------------------------------------------;
1787: ; Macro to draw two read before write bytes, then advance to next scan line.
1788:
1789: DRAW_2_WIDE_RW macro ENTRY_LABEL,ENTRY_INDEX
1790: &ENTRY_LABEL&ENTRY_INDEX&:
1791: mov ah,[edi]
1792: mov [edi],al
1793: mov ah,[edi+1]
1794: mov [edi+1],al
1795: add edi,edx ;point to the next scan line
1796: endm ;-----------------------------------;
1797:
1798: ; 2-wide read/write.
1799:
1800: align 4
1801: draw_2_wide_rop_loop proc near
1802: UNROLL_LOOP DRAW_2_WIDE_RW,RWW2,LOOP_UNROLL_COUNT
1803: dec ebx
1804: jnz draw_2_wide_rop_loop
1805:
1806: ret
1807:
1808: draw_2_wide_rop_loop endp
1809:
1810: ;-----------------------------------------------------------------------;
1811: ; Macro to draw three read before write bytes, then advance to next scan line.
1812:
1813: DRAW_3_WIDE_RW macro ENTRY_LABEL,ENTRY_INDEX
1814: &ENTRY_LABEL&ENTRY_INDEX&:
1815: mov ah,[edi]
1816: mov [edi],al
1817: mov ah,[edi+1]
1818: mov [edi+1],al
1819: mov ah,[edi+2]
1820: mov [edi+2],al
1821: add edi,edx ;point to the next scan line
1822: endm ;-----------------------------------;
1823:
1824: ; 3-wide read/write.
1825:
1826: align 4
1827: draw_3_wide_rop_loop proc near
1828: UNROLL_LOOP DRAW_3_WIDE_RW,RWW3,LOOP_UNROLL_COUNT
1829: dec ebx
1830: jnz draw_3_wide_rop_loop
1831:
1832: ret
1833:
1834: draw_3_wide_rop_loop endp
1835:
1836: ;-----------------------------------------------------------------------;
1837: ; Macro to draw four read before write bytes, then advance to next scan line.
1838:
1839: DRAW_4_WIDE_RW macro ENTRY_LABEL,ENTRY_INDEX
1840: &ENTRY_LABEL&ENTRY_INDEX&:
1841: mov ah,[edi]
1842: mov [edi],al
1843: mov ah,[edi+1]
1844: mov [edi+1],al
1845: mov ah,[edi+2]
1846: mov [edi+2],al
1847: mov ah,[edi+3]
1848: mov [edi+3],al
1849: add edi,edx ;point to the next scan line
1850: endm ;-----------------------------------;
1851:
1852: ; 4-wide read/write.
1853:
1854: align 4
1855: draw_4_wide_rop_loop proc near
1856: UNROLL_LOOP DRAW_4_WIDE_RW,RWW4,LOOP_UNROLL_COUNT
1857: dec ebx
1858: jnz draw_4_wide_rop_loop
1859:
1860: ret
1861:
1862: draw_4_wide_rop_loop endp
1863:
1864: ;-----------------------------------------------------------------------;
1865: ; Unrolled 5-or-wider read before write loop.
1866: ;
1867: ; Entry:
1868: ; EAX = # of bytes to fill across scan line (needed only by 5-or-wider
1869: ; handler)
1870: ; EBX = unrolled loop count
1871: ; EDX = offset from end of one scan line to the start of the next next
1872: ; EDI = start offset
1873: ;
1874: ; EBX, ECX, ESI, EDI modified. All other registers preserved.
1875:
1876: ;-----------------------------------------------------------------------;
1877: ; Macro to draw five or more read before write bytes, then advance to
1878: ; next scan line. (Actually, will handle any number of bytes,
1879: ; including 0, but there are special-case handlers for narrow cases.)
1880: ; Works because reads of display memory return 0ffh, which then becomes the
1881: ; Bit Mask as it's written in write mode 3.
1882:
1883: DRAW_WIDE_RW macro ENTRY_LABEL,ENTRY_INDEX
1884: &ENTRY_LABEL&ENTRY_INDEX&:
1885: mov ecx,esi
1886: @@: mov ah,[edi]
1887: mov [edi],al
1888: inc edi
1889: dec ecx
1890: jnz @b
1891: add edi,edx
1892: endm ;-----------------------------------;
1893:
1894: ; 5-or-wider read/write.
1895:
1896: align 4
1897: draw_wide_rop_loop proc near
1898: UNROLL_LOOP DRAW_WIDE_RW,RWWIDE,LOOP_UNROLL_COUNT
1899: dec ebx
1900: jnz draw_wide_rop_loop
1901:
1902: ret
1903:
1904: draw_wide_rop_loop endp
1905:
1906: _TEXT$01 ends
1907:
1908: end
1909:
1910: ;masm386 -Mx -I..\..\inc -I..\..\..\inc -Id:\nt\public\sdk\inc -Di386=1 -DNT_INST=0 -DNT_UP=1 -DSTD_CALL -DDBG=1 -DDEVL=1 i386\patblt.asm,obj\i386\patblt.obj,x.lst;
1911:
1912:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.