![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to brushes.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 brushes.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 root 1: .386
2:
3: ifndef DOS_PLATFORM
4: .model small,c
5: else
6: ifdef STD_CALL
7: .model small,c
8: else
9: .model small,pascal
10: endif; STD_CALL
11: endif; DOS_PLATFORM
12:
13: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
14: assume fs:nothing,gs:nothing
15:
16: .xlist
17: include stdcall.inc ;calling convention cmacros
18: include i386\egavga.inc
19: include i386\strucs.inc
20: include i386\ropdefs.inc
21: include i386\display.inc ; Display specific structures
22:
23: .list
24:
25: ;-----------------------------------------------------------------------;
26:
27: .data
28:
29: align 4
30: ifdef LATER
31: public CmpPlanes
32: CmpPlanes label dword
33: dd check_plane_1
34: dd check_plane_2
35: dd check_plane_3
36: dd 0
37: endif;LATER
38:
39: public pCountTable
40: pCountTable label dword
41: dd 1h
42: dd 2h
43: dd 4h
44: dd 8h
45: dd 10h
46: dd 20h
47: dd 40h
48: dd 80h
49: dd 100h
50: dd 200h
51: dd 400h
52: dd 800h
53: dd 1000h
54: dd 2000h
55: dd 4000h
56: dd 8000h
57:
58: align 4
59: public pPixelCount
60: pPixelCount label dword
61: dd 0 ;//0
62: dd 1 ;//1
63: dd 1 ;//2
64: dd 2 ;//3
65: dd 1 ;//4
66: dd 2 ;//5
67: dd 2 ;//6
68: dd 3 ;//7
69: dd 1 ;//8
70: dd 2 ;//9
71: dd 2 ;//10
72: dd 3 ;//11
73: dd 2 ;//12
74: dd 3 ;//13
75: dd 3 ;//14
76: dd 3 ;//15
77: dd 4 ;//16
78:
79: align 4
80: PackedToPlanar0 label dword
81: dd 0 ;//0
82: dd 00000001h ;//1
83: dd 00000100h ;//2
84: dd 00000101h ;//3
85: dd 00010000h ;//4
86: dd 00010001h ;//5
87: dd 00010100h ;//6
88: dd 00010101h ;//7
89: dd 01000000h ;//8
90: dd 01000001h ;//9
91: dd 01000100h ;//10
92: dd 01000101h ;//11
93: dd 01010000h ;//12
94: dd 01010001h ;//13
95: dd 01010100h ;//14
96: dd 01010101h ;//15
97:
98: align 4
99: PackedToPlanar1 label dword
100: dd 0 ;//0
101: dd (00000001h SHL 1) ;//1
102: dd (00000100h SHL 1) ;//2
103: dd (00000101h SHL 1) ;//3
104: dd (00010000h SHL 1) ;//4
105: dd (00010001h SHL 1) ;//5
106: dd (00010100h SHL 1) ;//6
107: dd (00010101h SHL 1) ;//7
108: dd (01000000h SHL 1) ;//8
109: dd (01000001h SHL 1) ;//9
110: dd (01000100h SHL 1) ;//10
111: dd (01000101h SHL 1) ;//11
112: dd (01010000h SHL 1) ;//12
113: dd (01010001h SHL 1) ;//13
114: dd (01010100h SHL 1) ;//14
115: dd (01010101h SHL 1) ;//15
116:
117: align 4
118: PackedToPlanar2 label dword
119: dd 0 ;//0
120: dd (00000001h SHL 2) ;//1
121: dd (00000100h SHL 2) ;//2
122: dd (00000101h SHL 2) ;//3
123: dd (00010000h SHL 2) ;//4
124: dd (00010001h SHL 2) ;//5
125: dd (00010100h SHL 2) ;//6
126: dd (00010101h SHL 2) ;//7
127: dd (01000000h SHL 2) ;//8
128: dd (01000001h SHL 2) ;//9
129: dd (01000100h SHL 2) ;//10
130: dd (01000101h SHL 2) ;//11
131: dd (01010000h SHL 2) ;//12
132: dd (01010001h SHL 2) ;//13
133: dd (01010100h SHL 2) ;//14
134: dd (01010101h SHL 2) ;//15
135:
136: align 4
137: PackedToPlanar3 label dword
138: dd 0 ;//0
139: dd (00000001h SHL 3) ;//1
140: dd (00000100h SHL 3) ;//2
141: dd (00000101h SHL 3) ;//3
142: dd (00010000h SHL 3) ;//4
143: dd (00010001h SHL 3) ;//5
144: dd (00010100h SHL 3) ;//6
145: dd (00010101h SHL 3) ;//7
146: dd (01000000h SHL 3) ;//8
147: dd (01000001h SHL 3) ;//9
148: dd (01000100h SHL 3) ;//10
149: dd (01000101h SHL 3) ;//11
150: dd (01010000h SHL 3) ;//12
151: dd (01010001h SHL 3) ;//13
152: dd (01010100h SHL 3) ;//14
153: dd (01010101h SHL 3) ;//15
154:
155: align 4
156: PackedToPlanar4 label dword
157: dd 0 ;//0
158: dd (00000001h SHL 4) ;//1
159: dd (00000100h SHL 4) ;//2
160: dd (00000101h SHL 4) ;//3
161: dd (00010000h SHL 4) ;//4
162: dd (00010001h SHL 4) ;//5
163: dd (00010100h SHL 4) ;//6
164: dd (00010101h SHL 4) ;//7
165: dd (01000000h SHL 4) ;//8
166: dd (01000001h SHL 4) ;//9
167: dd (01000100h SHL 4) ;//10
168: dd (01000101h SHL 4) ;//11
169: dd (01010000h SHL 4) ;//12
170: dd (01010001h SHL 4) ;//13
171: dd (01010100h SHL 4) ;//14
172: dd (01010101h SHL 4) ;//15
173:
174: align 4
175: PackedToPlanar5 label dword
176: dd 0 ;//0
177: dd (00000001h SHL 5) ;//1
178: dd (00000100h SHL 5) ;//2
179: dd (00000101h SHL 5) ;//3
180: dd (00010000h SHL 5) ;//4
181: dd (00010001h SHL 5) ;//5
182: dd (00010100h SHL 5) ;//6
183: dd (00010101h SHL 5) ;//7
184: dd (01000000h SHL 5) ;//8
185: dd (01000001h SHL 5) ;//9
186: dd (01000100h SHL 5) ;//10
187: dd (01000101h SHL 5) ;//11
188: dd (01010000h SHL 5) ;//12
189: dd (01010001h SHL 5) ;//13
190: dd (01010100h SHL 5) ;//14
191: dd (01010101h SHL 5) ;//15
192:
193: align 4
194: PackedToPlanar6 label dword
195: dd 0 ;//0
196: dd (00000001h SHL 6) ;//1
197: dd (00000100h SHL 6) ;//2
198: dd (00000101h SHL 6) ;//3
199: dd (00010000h SHL 6) ;//4
200: dd (00010001h SHL 6) ;//5
201: dd (00010100h SHL 6) ;//6
202: dd (00010101h SHL 6) ;//7
203: dd (01000000h SHL 6) ;//8
204: dd (01000001h SHL 6) ;//9
205: dd (01000100h SHL 6) ;//10
206: dd (01000101h SHL 6) ;//11
207: dd (01010000h SHL 6) ;//12
208: dd (01010001h SHL 6) ;//13
209: dd (01010100h SHL 6) ;//14
210: dd (01010101h SHL 6) ;//15
211:
212: align 4
213: PackedToPlanar7 label dword
214: dd 0 ;//0
215: dd (00000001h SHL 7) ;//1
216: dd (00000100h SHL 7) ;//2
217: dd (00000101h SHL 7) ;//3
218: dd (00010000h SHL 7) ;//4
219: dd (00010001h SHL 7) ;//5
220: dd (00010100h SHL 7) ;//6
221: dd (00010101h SHL 7) ;//7
222: dd (01000000h SHL 7) ;//8
223: dd (01000001h SHL 7) ;//9
224: dd (01000100h SHL 7) ;//10
225: dd (01000101h SHL 7) ;//11
226: dd (01010000h SHL 7) ;//12
227: dd (01010001h SHL 7) ;//13
228: dd (01010100h SHL 7) ;//14
229: dd (01010101h SHL 7) ;//15
230:
231:
232:
233: .code
234:
235: ;==============================================================================
236: ; CountColors(pBuffer, Count)
237: ;
238: ; This routine will count the number of unique colors in a packed pel 4bpp
239: ; bitmap. The total number of colors is returned.
240: ;
241: ;==============================================================================
242:
243: _TEXT$03 SEGMENT DWORD USE32 PUBLIC 'CODE'
244: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
245:
246: cProc CountColors,16,< \
247: uses esi edi ebx, \
248: pBuffer: ptr dword, \
249: count:dword, \
250: pColors: ptr dword, \
251: cbScan: dword >
252:
253: ; This could be much faster. This routine really only needs to
254: ; find out if there are two colors and return those two colors.
255: ; If there are more, we can just return.
256:
257: mov ecx,8
258: mov esi,pBuffer
259: lea edi,pCountTable
260: xor edx,edx
261:
262:
263: @@: mov ebx,[esi] ; read in a dword of the bitmap
264:
265: rept 7
266:
267: mov eax,ebx ;copy colors to eax
268: and eax,0fh ;isolate nibble
269: shr ebx,4 ;remove current nibble from ebx
270: or edx,[edi+eax*4] ;or color count flags into edx
271: endm ;-----------------------
272:
273: or edx,[edi+ebx*4] ;do last nibble
274:
275: cmp count,16 ;if this is 16x8 we need to
276: jne short continue_count ; process the second dword on this
277: ; scan.
278:
279: rept 7
280:
281: mov ebx,[esi+4] ;read second dword
282: mov eax,ebx ;copy colors to eax
283: and eax,0fh ;isolate nibble
284: shr ebx,4 ;remove current nibble from ebx
285: or edx,[edi+eax*4] ;or color count flags into edx
286: endm ;-----------------------
287:
288: or edx,[edi+ebx*4] ;do last nibble
289: continue_count:
290: add esi,cbScan
291: dec ecx ;do next dword
292: jnz @b
293:
294: ; Now count the number of bits on in each nibble
295:
296: mov ecx,edx ;save bit mask
297: mov ebx,edx
298: shr edx,4
299: and ebx,0fh
300: mov eax,pPixelCount[ebx*4]
301:
302: mov ebx,edx
303: shr edx,4
304: and ebx,0fh
305: add eax,pPixelCount[ebx*4]
306:
307: mov ebx,edx
308: shr edx,4
309: and ebx,0fh
310: add eax,pPixelCount[ebx*4]
311:
312: add eax,pPixelCount[edx*4]
313:
314: cmp eax,2
315: jne short cc_exit
316:
317: mov al,16
318:
319: @@: dec al
320: add cx,cx
321: jnc @b
322: mov ah,al
323:
324: @@: dec al
325: add cx,cx
326: jnc @b
327:
328: mov edi,pColors
329: mov [edi],ax
330: mov ax,2
331: cc_exit:
332: cRet CountColors
333:
334: endProc CountColors
335:
336: ;==============================================================================
337: ; bQuickPattern
338: ;
339: ; We special case patterns that are repeating two line patterns (like the
340: ; grey/hatch brush). This allows us to do two passes instead of eight in the
341: ; venetian blind patblt code.
342: ;
343: ;==============================================================================
344:
345: cProc bQuickPattern,8,< \
346: uses edi, \
347: pBuffer: ptr dword, \
348: count:dword >
349:
350: ; Count must be 8 or 16;
351:
352: xor eax,eax ;Set ret value to false
353: mov edi,pBuffer ;get pointer to pattern
354: mov edx,[edi] ;Get first dword (first two lines of pattern)
355: mov ecx,count ;dword count
356:
357: qp_loop:
358: INDEX=4
359: rept 7
360: cmp edx,[edi+INDEX]
361: jne short qp_exit
362: INDEX=INDEX+4
363: endm ;----------------------
364:
365: sub ecx,8
366: jz exit_true
367:
368: add edi,32
369: cmp edx,[edi]
370: jne short qp_exit
371: jmp short qp_loop
372:
373: exit_true:
374: inc eax
375: qp_exit:
376: cRet bQuickPattern
377: endProc bQuickPattern
378:
379: _TEXT$03 ends
380:
381: .code
382:
383: ;==============================================================================
384: ; bShrinkPattern
385: ;
386: ; Test to see if we can shrink an 16x8 pattern to an 8x8 pattern.
387: ;
388: ;==============================================================================
389:
390: cProc bShrinkPattern,8,< \
391: uses edi, \
392: pBuffer: ptr dword, \
393: cbScan:dword >
394:
395: xor eax,eax
396: mov ecx,cbScan
397: mov edi,pBuffer ;get pointer to pattern
398:
399: rept 8
400: mov edx,[edi]
401: cmp edx,[edi+4]
402: jne @f
403: add edi,ecx
404: endm ;---------------
405:
406: inc eax
407: @@:
408:
409: cRet bShrinkPattern
410: endProc bShrinkPattern
411:
412: ;==============================================================================
413: ;vMono8Wide
414: ;
415: ; Copies an 8x8 pattern to a 16x16 buffer
416: ;
417: ;==============================================================================
418:
419: _TEXT$04 SEGMENT DWORD USE32 PUBLIC 'CODE'
420: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
421:
422: cProc vMono8Wide,12,< \
423: uses ebx edi esi, \
424: pDest: ptr dword, \
425: pBuffer: ptr dword, \
426: cbScan:ptr dword >
427:
428: mov edi,pDest ;Load up edi with our dest
429: mov esi,pBuffer ;load esi with the source
430: mov ebx,cbScan ;dest line delta
431:
432: rept 8
433:
434: mov al,[esi] ;Read in first line of pattern
435: add esi,ebx ;inc dest pointer
436: mov ah,al ;make pattern 16 wide
437: mov [edi],ax ;write first line of pattern
438: add edi,2
439: endm ;----------------------
440:
441: cRet vMono8Wide
442: endProc vMono8Wide
443:
444: _TEXT$04 ends
445:
446: .code
447:
448: ;==============================================================================
449: ;vMono16Wide
450: ;
451: ; Copies an 16x8 pattern to a 16x16 buffer
452: ;
453: ;==============================================================================
454:
455: cProc vMono16Wide,12,< \
456: uses ebx edi esi, \
457: pDest: ptr dword, \
458: pBuffer: ptr dword, \
459: cbScan:ptr dword >
460:
461: mov edi,pDest ;Load up edi with our dest
462: mov esi,pBuffer ;load esi with the source
463: mov ebx,cbScan ;dest line delta
464:
465: rept 8
466:
467: mov ax,[esi] ;Read in first line of pattern
468: add esi,ebx ;inc dest pointer
469: mov [edi],ax ;write first line of pattern
470: add edi,2
471:
472: endm ;----------------------
473:
474: cRet vMono16Wide
475: endProc vMono16Wide
476:
477: cProc vMono4Wide,12,< \
478: uses ebx edi esi, \
479: pDest: ptr dword, \
480: pBuffer: ptr dword, \
481: cbScan:ptr dword >
482:
483: nop
484:
485: cRet vMono4Wide
486: endProc vMono4Wide
487:
488: cProc vMono2Wide,12,< \
489: uses ebx edi esi, \
490: pDest: ptr dword, \
491: pBuffer: ptr dword, \
492: cbScan:ptr dword >
493:
494: nop
495:
496: cRet vMono2Wide
497: endProc vMono2Wide
498:
499: ;==============================================================================
500: ; Brush2ColorToMono
501: ;
502: ;
503: ;==============================================================================
504:
505: _TEXT$01 SEGMENT DWORD USE32 PUBLIC 'CODE'
506: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
507:
508: cProc vBrush2ColorToMono,20,< \
509: uses esi edi ebx, \
510: pDest: ptr dword, \
511: pSrc: ptr dword, \
512: cbScan: dword, \
513: ulWidth: dword, \
514: jColor: dword >
515:
516: local ulHeight : dword
517:
518: mov ulHeight,8
519:
520: ;This routine relies on this: It only works on an 8x8
521: ;two color 4bpp packed pel pattern. It creates a 1bpp bitmap
522: ;with the foreground color being the smaller of the two numbers.
523: ;This is key because the way we set the bit in the monochrome bmp
524: ;is by comparing the background color (the larger of the two colors)
525: ;with the current nibble. If this nibble contains the foreground
526: ;color (the smaller color) then a carry will result from the compare.
527: ;We then use adc ebx,ebx to set the lsb to zero or one depending on
528: ;the result of the compare and also to shift ebx left by one.
529:
530: mov ecx,jColor ;jColor is the larger of the two colors
531: mov ch,cl ;Save jcolor in cl for comparisions with the low
532: shl ch,4 ;nibble and ch for the high nibble
533:
534: mov edi,pDest ;Load Dest
535: mov esi,pSrc ;Load Src
536: mov edx,cbScan
537:
538: cmp ulWidth,8
539: jnz do_16_wide
540:
541: x8_wide_loop:
542: SRCINDEX=0
543: xor ebx,ebx ;clear out place where we store the dest byte.
544: rept 4
545: mov al,[esi+SRCINDEX] ;get src byte
546: cmp al,ch ;Is the top nibble fg or bk?
547: adc ebx,ebx ;carry will be set if fg. Set bit in mask
548: and al,0fh ;mask off high nibble
549: cmp al,cl ;Is the bottom nibble fg or bk?
550: adc ebx,ebx ;carry will be set if fg. Set bit in mask
551: SRCINDEX=SRCINDEX+1
552: endm ;------------------
553: add esi,edx ;increment src to next line
554:
555: mov [edi],bl ;Write out first byte (8 Pixels)
556: mov [edi+1],bl ;We expand this to 16 pixels
557: add edi,2
558:
559: dec ulHeight
560: jnz x8_wide_loop
561: jmp convert_exit
562:
563:
564: do_16_wide:
565: x16_wide_loop:
566: xor ebx,ebx ;clear out place where we store the dest byte.
567:
568: SRCINDEX=0
569: rept 4
570: mov al,[esi+SRCINDEX] ;get src byte
571: cmp al,ch ;Is the top nibble fg or bk?
572: adc ebx,ebx ;carry will be set if fg. Set bit in mask
573: and al,0fh ;mask off high nibble
574: cmp al,cl ;Is the bottom nibble fg or bk?
575: adc ebx,ebx ;carry will be set if fg. Set bit in mask
576: SRCINDEX=SRCINDEX+1
577: endm ;------------------
578:
579: mov [edi],bl ;Write out first byte (8 Pixels)
580: inc edi
581: xor ebx,ebx ;clear out place where we store the dest byte.
582:
583: rept 4
584: mov al,[esi+SRCINDEX] ;get src byte
585: cmp al,ch ;Is the top nibble fg or bk?
586: adc ebx,ebx ;carry will be set if fg. Set bit in mask
587: and al,0fh ;mask off high nibble
588: cmp al,cl ;Is the bottom nibble fg or bk?
589: adc ebx,ebx ;carry will be set if fg. Set bit in mask
590: SRCINDEX=SRCINDEX+1
591: endm ;------------------
592:
593: add esi,edx ;increment src to next line
594: mov [edi],bl ;Write out Second byte (8 Pixels)
595: inc edi
596: dec ulHeight
597: jnz x16_wide_loop
598: convert_exit:
599: cRet vBrush2ColorToMono
600: endProc vBrush2ColorToMono
601:
602:
603: ;==============================================================================
604: ; vConvert4BppToPlanar
605: ;
606: ;
607: ;==============================================================================
608:
609: cProc vConvert4BppToPlanar,16,< \
610: uses esi edi ebx, \
611: pDest: ptr dword, \
612: pSrc: ptr dword, \
613: cbScan: dword, \
614: pulXlate: ptr dword >
615:
616: local ulHeight : dword
617:
618: xor eax,eax
619: mov esi,pSrc
620: mov edi,pDest
621:
622: mov edx,pulXlate
623: or edx,edx
624: jz do_convert4toplanar
625:
626: mov ulHeight,8
627: convert4xlate:
628: mov ebx,[esi] ;Get 8 4bpp pixels
629: and ebx,0f0f0f0fh ;Mask off the high nibbles
630: shl ebx,2 ;multiply by four (size of dword)
631: mov al,bl ;move into eax to use an index
632: mov eax,[edx][eax] ;xlate color
633: mov ecx,PackedToPlanar6[eax*4] ;build planar bytes
634: mov al,bh ;move into eax to use an index
635: shr ebx,16 ;get access to high word
636: mov eax,[edx][eax] ;xlate color
637: or ecx,PackedToPlanar4[eax*4] ;build planar bytes
638: mov al,bl ;move into eax to use an index
639: mov eax,[edx][eax] ;xlate color
640: or ecx,PackedToPlanar2[eax*4] ;build planar bytes
641: mov al,bh ;move into eax to use an index
642: mov eax,[edx][eax] ;xlate color
643: or ecx,PackedToPlanar0[eax*4] ;build planar bytes
644:
645: mov ebx,[esi] ;Get same dword again so we
646: add esi,cbScan ; can do the high nibbles
647:
648: and ebx,0f0f0f0f0h ;Mask off the low nibbles
649: shr ebx,2 ;shift into low nible and
650: ;multiply by four ((>> 4) << 2)
651:
652: mov al,bl ;move into eax to use an index
653: mov eax,[edx][eax] ;xlate color
654: or ecx,PackedToPlanar7[eax*4] ;build planar bytes
655: mov al,bh ;move into eax to use an index
656: shr ebx,16 ;get access to high word
657: mov eax,[edx][eax] ;xlate color
658: or ecx,PackedToPlanar5[eax*4] ;build planar bytes
659: mov al,bl ;move into eax to use an index
660: mov eax,[edx][eax] ;xlate color
661: or ecx,PackedToPlanar3[eax*4] ;build planar bytes
662: mov al,bh ;move into eax to use an index
663: mov eax,[edx][eax] ;xlate color
664: or ecx,PackedToPlanar1[eax*4] ;build planar bytes
665:
666: mov [edi],cl ;Write the bytes out in planar
667: mov [edi+8],ch ;format. We have to store them
668: shr ecx,16 ;this way because this is how
669: mov [edi+16],cl ;the blt compiler expects it.
670: mov [edi+24],ch
671: add edi,1 ;increment dest pointer
672:
673: dec ulHeight ;Check height
674: jnz convert4xlate ;do next line
675: jmp short convert4exit ;exit
676:
677: do_convert4toplanar:
678: mov edx,8
679:
680: convert4toplanar:
681: mov ebx,[esi] ;Get 8 4bpp pixels
682: and ebx,0f0f0f0fh ;Mask off the high nibbles
683: shl ebx,2 ;multiply by four each nibble
684: ; by four (size of dword)
685: mov al,bl ;move into eax to use an index
686: mov ecx,PackedToPlanar6[eax] ;build planar bytes
687: mov al,bh ;move into eax to use an index
688: shr ebx,16 ;get access to high word
689: or ecx,PackedToPlanar4[eax] ;build planar bytes
690: mov al,bh ;move into eax to use an index
691: and ebx,03ch ;mask off unneeded bits
692: or ecx,PackedToPlanar2[ebx] ;build planar bytes
693: or ecx,PackedToPlanar0[eax] ;build planar bytes
694:
695: mov ebx,[esi] ;Get same dword again so we
696: add esi,cbScan ; can do the high nibbles
697:
698: and ebx,0f0f0f0f0h ;Mask off the low nibbles
699: shr ebx,2 ;shift into low nible and
700: ;multiply by four ((>> 4) << 2)
701:
702: mov al,bl ;move into eax to use an index
703: or ecx,PackedToPlanar7[eax] ;build planar bytes
704: mov al,bh ;move into eax to use an index
705: shr ebx,16 ;get access to high word
706: or ecx,PackedToPlanar5[eax] ;build planar bytes
707: mov al,bh ;move into eax to use an index
708: and ebx,03ch ;mask off unneeded bits
709: or ecx,PackedToPlanar3[ebx] ;build planar bytes
710: or ecx,PackedToPlanar1[eax] ;build planar bytes
711:
712: mov [edi],cl ;Write the bytes out in planar
713: mov [edi+8],ch ;format. We have to store them
714: shr ecx,16 ;this way because this is how
715: mov [edi+16],cl ;the blt compiler expects it.
716: mov [edi+24],ch
717: add edi,1 ;increment dest pointer
718:
719: dec edx ;check scan count
720: jnz convert4toplanar ;
721:
722: convert4exit:
723: cRet vConvert4BpptoPlanar
724: endProc vConvert4BppToPlanar
725:
726: ;==============================================================================
727: ; vConvert8BppToPlanar
728: ;
729: ;
730: ;==============================================================================
731:
732: cProc vConvert8BppToPlanar,16,< \
733: uses esi edi ebx, \
734: pDest: ptr dword, \
735: pSrc: ptr dword, \
736: cbScan: dword, \
737: pulXlate: ptr dword >
738:
739: local ulHeight : dword
740:
741: xor eax,eax
742: mov esi,pSrc
743: mov edi,pDest
744:
745: mov edx,pulXlate
746: or edx,edx
747: jz do_convert8toplanar
748:
749: mov ulHeight,8
750: convert8xlate:
751: xor ecx,ecx
752: mov ebx,[esi] ;Get 4 8bpp pixels
753: mov al,bl ;move into eax to use an index
754: mov eax,[edx][eax*4] ;xlate color
755: or ecx,PackedToPlanar7[eax*4] ;build planar bytes
756: mov al,bh ;move into eax to use an index
757: shr ebx,16 ;get access to high word
758: mov eax,[edx][eax*4] ;xlate color
759: or ecx,PackedToPlanar6[eax*4] ;build planar bytes
760: mov al,bl ;move into eax to use an index
761: mov eax,[edx][eax*4] ;xlate color
762: or ecx,PackedToPlanar5[eax*4] ;build planar bytes
763: mov al,bh ;move into eax to use an index
764: mov eax,[edx][eax*4] ;xlate color
765: or ecx,PackedToPlanar4[eax*4] ;build planar bytes
766:
767: mov ebx,[esi+4] ;Get same dword again so we
768: add esi,cbScan ; can do the high nibbles
769:
770: mov al,bl ;move into eax to use an index
771: mov eax,[edx][eax*4] ;xlate color
772: or ecx,PackedToPlanar3[eax*4] ;build planar bytes
773: mov al,bh ;move into eax to use an index
774: shr ebx,16 ;get access to high word
775: mov eax,[edx][eax*4] ;xlate color
776: or ecx,PackedToPlanar2[eax*4] ;build planar bytes
777: mov al,bl ;move into eax to use an index
778: mov eax,[edx][eax*4] ;xlate color
779: or ecx,PackedToPlanar1[eax*4] ;build planar bytes
780: mov al,bh ;move into eax to use an index
781: mov eax,[edx][eax*4] ;xlate color
782: or ecx,PackedToPlanar0[eax*4] ;build planar bytes
783:
784: mov [edi],cl ;Write the bytes out in planar
785: mov [edi+8],ch ;format. We have to store them
786: shr ecx,16 ;this way because this is how
787: mov [edi+16],cl ;the blt compiler expects it.
788: mov [edi+24],ch
789: add edi,1 ;increment dest pointer
790:
791: dec ulHeight ;Check height
792: jnz convert8xlate ;do next line
793: jmp short convert8exit ;exit
794:
795: do_convert8toplanar:
796: mov edx,8
797:
798: convert8toplanar:
799: xor ecx,ecx
800: mov ebx,[esi] ;Get 8 4bpp pixels
801: mov al,bl ;move into eax to use an index
802: or ecx,PackedToPlanar7[eax*4] ;build planar bytes
803: mov al,bh ;move into eax to use an index
804: shr ebx,16 ;get access to high word
805: or ecx,PackedToPlanar6[eax*4] ;build planar bytes
806: mov al,bl ;move into eax to use an index
807: or ecx,PackedToPlanar5[eax*4] ;build planar bytes
808: mov al,bh ;move into eax to use an index
809: or ecx,PackedToPlanar4[ebx*4] ;build planar bytes
810:
811: mov ebx,[esi+4] ;Get same dword again so we
812: add esi,cbScan ; can do the high nibbles
813:
814: mov al,bl ;move into eax to use an index
815: or ecx,PackedToPlanar3[eax*4] ;build planar bytes
816: mov al,bh ;move into eax to use an index
817: shr ebx,16 ;get access to high word
818: or ecx,PackedToPlanar2[eax*4] ;build planar bytes
819: mov al,bl ;move into eax to use an index
820: or ecx,PackedToPlanar1[eax*4] ;build planar bytes
821: mov al,bh ;move into eax to use an index
822: or ecx,PackedToPlanar0[ebx*4] ;build planar bytes
823:
824: mov [edi],cl ;Write the bytes out in planar
825: mov [edi+8],ch ;format. We have to store them
826: shr ecx,16 ;this way because this is how
827: mov [edi+16],cl ;the blt compiler expects it.
828: mov [edi+24],ch
829: add edi,1 ;increment dest pointer
830:
831: dec edx ;check scan count
832: jnz convert8toplanar ;
833:
834: convert8exit:
835: cRet vConvert8BpptoPlanar
836: endProc vConvert8BppToPlanar
837:
838: ;==============================================================================
839: ; vCreatePlaneMasks
840: ;
841: ;
842: ;==============================================================================
843:
844: cProc vCreatePlaneMasks,8,< \
845: uses esi edi ebx, \
846: pDest: ptr dword, \
847: pSrc: ptr dword >
848:
849: mov esi,pSrc
850: mov edi,pDest
851:
852: mov ebx,8 ; do eight lines
853:
854: ;------------------------------------------------
855: ; al = source byte for compare
856: ; ah = plane 0 mask
857: ; cl = plane 1 mask
858: ; ch = plane 2 mask
859: ; dl = plane 3 mask
860: ;
861: ; ebx = scan count
862: ; esi = pattern
863: ; edi = plane masks
864: ;------------------------------------------------
865: new_scan:
866: mov ah,MM_C0 ;initialize plane masks
867: mov cx,MM_C1 + (MM_C2 SHL 8)
868: mov dl,MM_C3
869:
870: mov al,[esi] ;load plane 0
871: cmp al,[esi+8] ;compare planes 0 and 1
872: jne plane0_ne_plane1
873: or ah,cl
874: xor cl,cl
875:
876: plane0_ne_plane1:
877: cmp al,[esi+16] ;compare planes 0 and 2
878: jne plane0_ne_plane2
879: or ah,ch
880: xor ch,ch
881:
882: plane0_ne_plane2:
883: cmp al,[esi+24] ;compare planes 0 and 3
884: jne plane0_ne_plane3
885: or ah,dl
886: xor dl,dl
887:
888: plane0_ne_plane3:
889: or cl,cl ;did this plane match plane 0
890: jz compare_plane_2 ;if so, skip it
891: mov al,[esi+8] ;load plane 1
892: cmp al,[esi+16] ;compare planes 1 and 2
893: jne plane1_ne_plane2
894: or cl,ch
895: xor ch,ch
896:
897: plane1_ne_plane2:
898: cmp al,[esi+24] ;compare planes 1 and 3
899: jne compare_plane_2
900: or cl,dl
901: xor dl,dl
902: jmp short done_with_scan
903:
904: compare_plane_2:
905: or ch,ch
906: jz done_with_scan
907: mov al,[esi+16] ;load plane 2
908: cmp al,[esi+24] ;compare planes 2 and 3
909: or ch,dl
910: xor dl,dl
911:
912:
913: done_with_scan: ;save results
914: mov [edi],ah ;save plane 0 mask
915: mov [edi+8],cl ;save plane 1 mask
916: mov [edi+16],ch ;save plane 2 mask
917: mov [edi+24],dl ;save plane 3 mask
918:
919: inc edi
920: inc esi
921: dec ebx
922: jnz new_scan
923:
924: cRet vCreatePlaneMasks
925: endProc vCreatePlaneMasks
926:
927: _TEXT$01 ends
928:
929: end
930:
931:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.