![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rleblts.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 rleblts.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 root 1: ;---------------------------Module-Header------------------------------;
2: ; Module Name: rleblts.asm
3: ;
4: ; Copyright (c) 1992 Microsoft Corporation
5: ;-----------------------------------------------------------------------;
6: .386
7:
8: ifndef DOS_PLATFORM
9: .model small,c
10: else
11: ifdef STD_CALL
12: .model small,c
13: else
14: .model small,pascal
15: endif; STD_CALL
16: endif; DOS_PLATFORM
17:
18: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
19: assume fs:nothing,gs:nothing
20:
21: .xlist
22: include stdcall.inc ;calling convention cmacros
23: include i386\egavga.inc
24: include i386\strucs.inc
25: .list
26:
27: .code
28:
29: ;-------------------------------Macro-----------------------------------;
30: ; RleSetUp
31: ;
32: ; Set the EGA\VGA to write mode 2 (M_COLOR_WRITE). Initialize local vars
33: ;
34: ; Entry:
35: ; None
36: ; Returns:
37: ; ESI = pointer to the source bitmap
38: ;
39: ;-----------------------------------------------------------------------;
40:
41: RleSetUp macro
42:
43: cld
44:
45: mov dx,VGA_BASE + GRAF_ADDR
46: mov ax,(M_COLOR_WRITE shl 8) + GRAF_MODE
47: out dx,ax
48:
49: mov esi,pRleInfo
50: mov edi,[esi].RLE_prctlTrg
51: mov eax,[edi].xLeft
52: mov xStart,eax
53: mov eax,[esi].RLE_xBegin
54: mov xCurr,eax
55: mov eax,[edi].yBottom
56: dec eax
57: mov yCurr,eax
58:
59: mov eax,[esi].RLE_pulTranslate
60: mov pulXlate,eax
61: mov eax,[esi].RLE_prctlClip
62: mov prclClip,eax
63: mov eax,[esi].RLE_pjSrcBitsMax
64: mov pjSrcEnd,eax
65: mov ebx,[esi].RLE_pjTrg
66:
67: mov pjDst,ebx
68: mov esi,[esi].RLE_pjSrcBits
69: endm
70:
71: ;-------------------------------Macro-----------------------------------;
72: ; RleDelta
73: ;
74: ; Handle the Delta case.
75: ;
76: ; Entry:
77: ; ESI = pointer to the horz/vert offset of the source bitmap
78: ; Returns:
79: ; None
80: ;
81: ;-----------------------------------------------------------------------;
82:
83: RleDelta macro dest
84:
85: lodsw
86: movzx ecx,al
87: add xCurr,ecx ;x adjustment
88:
89: movzx eax,ah
90: sub yCurr,eax ;y adjustment
91:
92: mul lNextScan
93: sub pjDst,eax
94: jmp dest
95: endm
96:
97: ;-------------------------------Macro-----------------------------------;
98: ; RleExit
99: ;
100: ; Prepare the Rle routine to exit. Set the EGA/VGA to default write
101: ; mode. Save the current status in the RleInfo so we can continue
102: ; from where we left off if a complex clipping is encountered.
103: ;
104: ; Entry:
105: ; ESI = pointer pass the first run above the clipping rect
106: ; EBX = yCurr(y value of the first run above the clipping rect)
107: ; ECX = xCurr(x value of the first run above the clipping rect)
108: ; Returns:
109: ; None
110: ;
111: ;-----------------------------------------------------------------------;
112:
113: RleExit macro
114:
115: mov dx,VGA_BASE + GRAF_ADDR
116: mov ax,(M_PROC_WRITE shl 8) + GRAF_MODE
117: out dx,ax
118:
119: mov ax,0FF00h + GRAF_BIT_MASK
120: out dx,ax ;no mask
121:
122: mov edi,pRleInfo ;update for next call
123: dec esi
124: dec esi
125: mov [edi].RLE_pjSrcBits,esi
126: mov esi,[edi].RLE_prctlTrg
127: inc ebx ;make it exclusive
128: mov [esi].yBottom,ebx
129: mov eax,pjDst
130: mov [edi].RLE_pjTrg,eax
131: mov [edi].RLE_xBegin,ecx
132: endm
133:
134: ;-------------------------------Macro-----------------------------------;
135: ; Clip_Encoded
136: ;
137: ; Clip the current run in encoded mode against the clipping rect.
138: ;
139: ; Entry:
140: ; AH = pel color of this run
141: ; AL = number of pels of this run
142: ; Returns:
143: ; EAX = left coordinate if no clipping
144: ; ECX = left coordinate of the clipped run
145: ; EBX = right coordinate of the clipped run
146: ;
147: ;-----------------------------------------------------------------------;
148:
149: Clip_Encoded macro done, loop_start
150:
151: movzx edx,ah ;EDX = pel color
152: movzx eax,al ;EAX = number of pels
153: mov ecx,xCurr ;ECX = left coordinate
154: add xCurr,eax ;compute new x position
155: mov ebx,yCurr
156:
157: ; Check if y is inside the clipping range.
158:
159: mov edi,prclClip
160: cmp ebx,[edi].yTop
161: jb done
162: cmp ebx,[edi].yBottom
163: jae short loop_start
164:
165: ; Clip to the passed in clip rectangle.
166:
167: mov eax,ecx
168: cmp ecx,[edi].xLeft
169: jae short @F
170: mov ecx,[edi].xLeft
171:
172: @@:
173: mov ebx,xCurr
174: cmp ebx,[edi].xRight
175: jbe short @F
176: mov ebx,[edi].xRight
177:
178: @@:
179: cmp ebx,ecx ;clipped out if left and right crossed
180: jbe short loop_start
181: endm
182:
183: ;-------------------------------Macro-----------------------------------;
184: ; Draw_Encoded
185: ;
186: ; Write the current encoded run to the EGA/VGA.
187: ;
188: ; Entry:
189: ; EBX = right coordinate (exclusive)
190: ; ECX = left coordinate (inclusive)
191: ; EDX = pel color
192: ; Returns:
193: ; None
194: ;
195: ;-----------------------------------------------------------------------;
196:
197: Draw_Encoded macro loop_start
198:
199: call comp_masks ;compute bit masks
200:
201: shl eax,8 ;save right mask in high word
202: add edi,pjDst
203:
204: mov ebx,pulXlate
205: mov ebx,[ebx][edx*4]
206:
207: mov dx,VGA_BASE + GRAF_ADDR
208:
209: or ah,ah ;AH = left mask
210: jz short @F
211:
212: mov al,GRAF_BIT_MASK ;Set bitmask for altered bits
213: out dx,ax
214:
215: mov al,bl ;write color
216: xchg [edi],al
217: inc edi ;update destination pointer
218:
219: @@:
220: or ecx,ecx ;ECX = inner loop count
221: jz short @F
222:
223: mov ax,0FF00h + GRAF_BIT_MASK
224: out dx,ax ;no mask
225:
226: mov al,bl
227: rep stosb ;write color
228:
229: @@:
230: shr eax,8 ;AH = right mask
231: or ah,ah
232: jz loop_start
233:
234: mov al,GRAF_BIT_MASK ;Set bitmask for altered bits
235: out dx,ax
236: xchg [edi],bl ;write color
237:
238: jmp loop_start
239: endm
240:
241: ;-------------------------------Macro-----------------------------------;
242: ; Clip_Absolute
243: ;
244: ; Clip the current run in absolute mode against the clipping rect.
245: ; Compute initial bit mask and other vars for subsequent loop.
246: ;
247: ; Entry:
248: ; AH = number of pels of this run
249: ; Returns:
250: ; AL = GRAF_BIT_MASK
251: ; AH = bitmap for the first pel
252: ; EBX = pulXlate (pointer to the xlate table)
253: ; CH = 01000001b
254: ; EDI = pointer to destination byte to be altered
255: ; loop_count = loop count (number of pels to be altered)
256: ;
257: ;-----------------------------------------------------------------------;
258:
259: Clip_Absolute macro done,loop_end,loop_count
260:
261: movzx eax,ah ;EAX = number of pels
262: mov ecx,xCurr ;ECX = left coordinate
263: add xCurr,eax
264:
265: mov ebx,yCurr
266:
267: ; Check if y is inside the clipping range.
268:
269: mov edi,prclClip
270: cmp ebx,[edi].yTop
271: jb done
272: cmp ebx,[edi].yBottom
273: jae loop_end
274:
275: ; Check if x is inside the clipping range.
276:
277: cmp ecx,[edi].xRight ;check if x is in range
278: jae loop_end
279:
280: mov ebx,xCurr ;EBX = right coordinate
281: cmp ebx,[edi].xLeft ;can I not jump???!!!
282: jbe loop_end
283:
284: ; Clip to the passed in clip rectangle.
285:
286: cmp ecx,[edi].xLeft
287: mov cPreSrcAdv,0
288: jae short @F
289: mov eax,[edi].xLeft
290: sub eax,ecx ;diff of left coor and prclClip->xLeft
291: mov cPreSrcAdv,eax
292: add ecx,eax ;ECX = left coordinate = prclClip->xLeft
293:
294: @@:
295: xor eax,eax ;diff of right coor and prclClip->xRight
296: cmp ebx,[edi].xRight
297: jbe short @F
298: mov eax,ebx
299: mov ebx,[edi].xRight ;EBX = right coor = prclClip->xRight
300: sub eax,ebx
301:
302: @@:
303: mov cPostSrcAdv,eax
304: sub ebx,ecx ;loop count
305:
306: mov edi,ecx
307: shr edi,3
308: add edi,pjDst ;point to the first byte to write
309:
310: and ecx,00000111b ;Compute bit index for left side
311: mov ah,080h ;Compute bit mask
312: shr ah,cl ;AL = first pel bit mask
313: mov al,GRAF_BIT_MASK
314: mov loop_count,bl ;loop count < 0FFh
315: mov ch,01000001b ;for later use
316: mov ebx,pulXlate
317: endm
318:
319: ;-------------------------------Macro-----------------------------------;
320: ; RleEOL
321: ;
322: ; Handle the End of line case.
323: ;
324: ; Entry:
325: ; None.
326: ; Returns:
327: ; None.
328: ;
329: ;-----------------------------------------------------------------------;
330:
331: RleEOL macro loop_start
332:
333: mov eax,lNextScan
334: sub pjDst,eax ;adjust pjDst
335: dec yCurr ;adjust yCurr
336: mov eax,xStart ;adjust xCurr
337: mov xCurr,eax
338: jmp loop_start
339: endm
340:
341:
342: ;-------------------------------Macro-----------------------------------;
343: ; Set up banking-related variables, and make sure the bank for the
344: ; initial (bottom) scan line is mapped in.
345: ;
346: ; Entry:
347: ; None.
348: ; Returns:
349: ; EBX = pdsurf
350: ; ESI = pRleInfo
351: ; EDI = RLE_prctlClip
352: ;
353: ;-------------------------------Macro-----------------------------------;
354:
355: RleBankSetUp macro
356: local map_bank,bank_mapped
357:
358: mov esi,pRleInfo
359: mov ebx,[esi].Rle_pdsurfTrg
360: mov pdsurf,ebx
361:
362: mov eax,[ebx].dsurf_lNextScan
363: mov lNextScan,eax
364:
365: mov edi,[esi].RLE_prctlClip
366: mov eax,[edi].yTop
367: mov ulTrueClipTop,eax ;we blt until we reach this scan line
368:
369: ; Map in the bottom scan line of the clip rect.
370:
371: mov eax,[edi].yBottom ;bottom clip scan, exclusive
372: dec eax ;make it inclusive
373: cmp eax,[ebx].dsurf_rcl1WindowClip.yTop
374: jl short map_bank
375: cmp eax,[ebx].dsurf_rcl1WindowClip.yBottom
376: jl short bank_mapped
377: map_bank:
378: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,eax,JustifyBottom>
379: bank_mapped:
380:
381: endm
382:
383:
384: ;-------------------------------Macro-----------------------------------;
385: ; Set up the screen pointer and clip the clip rect to the current bank.
386: ;
387: ; Entry:
388: ; EBX = pdsurf
389: ; ESI = pRleInfo
390: ; EDI = RLE_prctlClip
391: ; Returns:
392: ; None.
393: ;
394: ;-------------------------------Macro-----------------------------------;
395:
396: RleBankTop macro
397:
398: ; Convert the screen pointer from an offset within the bitmap to a virtual
399: ; address.
400:
401: mov eax,[ebx].dsurf_pvBitmapStart
402: add [esi].RLE_pjTrg,eax
403:
404: ; Set the clip rect top to MAX(top_of_bank,top_of_clip), to confine drawing to
405: ; this bank.
406:
407: mov eax,[ebx].dsurf_rcl1WindowClip.yTop
408: cmp ulTrueClipTop,eax
409: jl short @F
410: mov eax,ulTrueClipTop
411: @@:
412: mov [edi].yTop,eax
413:
414: endm
415:
416:
417: ;-------------------------------Macro-----------------------------------;
418: ; Check whether we've done the last bank spanned by this clip rect; exit
419: ; if so, map in the bank and continue if not.
420: ;
421: ; Entry:
422: ; None.
423: ; Returns:
424: ; EBX = pdsurf
425: ; ESI = pRleInfo
426: ; EDI = RLE_prctlClip
427: ;
428: ;-------------------------------Macro-----------------------------------;
429:
430: RleBankBottom macro loop_top,done
431:
432: ; Convert the screen pointer back to an offset within the bitmap.
433:
434: mov ebx,pdsurf
435: mov esi,pRleInfo
436: mov eax,[ebx].dsurf_pvBitmapStart
437: sub [esi].RLE_pjTrg,eax
438:
439: ; Have we reached the top bank involved in this blt? If so, done; if not, map
440: ; it in and blt the next bank.
441:
442: mov eax,[ebx].dsurf_rcl1WindowClip.yTop
443: cmp eax,ulTrueClipTop
444: jle &done
445: dec eax ;map in the bank above the current one
446: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,eax,JustifyBottom>
447:
448: mov edi,[esi].RLE_prctlClip ;for RleBankTop
449:
450: jmp &loop_top
451:
452: endm
453:
454:
455: ;--------------------------Public-Routine-------------------------------;
456: ; vRle8ToVga
457: ;
458: ; Write an RLE8 bitmap onto the VGA device.
459: ;
460: ; Entry:
461: ; None.
462: ; Returns:
463: ; None
464: ;
465: ;-----------------------------------------------------------------------;
466:
467: cProc vRle8ToVga,4,< \
468: uses esi edi ebx, \
469: pRleInfo: ptr RLEINFO >
470:
471: local pjDst :ptr
472: local pulXlate :ptr
473: local xCurr :dword
474: local yCurr :dword
475: local xStart :dword
476: local cPreSrcAdv :dword
477: local cPostSrcAdv :dword
478: local prclClip :ptr RECTL
479: local pjSrcEnd :ptr
480: local pdsurf :ptr DEVSURF
481: local ulTrueClipTop :dword
482: local lNextScan : dword
483:
484: RleBankSetUp ;wrap a banking loop around everything
485:
486: rle8_bank_loop:
487:
488: RleBankTop
489:
490: RleSetUp
491:
492: rle8_loop:
493: cmp esi,pjSrcEnd
494: jae rle8_done
495: lodsw ;fetch a word from src RLE bitmap
496:
497: or al,al
498: jz rle8_escape
499:
500: rle8_encoded:
501: Clip_Encoded rle8_done,rle8_loop
502: Draw_Encoded rle8_loop
503:
504: rle8_escape:
505: cmp ah,2 ; First byte is 0, check the second byte.
506: ja short rle8_absolute
507: jb rle8_end_of_line_or_bitmap
508:
509: rle8_delta:
510: RleDelta rle8_loop
511:
512: rle8_absolute:
513: Clip_Absolute rle8_done,rle8_absolute_advance_src,cl
514: add esi,cPreSrcAdv ;advance esi to point to the clipped run
515:
516: ; I am doing a per pel loop rather than a per byte loop which writes 1 plane
517: ; at a time because it appears to me that most of the time we output 2 or
518: ; 3 pels per encounter of absolute mode. The logic here is simple and we can
519: ; stay with M_COLOR_WRITE mode all the time.
520:
521: rle8_absolute_loop:
522: mov dx,VGA_BASE + GRAF_ADDR
523: out dx,ax ;Set bitmask for altered bit
524:
525: movzx edx,byte ptr [esi] ;grab color for this pel
526: inc esi
527:
528: mov edx,[ebx][edx*4]
529: xchg [edi],dl ;write to destination
530:
531: ror ah,1 ;rotate bit mask for next pel
532: cmp ch,ah ;cmp bitmask with 01000001b
533: adc edi,0 ;advance edi if bitmask is 10000000b
534:
535: dec cl ;per pel loop
536: jnz short rle8_absolute_loop
537: mov eax,cPostSrcAdv
538:
539: rle8_absolute_advance_src:
540: add esi,eax ;advance src ptr for clipped out pels
541: bt esi,0 ;add 1 if not word aligned
542: adc esi,0
543: jmp rle8_loop
544:
545: rle8_end_of_line_or_bitmap:
546: or ah,ah
547: jnz short rle8_end_of_bitmap
548:
549: rle8_end_of_line:
550:
551: RleEOL rle8_loop
552:
553: rle8_done:
554: RleExit
555:
556: RleBankBottom rle8_bank_loop,rle8_exit ;see if there are more banks
557: ; to do
558: align 4
559: rle8_end_of_bitmap:
560: RleExit
561: rle8_exit:
562: cRet vRle8ToVga
563:
564: endProc vRle8ToVga
565:
566:
567: ;--------------------------Public-Routine-------------------------------;
568: ; vRle4ToVga
569: ;
570: ; Write an RLE4 bitmap onto the VGA device.
571: ;
572: ; Entry:
573: ; None
574: ; Returns:
575: ; None
576: ;
577: ;-----------------------------------------------------------------------;
578:
579: cProc vRle4ToVga,4,< \
580: uses esi edi ebx, \
581: pRleInfo: ptr RLEINFO >
582:
583: local pjDst :ptr
584: local pulXlate :ptr
585: local xCurr :dword
586: local yCurr :dword
587: local xStart :dword
588: local cPreSrcAdv :dword
589: local cPostSrcAdv :dword
590: local pjDstStart :ptr
591: local iPels :dword
592: local xMask :dword
593: local nPels :byte
594: local prclClip :ptr RECTL
595: local pjSrcEnd :ptr
596: local pdsurf :ptr DEVSURF
597: local ulTrueClipTop :dword
598: local lNextScan : dword
599:
600: RleBankSetUp ;wrap a banking loop around everything
601:
602: rle4_bank_loop:
603:
604: RleBankTop
605:
606: RleSetUp
607:
608: rle4_loop:
609: cmp esi,pjSrcEnd
610: jae rle4_done
611: lodsw ;fetch a word
612:
613: or al,al
614: jz rle4_escape
615:
616: rle4_encoded:
617: Clip_Encoded rle4_done,rle4_loop
618:
619: mov dh,dl ;separate two colors into dl, dh
620: and dl,0Fh
621: shr dh,4
622: cmp dh,dl
623: jnz short encoded_diff_color
624: xor dh,dh ;Draw_Encoded use edx as color index
625: Draw_Encoded rle4_loop
626:
627: encoded_diff_color:
628: sub eax,ecx ;-eax = #pels clipped away
629: bt eax,0
630: jnc short @F
631: xchg dl,dh ;xchg colors if odd #pels clipped
632: @@:
633: mov iPels,edx ;save color index
634: sub ebx,ecx ;Compute extent of interval
635: dec ebx ;Make interval inclusive
636: mov edi,ecx ;Don't destroy starting X
637: shr edi,3 ;/8 for byte address
638: add edi,pjDst
639:
640: and ecx,00000111b ;Compute bit index for first byte
641: mov eax,00AAAAAAh ;Compute altered bits mask
642: shr eax,cl ;AL = left side altered bytes mask
643:
644: add ebx,ecx ;Compute bit index for last byte
645: mov ecx,ebx ;(save for inner loop count)
646: and ecx,00000111b
647: mov ch,80h
648: sar ch,cl
649: and al,ch ;AL = last byte altered bits mask
650:
651: mov edx,eax
652: shr edx,1
653: and dl,ch ;EDX = mask for 2nd pel
654:
655: mov ecx,ebx
656: shr ecx,3 ;Compute inner byte count
657: jnz short comp_byte_dont_combine ;loop count + 1 > 0, check it out
658:
659: ; Only one byte will be affected. Combine first/last masks, set loop count = 0
660:
661: mov ebx,eax
662: shl eax,16 ;Will use first byte mask only
663: and eax,ebx ;AH = first mask. Rest of the bits = 0
664:
665: mov ebx,edx
666: shl edx,16 ;Will use first byte mask only
667: and edx,ebx ;DH = first mask. Rest of the bits = 0
668: inc ecx ;Fall through to set 0
669:
670: comp_byte_dont_combine:
671: dec ecx ;Dec inner loop count (might become 0)
672:
673: xchg al,ah
674: ror eax,16 ;EAX = last mask:inter mask:first mask:0
675: xchg al,ah ;for first pel
676: xchg dl,dh
677: ror edx,16 ;EDX = last mask:inter mask:first mask:0
678: xchg dl,dh ;for second pel
679:
680: mov pjDstStart,edi
681: mov xMask,edx ;save mask for the 2nd round
682:
683: mov ebx,pulXlate
684: mov edx,iPels
685: shr edx,8 ;index for the first pel
686: mov ebx,[ebx][edx*4]
687: inc bh ;BH = rle4_encoded_diff_color_loop count
688: inc bh
689: mov dx,VGA_BASE + GRAF_ADDR
690: ;BL = color for first pel
691: rle4_encoded_diff_color_loop:
692: or ah,ah ;AH = first mask
693: jz short encoded_inner_diff_color
694:
695: mov al,GRAF_BIT_MASK ;Set bitmask for altered bits
696: out dx,ax
697:
698: mov al,bl
699: xchg [edi],al ;write color
700: encoded_inner_diff_color:
701: inc edi ;update destination pointer
702: shr eax,8 ;AH = internal mask
703: or cl,cl ;ECX = inner loop count
704: jz short encoded_last_byte_diff_color
705:
706: mov ch,cl ;save loop count in ch
707: ;loop count always fit in a byte
708: mov al,GRAF_BIT_MASK
709: out dx,ax ;no mask
710:
711: encoded_loop_diff_color:
712: mov al,bl
713: xchg [edi],al ;write color
714: inc edi
715: dec cl
716: jnz encoded_loop_diff_color
717:
718: encoded_last_byte_diff_color:
719: shr eax,8 ;AH = last mask
720: or ah,ah
721: jz encoded_this_run_maybe_done
722:
723: mov al,GRAF_BIT_MASK ;Set bitmask for altered bits
724: out dx,ax
725:
726: encoded_write:
727: xchg [edi],bl ;write color
728:
729: encoded_this_run_maybe_done:
730: dec bh
731: jz rle4_loop
732:
733: mov edi,pulXlate
734: mov eax,iPels ;index of the second pel
735: xor ah,ah
736: mov bl,byte ptr [edi][eax*4]
737: mov edi,pjDstStart
738: mov eax,xMask ;load mask
739: mov cl,ch ;loop count
740:
741: jmp rle4_encoded_diff_color_loop
742:
743: rle4_escape:
744: cmp ah,2 ; First byte is 0, check the second byte.
745: ja rle4_absolute
746: jb rle4_end_of_line_or_bitmap
747:
748: rle4_delta:
749:
750: RleDelta rle4_loop
751:
752: rle4_absolute:
753: Clip_Absolute rle4_done,rle4_absolute_advance_src,nPels
754:
755: ;advance esi to point to the clipped run
756:
757: mov edx,cPreSrcAdv ;number of pels to advance
758: shr edx,1 ;number of bytes
759: jnc @F
760:
761: add esi,edx ;odd number of pels to advance
762: movzx edx,byte ptr [esi] ;grab color for prev and this pels
763: inc esi
764: mov iPels,edx
765:
766: inc nPels ;inc loop count since we start from 1
767: mov cl,1
768: jmp short absolute_loop
769:
770: @@: ;even number of pels to advance
771: add esi,edx
772:
773: ; I am doing a per pel loop rather than a per byte loop which writes 1 plane
774: ; at a time because it appears to me that most of the time we output 2 or
775: ; 3 pels per encounter of absolute mode. The logic here is simple and we can
776: ; stay with M_COLOR_WRITE mode all the time.
777:
778: xor cl,cl ;initialize loop count
779:
780: absolute_loop:
781: mov dx,VGA_BASE + GRAF_ADDR
782: out dx,ax ;Set bitmask for altered bit
783:
784: bt cl,0
785: jc @F
786:
787: movzx edx,byte ptr [esi] ;grab color for this and next pels
788: inc esi
789:
790: mov iPels,edx ;save for next pel
791: shr dl,4
792: jmp short ready_to_draw
793: @@:
794: mov edx,iPels ;second pel
795: and dl,0Fh ;mask out the second pel
796:
797: ready_to_draw:
798: mov edx,[ebx][edx*4] ;look up for VGA color
799: xchg [edi],dl ;write to destination
800:
801: ror ah,1 ;rotate bit mask for next pel
802: cmp ch,ah ;cmp bitmask with 01000001b
803: adc edi,0 ;advance edi if bitmask is 10000000b
804:
805: inc cl
806: cmp cl,nPels
807: jnz short absolute_loop
808:
809: mov eax,cPostSrcAdv
810:
811: rle4_absolute_advance_src:
812: shr eax,1 ;2 pels for one byte
813: add esi,eax ;advance src ptr for clipped out pels
814: bt esi,0 ;add 1 if not word aligned
815: adc esi,0
816: jmp rle4_loop
817:
818:
819: rle4_end_of_line_or_bitmap:
820: or ah,ah
821: jnz short rle4_end_of_bitmap
822:
823: rle4_end_of_line:
824: RleEOL rle4_loop
825:
826: rle4_done:
827: RleExit
828:
829: RleBankBottom rle4_bank_loop,rle4_exit ;see if there are more banks
830: ; to do
831: align 4
832: rle4_end_of_bitmap:
833: RleExit
834: rle4_exit:
835: cRet vRle4ToVga
836:
837: endProc vRle4ToVga
838:
839: ;--------------------------Private-Routine------------------------------;
840: ; comp_byte_interval
841: ;
842: ; An interval will be computed for byte boundaries.
843: ;
844: ; A first mask and a last mask will be calculated, and possibly
845: ; combined into the inner loop count. If no first byte exists,
846: ; the start address will be incremented to adjust for it.
847: ;
848: ; Entry:
849: ; EBX = right coordinate (exclusive)
850: ; ECX = left coordinate (inclusive)
851: ; Returns:
852: ; EDI = offset to first byte to be altered in the scan
853: ; ECX = inner loop count
854: ; AL = first byte mask (possibly 0)
855: ; AH = last byte mask (possibly 0)
856: ; Error Returns:
857: ; None
858: ; Registers Preserved:
859: ; ES,BP
860: ; Registers Destroyed:
861: ; AX,BX,CX,DI,FLAGS
862: ; Calls:
863: ; None
864: ;
865: ;-----------------------------------------------------------------------;
866:
867: comp_masks proc
868:
869: sub ebx,ecx ;Compute extent of interval
870: dec ebx ;Make interval inclusive
871: mov edi,ecx ;Don't destroy starting X
872: shr edi,3 ;/8 for byte address
873:
874: and ecx,00000111b ;Compute bit index for left side
875: mov al,0FFh ;Compute left side altered bits mask
876: shr al,cl ;AL = left side altered bytes mask
877:
878: add ebx,ecx ;Compute bit index for right side
879: mov ecx,ebx ;(save for inner loop count)
880: and ecx,00000111b
881: mov ah,80h
882: sar ah,cl ;AH = right side altered bits mask
883:
884: shr ebx,3 ;Compute inner byte count
885: jnz short comp_byte_dont_combine ;loop count + 1 > 0, check it out
886:
887: ; Only one byte will be affected. Combine first/last masks, set loop count = 0
888:
889: and al,ah ;Will use first byte mask only
890: xor ah,ah ;Want last byte mask to be 0
891: inc ebx ;Fall through to set 0
892:
893: comp_byte_dont_combine:
894: dec ebx ;Dec inner loop count (might become 0)
895:
896: ; If all pixels in the first byte are altered, combine the first byte into the
897: ; inner loop and clear the first byte mask. Ditto for the last byte mask.
898:
899: mov ecx,0FFFFFFFFh
900: cmp al,cl ;Set 'C' if not all pixels 1
901: sbb ebx,ecx ;If no 'C', sub -1 (add 1), else sub 0
902: cmp al,cl ;Set 'C' if not all pixels 1
903: sbb al,cl ;If no 'C', sub -1 (add 1), else sub 0
904:
905: cmp ah,cl ;Set 'C' if not all pixels 1
906: sbb ebx,ecx ;If no 'C', sub -1 (add 1), else sub 0
907: cmp ah,cl ;Set 'C' if not all pixels 1
908: sbb ah,cl ;If no 'C', sub -1 (add 1), else sub 0
909:
910: mov ecx,ebx ;Return inner loop count in ECX
911:
912: ret
913:
914: comp_masks endp
915:
916: end
917:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.