![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to special.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 special.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 root 1: page ,132
2: ;---------------------------Module-Header------------------------------;
3: ; Module Name: special.asm
4: ;
5: ; Copyright (c) 1992 Microsoft Corporation
6: ;-----------------------------------------------------------------------;
7: title Special
8: .386
9:
10: ifndef DOS_PLATFORM
11: .model small,c
12: else
13: ifdef STD_CALL
14: .model small,c
15: else
16: .model small,pascal
17: endif; STD_CALL
18: endif; DOS_PLATFORM
19:
20: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
21: assume fs:nothing,gs:nothing
22:
23: .data
24:
25: ;BUGBUG this should be obtained from the surface
26:
27: extrn ulNextScan_global:dword
28:
29: .code
30:
31: _TEXT$01 SEGMENT DWORD USE32 PUBLIC 'CODE'
32: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
33:
34: .xlist
35: include stdcall.inc ;calling convention cmacros
36: include i386\cmacFLAT.inc ; FLATland cmacros
37: include i386\display.inc ; Display specific structures
38: include i386\ppc.inc ; Pack pel conversion structure
39: include i386\bitblt.inc ; General definitions
40: include i386\ropdefs.inc ; Rop definitions
41: include i386\egavga.inc ; EGA register definitions
42: include i386\strucs.inc
43: .list
44:
45: ; Rops we use in this code
46:
47: ROP_P equ 0F0h
48: ROP_Pn equ 0Fh
49: ROP_S equ 0CCh
50: ROP_DDx equ 0
51: ROP_DDxn equ 0FFh
52: ROP_Dn equ 055h
53: ROP_DPx equ 05Ah
54:
55: ; Other values used in this code
56:
57: fr equ [ebp] ; Access to bitblt frame
58: bptr equ byte ptr
59:
60: ;----------------------------Public Routine----------------------------;
61: ; check_device_special_cases
62: ;
63: ; Check for fast special cases of BLT.
64: ;
65: ; Determine if the BLT is a special case which can be performed with
66: ; static code as opposed to code compiled on the stack, and, if so,
67: ; dispatch to the proper static code.
68: ;
69: ; The parameters needed for the BLT (phase alignment, directions of
70: ; movement, ...) have been computed and saved. These parameters will
71: ; now be interpreted and a BLT created on the stack.
72: ;
73: ; If the raster op is source copy, both devices are the screen, and the
74: ; phase alignment is 0, then the copy can be performed by the static
75: ; code using the EGA's write mode 1.
76: ;
77: ; If the rasterop is P, Pn, DDx (0), DDxn (1), and the brush is solid
78: ; or grey (for P and Pn), and the destination device is the screen,
79: ; then the operation can be performed by the static code using the EGA's
80: ; write mode 2 (write mode 0 for greys).
81: ;
82: ; Entry:
83: ; EDI --> pointer to target surface
84: ; EBP --> frame of BitBLT local variables
85: ; EGA registers in default state
86: ; Returns:
87: ; Carry set if BLT was performed with static code.
88: ; Error Returns:
89: ; Carry clear if BLT was not a special case.
90: ; Registers Destroyed:
91: ; AX,BX,CX,DX,SI,DI,DS,ES,flags
92: ; Registers Preserved:
93: ; EBP
94: ; Calls:
95: ;-----------------------------------------------------------------------;
96:
97: cProc check_device_special_cases
98:
99: xor cx,cx ;This is used, what is it????!!!
100: mov dh,fr.the_flags ;Keep the flags in DH for a while
101: test dh,F0_DEST_IS_DEV ;Is the destination a device?
102: jz cdsc_blt_not_special_cased ;Not device, cannot special case it
103: mov edi,fr.dest.next_scan ;Special case code expects this
104: mov al,byte ptr fr.Rop[0] ;Get the raster op
105: cmp al,ROP_S ;Is it src copy?
106: je cdsc_its_src_copy ; Yes, go check it out
107: cmp al,ROP_P
108: je short cdsc_its_patblt
109:
110: cdsc_not_s_or_p:
111: xor bl,bl ;Color for 0 fill
112: cmp al,ROP_DDx
113: je short cdsc_its_1_or_0
114: cmp al,ROP_Pn
115: je short cdsc_its_inverse_patblt
116: cmp al,ROP_Dn
117: je short cdsc_its_dn
118: cmp al,ROP_DPx
119: je short cdsc_its_dpx
120: cmp al,ROP_DDxn
121: jne cdsc_blt_not_special_cased
122: mov bl,0FFh ;Color for 1 fill
123:
124: ; It's "1" (DDxn) or "0" (DDx)
125: cdsc_its_1_or_0:
126: mov fr.brush_accel,SOLID_BRUSH ;(no brush given for DDx or DDxn)
127: call ega_solid_pat
128: jmp cdsc_exit
129:
130: cdsc_its_patblt:
131: mov bl,fr.brush_accel ;Ccolor in lower bits, flags in upper
132: test bl,SOLID_BRUSH
133: jnz short cdsc_its_a_solid_color
134: test bl,GREY_SCALE
135: jz short cdsc_not_solid_nor_grey
136: xor bl,bl ;It's grey. !!! what is this flag
137: call ega_solid_pat
138: jmp cdsc_exit
139:
140: cdsc_not_solid_nor_grey:
141: call do_wes_patblt
142: jmp cdsc_exit
143:
144: cdsc_its_inverse_solid_color:
145: not bl
146: cdsc_its_a_solid_color:
147: mov cx,2
148: call do_solid_patcopy ;color and accl. flags already in BL
149: jmp short cdsc_exit
150:
151: cdsc_its_inverse_patblt:
152: mov bl,fr.brush_accel ;color in lower bits, flags in upper
153: test bl,SOLID_BRUSH
154: jnz short cdsc_its_inverse_solid_color
155: test bl,GREY_SCALE
156: jz short cdsc_blt_not_special_cased
157: mov bl,-1 ;It's grey. !!! What is this flag
158: call ega_solid_pat
159: jmp short cdsc_exit
160:
161: cdsc_its_dn:
162: call do_wes_invert
163: jmp short cdsc_exit
164:
165: cdsc_its_dpx:
166: mov ah,fr.brush_accel ;color in lower bits, flags in upper
167: test ah,SOLID_BRUSH
168: jnz cdsc_its_solid_dpx ;dpx with solid brush
169: test ah,GREY_SCALE ;Otherwise must be a grey brush
170: jz short cdsc_blt_not_special_cased
171: call do_grey_dpx
172: jmp short cdsc_exit
173:
174: cdsc_its_solid_dpx:
175: call do_wes_dpx_solidpat ;solid color => can special case
176: jmp short cdsc_exit
177:
178:
179: ;-----------------------------------------------------------------------;
180: ; This is a source copy. The phase must be zero to special case the
181: ; source copy, and both devices must be the screen.
182: ;
183: ; errnz F0_SRC_IS_DEV - 00001000b
184: ; errnz F0_SRC_IS_COLOR - 00000100b
185: ;
186: ; its_src_copy:
187: ; and dh,F0_SRC_IS_DEV + F0_SRC_IS_COLOR
188: ; shiftr dh,2
189: ; cmp fr.phase_h,1 ; Gives CF if horizontal phase = zero
190: ; rcl dh,1
191: ; Now we have the needed flags in the lower 3 bits of DH
192: ; ; Src=EGA Src=Color Phase0
193: ;
194: ; dw do_wes_mono_trick ; 0 0 0
195: ; dw blt_not_a_special_case ; 0 0 1
196: ; dw blt_not_a_special_case ; 0 1 0
197: ; dw blt_not_a_special_case ; 0 1 1
198: ; dw do_wes_mono_trick ; 1 0 0
199: ; dw blt_not_a_special_case ; 1 0 1
200: ; dw blt_not_a_special_case ; 1 1 0
201: ; dw ega_src_copy ; 1 1 1
202: ;-----------------------------------------------------------------------;
203:
204: cdsc_its_src_copy:
205: test dh,F0_SRC_IS_DEV
206: jnz short cdsc_exit
207:
208: cdsc_source_is_memory:
209: test dh,F0_SRC_IS_COLOR ;mono-mem to color-EGA conversion?
210: jnz cdsc_blt_not_special_cased ;color to color, cannot special case it
211: call do_wes_mono_trick
212: jmp short cdsc_exit
213:
214: cdsc_blt_not_special_cased:
215: clc
216: cRet check_device_special_cases
217:
218: cdsc_exit:
219: stc
220: cRet check_device_special_cases
221:
222:
223: ;----------------------------Private-Routine----------------------------;
224: ; calc_parms
225: ;
226: ; Calculate the parameters needed for the output functions contained
227: ; in this file.
228: ;
229: ; To avoid conditional jumps we will use some sick optimizations.
230: ; Remember this:
231: ; adc ax,-1 ; DEC AX if carry clear
232: ; sbb ax,0 ; DEC AX if carry set
233: ; sbb ax,-1 ; INC AX if carry clear
234: ; adc ax,0 ; INC AX if carry set
235: ;
236: ; Entry:
237: ; EBP --> BitBLT local frame
238: ; Returns:
239: ; ESI set to upper left of bitmap or pattern
240: ; EDI set to upper left
241: ; EDX = src bitmap width (if present)
242: ; ECX = fr.yExt
243: ; EBX = offset into pattern (if pat present)
244: ; sets dest_right_edge
245: ; sets start_mask[0]
246: ; sets last_mask[0]
247: ; sets inner_loop_count
248: ; Registers Destroyed:
249: ; EAX,flags
250: ; Registers Preserved:
251: ; EBP
252: ; Alters:
253: ;
254: ; Calls:
255: ; None
256: ;-----------------------------------------------------------------------;
257:
258: .errnz SIZE_PATTERN - 8 ; any power of 2 will work
259:
260: align 4
261: calc_parms:
262:
263: ; Left edge.
264:
265: movzx edi,fr.DestxOrg ;X origin in pixels, must be positive
266: mov ebx,edi
267: mov cl,7
268: and ecx,edi ;Save lower 3 bits
269: mov fr.phase_h,cl
270: shr edi,3 ;EDI set for left edge
271: mov al,0FFh
272: shr al,cl
273: mov byte ptr fr.start_mask[0],al
274:
275: ; Right edge.
276:
277: movzx eax,fr.xExt
278: add ebx,eax ;Right edge in pixels
279: mov cl,7
280: and cl,bl ;save lower 3 bits
281: shr ebx,3 ;convert to bytes
282: mov fr.start_fl,ebx ;dest_right_edge (reuse stk variable)
283: mov al,0FFh
284: shr al,cl
285: not al
286:
287: ; Check if the BLT does not cross any byte boundaries.
288:
289: sub ebx,edi ;make EBX # bytes including left edge
290: jnz crosses_byte_boundary
291: and byte ptr fr.start_mask[0],al
292: xor al,al
293:
294: ; There are 2 cases where we get zero for fr.inner_loop_count:
295: ; When the start and end bytes are adjacent and when they are
296: ; the same byte. In the latter case we get -1 for
297: ; fr.inner_loop_count so INC BX now so it will be zero.
298:
299: inc ebx
300: crosses_byte_boundary:
301:
302: cmp al,0FFh
303: sbb al,-1 ;AL=FF -> AL=0 (put in innerloop)
304: mov byte ptr fr.last_mask[0],al
305:
306: ; Inner loop -- combine edge bytes into inner loop if they are
307: ; full bytes.
308:
309: mov fr.end_fl,ebx ;src_right_edge (reuse stk variable)
310: mov al,byte ptr fr.start_mask[0]
311: cmp al,0FFh
312:
313: ; If gl_start_mask = FF the carry is clear, otherwise carry is set.
314: ; We want to DEC BX if carry set because we have already included
315: ; the left edge byte in BX, but we shouldn't have included it if
316: ; it's only a partial byte.
317:
318: sbb ebx,0
319: cmp al,0FFh
320:
321: ; If gl_start_mask = FF the carry is clear, otherwise carry is set.
322: ; We want to INC AL (zero it) if it is FF (carry clear) because we
323: ; will do this edge as part of the innerloop.
324:
325: sbb al,-1
326: mov byte ptr fr.start_mask[0],al
327: mov fr.inner_loop_count,ebx
328: movzx eax,fr.DestyOrg
329: imul eax,ulNextScan_global
330: add edi,eax
331: mov esi,fr.pdsurfDst
332: add edi,[esi].dsurf_pvBitmapStart
333:
334: ; The source.
335:
336: test fr.the_flags,F0_SRC_PRESENT
337: jz no_source
338: mov esi,fr.pdsurfSrc
339: mov ecx,[esi].dsurf_lNextScan ;!!! will this be correct ??
340: mov esi,[esi].dsurf_pvBitmapStart
341:
342: ; Left edge.
343:
344: movzx ebx,fr.SrcxOrg
345: mov dl,7
346: and dl,bl ;get lower 3 bits ( Src Mod 8 )
347: sub fr.phase_h,dl ;phase def'd as Mod8[gl_dest]-
348: shr ebx,3 ; Mod8[gl_src]
349: add esi,ebx ;ESI set for left edge
350: movzx eax,fr.SrcyOrg
351: mul ecx
352: add esi,eax
353: add fr.end_fl,esi ;src_right_edge (reuse stack variable)
354: mov edx,ecx
355: jmp short no_pattern
356: no_source:
357: test fr.the_flags,F0_PAT_PRESENT ; assuming P or S but not both
358: jz no_pattern
359: mov esi,fr.lpPBrush
360: movzx ebx,fr.DestyOrg
361: and ebx,SIZE_PATTERN - 1
362: no_pattern:
363: movzx ecx,fr.yExt
364: PLAIN_RET
365:
366:
367: ;----------------------------Private-Routine----------------------------;
368: ; ega_solid_pat
369: ;
370: ; EGA special case for solid color pattern copy.
371: ;
372: ; The following routine is invoked instead of generating code for a
373: ; pattern copy. The actual time involved in executing the pattern
374: ; copy as static code as compared to compiled code is a win.
375: ;
376: ; This code can only be used if the pattern is a solid color or a grey,
377: ; and the operation is to the screen. In this case, the three bits of
378: ; color stored in the accelerator byte of the brush will be used, or the
379: ; bits of the grey brush.
380: ;
381: ; The logic operations which will invoke this routine are:
382: ;
383: ; P
384: ; Pn
385: ; DDx
386: ; DDxn
387: ;
388: ; Entry:
389: ; BL = color to write or xor value for a grey pattern
390: ; CX = Mode register value (sort of)
391: ; EBP = BitBLT local variable frame
392: ; Returns:
393: ; Nothing
394: ; Registers Destroyed:
395: ; ALL except EBP
396: ; Registers Preserved:
397: ; EBP
398: ; Calls:
399: ; None
400: ;-----------------------------------------------------------------------;
401:
402: align 4
403: ega_solid_pat:
404:
405: ; Instead of pushing and popping the destination pointer and adding in
406: ; the fr.dest.Incr, the bias needed for adjusting the pointer at the
407: ; end of a scan line will be computed and used.
408: ;
409: ; Since this is a pattern copy, the fr.dest.Incr will be positive.
410:
411: ; mov esi,edi ;Get destination increment
412: ; sub esi,1 ;Adjust for first byte
413: lea esi,-1[edi]
414: sub esi,fr.inner_loop_count ;Compute number of bytes to copy
415:
416: ; Put color in Set/Reset if it is a solid color.
417:
418: mov dx,EGA_BASE + GRAF_ADDR
419: or cx,cx
420: jz not_solid_color
421: mov ax,MM_ALL * 256 + GRAF_ENAB_SR
422: out dx,ax
423: mov ah,bl
424: mov al,GRAF_SET_RESET
425: out dx,ax
426: not_solid_color:
427: mov al,GRAF_BIT_MASK ;Leave graphics controller pointing
428: out dx,al ; to the bitmask register, which
429: inc dx ; is where cursor leaves it too
430:
431: ; Set up for the loop.
432:
433: mov edi,fr.dest.lp_bits ;--> destination
434: mov fr.phase_h,bl ;Save color to write or grey XOR mask
435:
436: ega_solid_pat_20:
437: mov al,fr.phase_h ;Get the color to write
438: test fr.brush_accel,SOLID_BRUSH ;Grey scale brush?
439: jnz ega_solid_pat_30 ; No, a solid color
440: mov bl,fr.pat_row ;Get scan of brush
441: inc bl ; and update brush pointer
442: mov fr.pat_row,bl
443: dec bl
444: and ebx,00000111b
445: add ebx,fr.lpPBrush
446: xor al,bptr [ebx] ;Invert if needed
447:
448: ega_solid_pat_30:
449: mov bl,al
450: mov al,bptr fr.start_mask[1] ;Set bitmask for first byte
451: out dx,al
452: mov al,bl
453: xchg al,[edi] ;xchg to load EGA's latches first
454: inc edi ;PAT_COPY step +X always!
455:
456: mov ecx,fr.inner_loop_count ;Set count for innerloop
457: jecxz ega_solid_pat_40 ;No innerloop or last byte
458: mov al,0FFh ;Inner loop alters all bits
459: out dx,al
460: mov al,bl
461: rep stosb
462:
463: ega_solid_pat_40:
464: mov al,bptr fr.last_mask[1] ;Last byte?
465: or al,al
466: jz ega_solid_pat_50 ;No last byte
467: out dx,al
468: xchg bl,[edi]
469:
470: ega_solid_pat_50:
471: add edi,esi ;--> next destination
472: dec fr.yExt ;Any more scans to process?
473: jnz ega_solid_pat_20 ; Yes
474: PLAIN_RET
475:
476:
477: ;----------------------------Private-Routine----------------------------;
478: ; do_wes_invert
479: ; do_wes_dpx_solidpat
480: ;
481: ; Entry:
482: ; EBP --> BitBLT local variable frame
483: ; AH = color of solid-pat.
484: ; Returns:
485: ; Nothing
486: ; Registers Destroyed:
487: ; ALL but EBP
488: ; Registers Preserved:
489: ; EBP
490: ; Calls:
491: ; calc_parms
492: ; edge_invert
493: ; invert
494: ;-----------------------------------------------------------------------;
495:
496: align 4
497: do_wes_invert:
498:
499: mov ah,0Fh ; black
500:
501: do_wes_dpx_solidpat label near
502:
503: ; Setup SET_RESET.
504:
505: mov dx,EGA_BASE + GRAF_ADDR
506: mov al,GRAF_SET_RESET
507: out dx,ax
508: mov ax,0F00h + GRAF_ENAB_SR ; enable all planes
509: out dx,ax
510:
511: ; Go to XOR mode.
512:
513: mov ax,GRAF_DATA_ROT + 256 * DR_XOR
514: out dx,ax
515:
516: call calc_parms
517: mov ah,byte ptr fr.start_mask[0]
518: or ah,ah
519: jz no_left_invert_edge
520: push edi
521: call edge_invert
522: pop edi
523: inc edi
524:
525: no_left_invert_edge:
526: mov ebx,fr.inner_loop_count
527: or ebx,ebx
528: jz no_inner_invert_loop
529: movzx ecx,fr.yExt
530: push edi
531: call invert
532: pop edi
533: add edi,fr.inner_loop_count
534:
535: no_inner_invert_loop:
536: mov ah,byte ptr fr.last_mask[0]
537: or ah,ah
538: jz no_last_invert_edge
539: movzx ecx,fr.yExt
540: call edge_invert
541:
542: no_last_invert_edge:
543: PLAIN_RET
544:
545:
546: ;----------------------------Private-Routine----------------------------;
547: ;do_solid_patcopy() is called to copy (PatCopy) a solid brush directly to
548: ;the screen.
549: ;
550: ;Entry:
551: ; BL color to write with
552: ; EDI fr.dest.next_scan which is equal to width_b
553: ; EBP local varible frame
554: ;
555: ;-----------------------------------------------------------------------;
556:
557: align 4
558: do_solid_patcopy:
559:
560: cmp fr.inner_loop_count,0 ;if zero, let ega_solid_pat do the work
561: jne dsp_do_it
562: call ega_solid_pat
563: PLAIN_RET
564:
565: dsp_do_it:
566: sub eax,eax ;accumulate flags in AL
567: mov esi,edi ;SI: fr.dest.next_scan (must be > 0)
568: mov edi,fr.dest.lp_bits ;EDI-->first byte to write to
569: mov bh,bptr fr.start_mask[1]
570: cmp ah,bh ;is there a left edge?
571: rcl al,1 ;CY if there is an edge to draw
572: sub bh,0ffh ;is the left edge an entire byte wide?
573: neg bh ;CY if less than a byte
574: rcl al,1 ;accumulate flag into AL
575: mov bh,bptr fr.last_mask[1]
576: cmp ah,bh ;is there a right edge?
577: rcl al,1 ;CY if there is an edge to draw
578: sub bh,0ffh ;is right edge an entire byte wide?
579: neg bh ;CY if less than a byte
580: rcl al,1 ;accumulate flag into AL
581: test al,04h ;set all pixels in left byte?
582: jnz dsp_keep_left_edge ;no. Do normal stuff
583: inc fr.inner_loop_count ;left edge is an entire byte. INC inner
584: and al,0f7h ;loop cnt and draw it the fast way
585:
586: dsp_keep_left_edge:
587: test al,01h ;set all pixels in right byte?
588: jnz dsp_keep_right_edge ;no. Do normal stuff
589: inc fr.inner_loop_count ;need to set all pixels in right byte.
590: and al,0fdh ;inc inner loop cnt do it the fast way
591:
592: dsp_keep_right_edge:
593: test al,0ah ;any edges to draw?
594: jz dsp_draw_core_piece ;no, just do the main chunk
595:
596: dsp_draw_edges:
597: mov bh,al ;save flags in BH
598: mov dx,EGA_BASE + GRAF_ADDR
599: mov ax,MM_ALL * 256 + GRAF_ENAB_SR
600: out dx,ax ;enable writing to all planes at once
601: mov ah,bl
602: mov al,GRAF_SET_RESET
603: out dx,ax ;program to color value to write
604: mov al,GRAF_BIT_MASK ;Leave graphics controller pointing
605: out dx,al ; to the bitmask register, which
606: inc dx ; is where cursor leaves it too
607:
608: test bh,08h ;need to draw the left edge?
609: jz dsp_draw_right_edge
610:
611: push edi ;save destination offset
612: mov al,bptr fr.start_mask[1]
613: out dx,al ;get it to the board
614: movzx ecx,fr.yExt
615:
616: dsp_left_edge_draw_loop:
617: mov al,bl ;copy color index into AL
618: xchg al,[edi] ;load latches, copy color index
619: add edi,esi
620: loop dsp_left_edge_draw_loop
621: pop edi ;restore dest offset
622: inc edi ;update to new draw position
623:
624:
625: dsp_draw_right_edge:
626: test bh,02h ;is there a right edge to draw?
627: jz dsp_reset_registers ;no. Restore default settings
628: push edi ;save updated dest offset
629: add edi,fr.inner_loop_count ;go to the right hand edge
630: mov al,bptr fr.last_mask[1]
631: out dx,al ;get it to the board
632: movzx ecx,fr.yExt
633:
634: dsp_right_edge_draw_loop:
635: mov al,bl ;copy color index into AL
636: xchg al,[edi] ;load latches, copy color index
637: add edi,esi
638: loop dsp_right_edge_draw_loop
639: pop edi ;restore dest offset
640:
641:
642: dsp_reset_registers:
643: mov al,0ffh ;allow writing to all bits in the byte
644: out dx,al ;this is the default value
645:
646: dsp_draw_core_piece:
647: sub esi,fr.inner_loop_count ;account for EDI being incr. by stosb
648: mov dx,EGA_BASE+SEQ_DATA ;time to copy pattern to board DX=3C5h
649: mov al,01h
650: mov ecx,4
651:
652: dsp_load_latches_loop:
653: out dx,al ;select the next plane to write to
654: shr bl,1 ;move plane bit into carry
655: sbb ah,ah ;expand into AH
656: mov [edi],ah ;copy it to the bit plane
657: shl al,1 ;update plane selector
658: loop dsp_load_latches_loop ;do all 4 planes
659:
660: mov al,MM_ALL ;to enable all four planes
661: out dx,al ;enable all planes
662: mov dx,EGA_BASE+GRAF_ADDR ;DX=3CEh
663: mov ax,GRAF_BIT_MASK ;AH=0 ie., copy data from latches, AL=8
664: out dx,ax ;ignore CPU data on write to board
665:
666: mov al,[edi] ;load the latches
667: movzx eax,fr.yExt ;initialize loop counter
668: mov ebx,fr.inner_loop_count ;initialize rep counter value
669:
670: align 4
671: dsp_pat_blt_loop:
672: mov ecx,ebx ;ECX: repeat count
673: test edi,1
674: jz short dsp_pat_blt_aligned2
675: stosb
676: dec ecx
677: dsp_pat_blt_aligned2:
678: shr ecx,1
679: rep stosw
680: adc ecx,ecx
681: rep stosb
682: add edi,esi ;point to next scanline
683: dec eax
684: jnz dsp_pat_blt_loop
685:
686: PLAIN_RET
687:
688:
689: ;----------------------------Private-Routine----------------------------;
690: ; do_wes_patblt
691: ;
692: ; Entry:
693: ; EBP --> BitBLT local variable frame
694: ; Returns:
695: ; Nothing
696: ; Registers Destroyed:
697: ; All but EBP
698: ; Registers Preserved:
699: ; EBP
700: ; Calls:
701: ; calc_parms
702: ; edge_pat_blt
703: ; pat_blt
704: ;-----------------------------------------------------------------------;
705:
706: align 4
707: do_wes_patblt:
708:
709: call calc_parms
710: mov ah,byte ptr fr.start_mask[0]
711: or ah,ah
712: jz no_left_pat_edge
713: push esi
714: push ebx
715: call edge_pat_blt ; preserves DI
716: pop ebx
717: pop esi
718: inc edi
719:
720: no_left_pat_edge:
721: mov edx,fr.inner_loop_count
722: or edx,edx
723: jz no_inner_pat_loop
724: movzx ecx,fr.yExt
725: push edi
726: push esi
727: push ebx
728: call pat_blt
729: pop ebx
730: pop esi
731: pop edi
732: add edi,fr.inner_loop_count
733:
734: no_inner_pat_loop:
735: mov ah,byte ptr fr.last_mask[0]
736: or ah,ah
737: jz no_last_pat_edge
738: movzx ecx,fr.yExt
739: call edge_pat_blt
740:
741: no_last_pat_edge:
742: PLAIN_RET
743:
744:
745: ;----------------------------Private-Routine----------------------------;
746: ; do_wes_mono_trick
747: ;
748: ; Entry:
749: ; EBP --> BitBLT local variable frame
750: ; Returns:
751: ; Nothing
752: ; Registers Preserved:
753: ; EBP
754: ; Registers Destroyed:
755: ; All but EBP
756: ; Calls:
757: ; calc_parms
758: ; left_edge_mono_to_color_blt
759: ; right_edge_mono_to_color_blt
760: ; mono_to_color_blt
761: ;-----------------------------------------------------------------------;
762:
763: align 4
764: do_wes_mono_trick:
765:
766: call calc_parms
767: push edx
768: mov ah,byte ptr fr.start_mask[0]
769: or ah,ah
770: jz no_left_edge
771: push edi
772: push esi
773: push edx
774: mov al,fr.phase_h
775: mov bx,fr.both_colors
776: ;- mov ecx,fr.yExt
777: call left_edge_mono_to_color_blt
778: pop edx
779: pop esi
780: pop edi
781: inc esi
782: inc edi
783: no_left_edge:
784: mov ebx,edx
785: mov edx,fr.inner_loop_count
786: mov ecx,edi ; compute/save the right-hand edge
787: add ecx,edx
788: push ecx
789: or edx,edx
790: jz no_inner_loop
791: sub ebx,edx
792: movzx ecx,fr.yExt
793: mov al,fr.phase_h
794: cbw
795: push ebp
796: mov bp,fr.both_colors
797: xchg bp,ax
798: call mono_to_color_blt
799: pop ebp
800:
801: no_inner_loop:
802: pop edi
803: pop edx
804: mov ah,byte ptr fr.last_mask[0]
805: or ah,ah
806: jz no_last_edge
807:
808: mov ecx,fr.inner_loop_count
809: mov esi,fr.end_fl ; src_right_edge (reuse stk variable)
810: movzx ecx,fr.yExt
811: mov bx,fr.both_colors
812: mov al,fr.phase_h
813: call right_edge_mono_to_color_blt
814:
815: no_last_edge:
816: PLAIN_RET
817:
818:
819: ;----------------------------Private-Routine----------------------------;
820: ; mono_to_color_blt
821: ;
822: ; This does phase-0, byte-aligned, mem-mono to ega-color blt.
823: ;
824: ; The Problem: copy to the ega a bitmap where "0"s in the bitmap mean
825: ; color1 and "1"s in the bitmap mean color2, where color1 and color2
826: ; are arbitrary colors.
827: ;
828: ; The solution:
829: ;
830: ; plane0 plane1 plane2 plane3
831: ;
832: ; color1 1 1 0 0
833: ; color2 1 0 1 0
834: ; SetResetEnable 1 0 0 1
835: ; SetReset 0 x x 0
836: ; latches 1 1 0 0 (=color1)
837: ;
838: ; Now with datarot = XOR we get
839: ;
840: ; when databit=0 1 1 0 0 (=color1)
841: ; when databit=1 1 0 1 0 (=color2)
842: ;
843: ;
844: ; Entry:
845: ; BP = phase ( -7 to 7) (high byte ignored)
846: ; AL = background color ( "1" bits in mono-bitmap )
847: ; AH = foreground color
848: ; EBX = SI wrap
849: ; ESI = Mono Bitmap first byte
850: ; EDI = First EGA Byte
851: ; ECX = Number of scan lines
852: ; EDX = bytes per scan line
853: ; GRAF_DATA_ROT = DR_SET
854: ; All Planes Enabled
855: ; Returns:
856: ; Nothing
857: ; Registers Destroyed:
858: ; ALL
859: ; Registers Preserved:
860: ; None
861: ; Alters:
862: ; GRAF_SET_RESET
863: ; GRAF_ENAB_SR
864: ; GRAF_BIT_MASK
865: ; Calls:
866: ; None
867: ;-----------------------------------------------------------------------;
868:
869: align 4
870: mono_to_color_blt:
871:
872: push ebp ; phase
873: push edx ; bytes per scan line
874: push ebx ; wrap for SI
875: mov ebx,eax ; colors
876:
877: ; First we put the foreground color into the latches. We do this
878: ; by putting this color into SET_RESET, writing it, then reading it.
879: ; The memory location we will use is the first byte where we will blt.
880:
881: mov dx,EGA_BASE + GRAF_ADDR
882: mov al,GRAF_SET_RESET
883: out dx,ax
884: mov ax,0F00h + GRAF_ENAB_SR
885: out dx,ax
886:
887: ; Set bit mask = FF.
888: mov ax,0FF00h + GRAF_BIT_MASK
889: out dx,ax
890:
891: ; Fill the latches.
892: mov [edi],al ; color in SetReset is written, not AL
893: mov al,[edi] ; read to fill latches
894:
895: ; Go to XOR mode.
896: mov ax,GRAF_DATA_ROT + 256 * DR_XOR
897: out dx,ax
898:
899: ; Now setup SET_RESET.
900:
901: mov eax,ebx ; restore colors
902: xor ah,al ; gives 0 where colors match
903: mov al,GRAF_SET_RESET
904: out dx,ax
905: not ah
906: mov al,GRAF_ENAB_SR
907: out dx,ax ; enable Set/Reset where colors match
908:
909: pop ebp ; wrap for ESI
910: pop edx ; bytes per scan
911: mov ebx,ulNextScan_global
912: sub ebx,edx ; BX = wrap
913:
914: mov eax,ecx ; loop count
915: pop ecx ; phase
916: or cl,cl
917: js phase_neg
918: jz phase_zero
919: dec esi
920: ;* dec ebp
921: pmono_to_color_loop:
922: push eax
923: push edx
924: pnext_byte:
925: lodsw
926: dec esi
927: xchg al,ah
928: shr ax,cl
929: ;+ shl ax,cl
930: stosb
931: dec edx
932: jnz pnext_byte
933: pop edx
934: pop eax
935: add edi,ebx
936: add esi,ebp
937: dec eax
938: jnz pmono_to_color_loop
939: jmp leave_in_set_mode
940:
941: phase_zero:
942: zmono_to_color_loop:
943: mov ecx,edx
944: shr ecx,1
945: rep movsw
946: rcl ecx,1
947: rep movsb
948: add edi,ebx
949: add esi,ebp
950: dec eax
951: jnz zmono_to_color_loop
952: jmp leave_in_set_mode
953:
954: phase_neg:
955: neg cl ; make CX = abs phase
956: nmono_to_color_loop:
957: push eax
958: push edx
959: nnext_byte:
960: lodsw
961: dec esi
962: rol ax,cl
963: ;+ shr ax,cl
964: stosb
965: dec edx
966: jnz nnext_byte
967: pop edx
968: pop eax
969: add edi,ebx
970: add esi,ebp
971: dec eax
972: jnz nmono_to_color_loop
973:
974: leave_in_set_mode:
975: mov dx,EGA_BASE + GRAF_ADDR
976: mov ax,GRAF_DATA_ROT + 256 * DR_SET
977: out dx,ax
978: PLAIN_RET
979:
980:
981: ;----------------------------Private-Routine----------------------------;
982: ; left_edge_mono_to_color_blt
983: ; right_edge_mono_to_color_blt
984: ;
985: ; This problem here is the same as in mono_to_color_blt, except it
986: ; is complicated by the need to preserve what is already in EGA memory
987: ; for part of the byte which we are writing.
988: ;
989: ; We will set the BIT MASK to preserve these bytes. We will then read
990: ; the data from memory, and write it to the EGA using an XCHG so the
991: ; latches are filled before the write -- so the appropriate EGA bits
992: ; are preserved.
993: ;
994: ; The method for writing the data involves two passes. The first pass
995: ; writes the data to some of the planes, the second pass writes NOT the
996: ; data to the other planes. Depending on the two colors involved we
997: ; may be able to skip one of the two passes.
998: ;
999: ; Define BkColor = the color corresponding to "1" bits in the data.
1000: ; Define TextColor = the color corresponding to "0" bits in the data.
1001: ;
1002: ; We will use the Set/Reset register to take care of the planes where
1003: ; the colors match. These planes will be ignored in the rest of this
1004: ; comment block.
1005: ;
1006: ; The first pass writes "1"s where the data is "1". Therefore, the
1007: ; condition for doing the first pass is that the BkColor has a "1"
1008: ; somewhere (ignoring those planes taken care of by Set/Reset).
1009: ; The second pass does whatever planes remain. We can skip this pass
1010: ; if no planes remain. To maximize to likelihood of this we make sure
1011: ; that all "Set/Reset" planes are enabled on the first pass (if the
1012: ; first pass occurs).
1013: ;
1014: ; Entry:
1015: ; AH = bitmask
1016: ; AL = phase (-7 to +7)
1017: ; BH = foreground color
1018: ; BL = background color
1019: ; EDX = src bitmap width in bytes
1020: ; ESI = Mono Bitmap first byte
1021: ; EDI = First EGA Byte
1022: ; ECX = Number of scan lines
1023: ; DATA_ROT = DR_SET
1024: ; Returns:
1025: ; Nothing
1026: ; Registers Destroyed:
1027: ; ALL but EBP
1028: ; Registers Preserved:
1029: ; EBP
1030: ; Alters:
1031: ; GRAF_SET_RESET
1032: ; GRAF_BIT_MASK
1033: ; GRAF_ENAB_SR
1034: ; Calls:
1035: ; None
1036: ;-----------------------------------------------------------------------;
1037:
1038: ; Does left edge, which never requires more than 1 byte, and can fault with
1039: ; the 2-byte approach used by the right edge.
1040:
1041: align 4
1042: left_edge_mono_to_color_blt:
1043:
1044: push ebp
1045: push eax ; AL = phase
1046: mov ebp,edx
1047:
1048: ; Set bit mask.
1049:
1050: mov dx,EGA_BASE + GRAF_ADDR
1051: mov al,GRAF_BIT_MASK
1052: out dx,ax
1053:
1054: ; Put foreground color in Set/Reset and enable planes where colors
1055: ; match.
1056:
1057: mov ah,bh
1058: mov al,GRAF_SET_RESET
1059: out dx,ax
1060: xor ah,bl
1061: not ah ; gives 1 where colors match
1062: mov al,GRAF_ENAB_SR
1063: out dx,ax
1064: mov dx,EGA_BASE + SEQ_DATA ; The rest of the OUTs are here.
1065: mov al,ah
1066: not ah ; Gives 1 where colors mismatch.
1067:
1068: ; The following AND leaves 1 bits in AH for the planes which
1069: ; CANNOT be done on the second pass. So if this is zero we can
1070: ; skip the first pass.
1071:
1072: and ah,bl ; BL = BkColor = color where data is 1
1073: or ah,bl ; planes to enable
1074: mov ebx,ecx ; we're done with the colors in BX
1075: pop ecx ; phase
1076: jz short left_skip_first_pass
1077: or al,ah ; Include "Set/Reset" planes.
1078: out dx,al ; Enable planes for first pass.
1079:
1080: push ecx
1081: push esi
1082: push edi
1083: push eax
1084: push ebx
1085: or cl,cl
1086: js short left_phase_is_negative1
1087: left_pfirst_pass:
1088: mov ah,[esi]
1089: shr ah,cl
1090: xchg ah,[edi]
1091: add esi,ebp
1092: add edi,ulNextScan_global
1093: dec ebx
1094: jnz left_pfirst_pass
1095: jmp short left_end_pass_one
1096:
1097: left_phase_is_negative1:
1098: neg cl ; make CL = abs phase
1099: left_nfirst_pass:
1100: mov ax,[esi]
1101: rol ax,cl
1102: xchg al,[edi]
1103: add esi,ebp
1104: add edi,ulNextScan_global
1105: dec ebx
1106: jnz left_nfirst_pass
1107: left_end_pass_one:
1108: pop ebx
1109: pop eax
1110: pop edi
1111: pop esi
1112: pop ecx
1113:
1114: left_skip_first_pass:
1115:
1116: ; Enable the other planes.
1117:
1118: not ah
1119: and ah,MM_ALL
1120: jz short left_no_planes_left
1121: mov al,ah
1122: out dx,al
1123: or cl,cl
1124: js short left_phase_is_negative2
1125: left_psecond_pass:
1126: mov ah,[esi]
1127: not ah
1128: shr ah,cl
1129: xchg ah,[edi]
1130: add esi,ebp
1131: add edi,ulNextScan_global
1132: dec ebx
1133: jnz left_psecond_pass
1134: jmp short left_no_planes_left
1135:
1136: left_phase_is_negative2:
1137: neg cl ; make CL = abs phase
1138: left_nsecond_pass:
1139: mov ax,[esi]
1140: not ax
1141: rol ax,cl
1142: xchg al,[edi]
1143: add esi,ebp
1144: add edi,ulNextScan_global
1145: dec ebx
1146: jnz left_nsecond_pass
1147:
1148: left_no_planes_left:
1149: mov al,MM_ALL
1150: out dx,al
1151: pop ebp
1152: PLAIN_RET
1153:
1154: ; Does right edge, which may require 2 bytes. 2 bytes are always available,
1155: ; because if there was only 1 byte across, the left edge would handle it,
1156: ; so we don't have to worry about faulting.
1157:
1158: align 4
1159: right_edge_mono_to_color_blt:
1160:
1161: push ebp
1162: push eax ; AL = phase
1163: mov ebp,edx
1164:
1165: ; Set bit mask.
1166:
1167: mov dx,EGA_BASE + GRAF_ADDR
1168: mov al,GRAF_BIT_MASK
1169: out dx,ax
1170:
1171: ; Put foreground color in Set/Reset and enable planes where colors
1172: ; match.
1173:
1174: mov ah,bh
1175: mov al,GRAF_SET_RESET
1176: out dx,ax
1177: xor ah,bl
1178: not ah ; gives 1 where colors match
1179: mov al,GRAF_ENAB_SR
1180: out dx,ax
1181: mov dx,EGA_BASE + SEQ_DATA ; The rest of the OUTs are here.
1182: mov al,ah
1183: not ah ; Gives 1 where colors mismatch.
1184:
1185: ; The following AND leaves 1 bits in AH for the planes which
1186: ; CANNOT be done on the second pass. So if this is zero we can
1187: ; skip the first pass.
1188:
1189: and ah,bl ; BL = BkColor = color where data is 1
1190: or ah,bl ; planes to enable
1191: mov ebx,ecx ; we're done with the colors in BX
1192: pop ecx ; phase
1193: jz short right_skip_first_pass
1194: or al,ah ; Include "Set/Reset" planes.
1195: out dx,al ; Enable planes for first pass.
1196:
1197: push ecx
1198: push esi
1199: push edi
1200: push eax
1201: push ebx
1202: or cl,cl
1203: js short right_phase_is_negative1
1204: dec esi
1205: right_pfirst_pass:
1206: mov ax,[esi]
1207: ror ax,cl
1208: xchg ah,[edi]
1209: add esi,ebp
1210: add edi,ulNextScan_global
1211: dec ebx
1212: jnz right_pfirst_pass
1213: jmp short right_end_pass_one
1214:
1215: right_phase_is_negative1:
1216: neg cl ; make CL = abs phase
1217: right_nfirst_pass:
1218: mov ax,[esi]
1219: rol ax,cl
1220: xchg al,[edi]
1221: add esi,ebp
1222: add edi,ulNextScan_global
1223: dec ebx
1224: jnz right_nfirst_pass
1225: right_end_pass_one:
1226: pop ebx
1227: pop eax
1228: pop edi
1229: pop esi
1230: pop ecx
1231:
1232: right_skip_first_pass:
1233:
1234: ; Enable the other planes.
1235:
1236: not ah
1237: and ah,MM_ALL
1238: jz short right_no_planes_left
1239: mov al,ah
1240: out dx,al
1241: or cl,cl
1242: js short right_phase_is_negative2
1243: dec esi
1244: right_psecond_pass:
1245: mov ax,[esi]
1246: not ax
1247: ror ax,cl
1248: xchg ah,[edi]
1249: add esi,ebp
1250: add edi,ulNextScan_global
1251: dec ebx
1252: jnz right_psecond_pass
1253: jmp short right_no_planes_left
1254:
1255: right_phase_is_negative2:
1256: neg cl ; make CL = abs phase
1257: right_nsecond_pass:
1258: mov ax,[esi]
1259: not ax
1260: rol ax,cl
1261: xchg al,[edi]
1262: add esi,ebp
1263: add edi,ulNextScan_global
1264: dec ebx
1265: jnz right_nsecond_pass
1266:
1267: right_no_planes_left:
1268: mov al,MM_ALL
1269: out dx,al
1270: pop ebp
1271: PLAIN_RET
1272:
1273:
1274: ;----------------------------Private-Routine----------------------------;
1275: ; pat_blt
1276: ; XOR mode with data = FF for Pn?
1277: ;
1278: ; This BLTs an arbitrary 8x8 bit pattern (3 or 4 planes deep) to EGA.
1279: ;
1280: ; The method is simple. Load the latches with the pattern for a
1281: ; particular scan line, then REP STOS this with the BIT MASK = 0
1282: ; so that only the latches get written. Before putting the pattern
1283: ; for the next scan line into the latches we will do all other scan
1284: ; lines with the same pattern.
1285: ;
1286: ; Entry:
1287: ; ESI = pattern bytes
1288: ; EDI = First EGA Byte
1289: ; ECX = Number of scan lines (yExt)
1290: ; EBX = offset into pattern
1291: ; EDX = bytes per scan line (scan_len)
1292: ; GRAF_DATA_ROT = DR_SET
1293: ; BIT_MASK = FF
1294: ; Returns:
1295: ; Nothing
1296: ; Registers Destroyed:
1297: ; ALL but EBP
1298: ; Registers Preserved:
1299: ; EBP
1300: ; Alters:
1301: ; GRAF_BIT_MASK (leaves it 00)
1302: ; Calls:
1303: ; None
1304: ;-----------------------------------------------------------------------;
1305:
1306: .errnz SIZE_PATTERN - 8 ; actually any power of 2 is okay.
1307:
1308: align 4
1309: pat_blt:
1310:
1311: push ebp
1312: push edx ; scan_len
1313: push ecx ; yExt
1314: mov ah,11h ; left nibble gives carry to end loop
1315:
1316: ; Set EBP = min(yExt, scans/pattern).
1317:
1318: sub ecx,SIZE_PATTERN ; SIZE_PATTERN = 8 = yExt of pattern
1319: sbb ebp,ebp
1320: and ebp,ecx
1321: add ebp,SIZE_PATTERN
1322:
1323: mov dx,EGA_BASE + SEQ_DATA
1324: set_next_plane:
1325: push ebx
1326: push edi
1327:
1328: ; Enable next plane.
1329:
1330: mov al,MM_ALL
1331: and al,ah
1332: out dx,al
1333: mov ecx,ebp
1334:
1335: hit_next_byte:
1336: mov al,[esi][ebx] ; Next pattern byte
1337: inc ebx
1338: and ebx,SIZE_PATTERN - 1
1339: mov [edi],al
1340: add edi,ulNextScan_global
1341: loop hit_next_byte
1342: add esi,SIZE_PATTERN
1343: pop edi
1344: pop ebx
1345: shl ah,1
1346: jnc set_next_plane
1347:
1348: ; Set bit mask = 00.
1349:
1350: mov dx,EGA_BASE + GRAF_ADDR
1351: mov ax,0000h + GRAF_BIT_MASK
1352: out dx,ax
1353:
1354: ; Enable all planes.
1355:
1356: mov al,MM_ALL
1357: mov dx,EGA_BASE + SEQ_DATA
1358: out dx,al
1359:
1360: mov ecx,ebp ; MIN(yExt,SIZE_PATTERN)
1361: pop ebp ; yExt
1362: pop eax ; scan_len
1363: mov esi,ulNextScan_global ; ESI = scan_width
1364:
1365: .errnz (SIZE_PATTERN - 8)
1366: ;------------------------------------------------;
1367: ; mov ebx,(SIZE_PATTERN - 1) * scan_width
1368: ;------------------------------------------------;
1369: lea ebx,[esi*2+esi] ; scan_width * 3
1370: lea ebx,[ebx+esi*4] ; scan_width * 7
1371:
1372: sub esi,eax ; ESI = scan_width
1373: add ebx,esi ; EBX = (scan_width * 7) + next_scan
1374:
1375: pat_blt_next_scan:
1376: push ecx
1377: mov esi,edi ; save ESI
1378: mov edx,ebp ; save yExt
1379: mov cl,[edi] ; load latches
1380:
1381: pat_blt_loop:
1382: mov ecx,eax ; EAX = scan_len
1383: rep stosb
1384: add edi,ebx ; EBX = (scan_width * 7) + next_scan
1385: sub ebp,SIZE_PATTERN
1386: jg pat_blt_loop
1387:
1388: mov ebp,edx
1389: dec ebp
1390: mov edi,esi
1391: add edi,ulNextScan_global
1392: pop ecx
1393: loop pat_blt_next_scan
1394:
1395: pop ebp
1396: PLAIN_RET
1397:
1398:
1399: ;----------------------------Private-Routine----------------------------;
1400: ; edge_pat_blt
1401: ;
1402: ; Entry:
1403: ; AH = bitmask
1404: ; ESI = pattern bytes
1405: ; EDI = First EGA Byte
1406: ; ECX = Number of scan lines (yExt)
1407: ; EBX = offset into pattern
1408: ; DATA_ROT = DR_SET
1409: ; Returns:
1410: ; Nothing
1411: ; Registers Destroyed:
1412: ; EAX,ECX,EDX,ESI,flags
1413: ; Registers Preserved:
1414: ; EBX,EDI,EBP
1415: ; Alters:
1416: ; GRAF_BIT_MASK (leaves it FF)
1417: ; Calls:
1418: ; None
1419: ;-----------------------------------------------------------------------;
1420:
1421: align 4
1422: edge_pat_blt:
1423:
1424: push ebp
1425:
1426: ; Set bit mask.
1427:
1428: mov dx,EGA_BASE + GRAF_ADDR
1429: mov al,GRAF_BIT_MASK
1430: out dx,ax
1431: mov ah,11h ; left nibble gives carry to end loop
1432: mov dx,EGA_BASE + SEQ_DATA
1433: sub si,SIZE_PATTERN
1434: mov ebp,ecx
1435:
1436: enable_next_plane:
1437: push ebx
1438: push edi
1439: mov ecx,ebp ; yExt
1440: mov al,MM_ALL
1441: and al,ah
1442: out dx,al
1443: add esi,SIZE_PATTERN
1444:
1445: over_scans:
1446: mov al,[ebx][esi] ; pattern fetch
1447: inc ebx
1448: and ebx,SIZE_PATTERN - 1 ; 7
1449: .errnz SIZE_PATTERN - 8 ; any power of 2 works
1450: xchg [edi],al
1451: add edi,ulNextScan_global
1452: loop over_scans
1453:
1454: pop edi
1455: pop ebx
1456: shl ah,1
1457: jnc enable_next_plane
1458:
1459: ; Restore bitmask to default.
1460:
1461: mov dx,EGA_BASE + GRAF_ADDR
1462: mov ax,0FF00h + GRAF_BIT_MASK
1463: out dx,ax
1464:
1465: pop ebp
1466: PLAIN_RET
1467:
1468:
1469: ;----------------------------Private-Routine----------------------------;
1470: ; invert
1471: ;
1472: ; Inverts pixels in a rectangle on the display, by simply writing the
1473: ; memory to itself, letting the EGA hardware perform the XORing.
1474: ;
1475: ; Entry:
1476: ; EDI = First EGA Byte
1477: ; ECX = Number of scan lines (yExt)
1478: ; EBX = scan line length in bytes
1479: ; DATA_ROT = DR_XOR
1480: ; GRAF_SET_RESET = color to xor DEST with
1481: ; GRAF_SR_ENAB = MM_ALL
1482: ; Returns:
1483: ; Nothing
1484: ; Registers Destroyed:
1485: ; EAX,ECX,EDX,ESI,EDI,flags
1486: ; Registers Preserved:
1487: ; EBX,EBP
1488: ; Alters:
1489: ; GRAF_BIT_MASK (leaves it FF)
1490: ; Calls:
1491: ; None
1492: ;-----------------------------------------------------------------------;
1493:
1494: align 4
1495: invert:
1496:
1497: ; Set bit mask.
1498:
1499: mov dx,EGA_BASE + GRAF_ADDR
1500: mov ax,0FF00h + GRAF_BIT_MASK
1501: out dx,ax
1502: mov edx,ulNextScan_global
1503: sub edx,ebx
1504: mov eax,ecx ; save height
1505:
1506: invert_next_scan:
1507: mov esi,edi
1508: mov ecx,ebx ; scan len in bytes
1509: rep movsb
1510: add edi,edx
1511: dec eax
1512: jnz invert_next_scan
1513: PLAIN_RET
1514:
1515:
1516: ;----------------------------Private-Routine----------------------------;
1517: ; edge_invert
1518: ;
1519: ; Inverts one byte on each scan line vertically according to the mask
1520: ; in AH.
1521: ;
1522: ; Entry:
1523: ; AH = bitmask
1524: ; EDI = First EGA Byte
1525: ; ECX = Number of scan lines (yExt)
1526: ; DATA_ROT = DR_XOR
1527: ; GRAF_SET_RESET = color to xor DEST with
1528: ; GRAF_ENAB_SR = MM_ALL
1529: ; Returns:
1530: ; Nothing
1531: ; Registers Destroyed:
1532: ; AL,ECX,EDX,EDI,flags
1533: ; Registers Preserved:
1534: ; AH,EBX,ESI,EBP
1535: ; Alters:
1536: ; GRAF_BIT_MASK
1537: ; Calls:
1538: ; None
1539: ;-----------------------------------------------------------------------;
1540:
1541: align 4
1542: edge_invert:
1543:
1544: ; Set bit mask.
1545:
1546: mov dx,EGA_BASE + GRAF_ADDR
1547: mov al,GRAF_BIT_MASK
1548: out dx,ax
1549:
1550: edge_invert_next_scan:
1551: xchg [edi],al
1552: add edi,ulNextScan_global
1553: loop edge_invert_next_scan
1554: PLAIN_RET
1555:
1556:
1557: ;----------------------------Private-Routine----------------------------;
1558: ; edge_grey_dpx
1559: ;
1560: ; Inverts one or two bytes on each scan line vertically according
1561: ; to the grey pattern given, under the passed clipping mask.
1562: ;
1563: ; Entry:
1564: ; EBX = brush index (0-7)
1565: ; ECX = number of scan lines (cyExt)
1566: ; DL = lhs clipping mask
1567: ; DH = rhs clipping mask
1568: ; ESI --> base address of brush
1569: ; EDI --> rhs EGA
1570: ; EBP --> lhs EGA
1571: ; Returns:
1572: ; Nothing
1573: ; Registers Destroyed:
1574: ; All
1575: ; Registers Preserved:
1576: ; None
1577: ; Alters:
1578: ; None
1579: ; Calls:
1580: ; None
1581: ;-----------------------------------------------------------------------;
1582:
1583: align 4
1584: edge_grey_dpx:
1585:
1586: sub ebp,edi ;Compute delta to lhs
1587: and ebx,00000111b ;Make sure brush is valid
1588: .errnz SIZE_PATTERN - 8
1589: or dh,dh ;Dispatch based on one or two edges
1590: jz edge_grey_dpx_one_loop
1591:
1592: edge_grey_dpx_both_loop:
1593: mov al,[esi][ebx] ;Get next byte of brush
1594: mov ah,al
1595: and al,dl ;Mask with lhs clipping mask
1596: xchg al,[edi] ;Invert necessary bits
1597: inc ebx ;--> next brush byte
1598: and bl,00000111b ;Handle any wrap
1599: .errnz SIZE_PATTERN - 8
1600: and ah,dh ;Mask with rhs clipping mask
1601: xchg ah,[edi][ebp] ;Invert necessary bits
1602: add edi,ulNextScan_global ;--> next destination byte
1603: loop edge_grey_dpx_both_loop
1604: PLAIN_RET
1605:
1606: edge_grey_dpx_one_loop:
1607: mov al,[esi][ebx] ;Get next byte of brush
1608: and al,dl ;Mask with lhs clipping mask
1609: xchg al,[edi] ;Invert necessary bits
1610: inc ebx ;--> next brush byte
1611: and bl,00000111b ;Handle any wrap
1612: .errnz SIZE_PATTERN - 8
1613: add edi,ulNextScan_global ;--> next destination byte
1614: loop edge_grey_dpx_one_loop
1615: PLAIN_RET
1616:
1617:
1618: ;----------------------------Private-Routine----------------------------;
1619: ; middle_grey_dpx
1620: ;
1621: ; Inverts a rectangle on the display using the passed grey pattern.
1622: ;
1623: ; Entry:
1624: ; EBX = brush index (0-7)
1625: ; ECX = # byte to invert on the scan
1626: ; EDX = EGA_BASE + GRAF_ADDR
1627: ; ESI --> base address of brush
1628: ; EDI --> starting byte
1629: ; EBP = number of scan lines (cyExt)
1630: ; DATA_ROT = DR_XOR
1631: ; GRAF_SET_RESET = All 1
1632: ; GRAF_ENAB_SR = MM_ALL
1633: ; Returns:
1634: ; Nothing
1635: ; Registers Destroyed:
1636: ; EAX,ECX,EDX,ESI,EDI,flags
1637: ; Registers Preserved:
1638: ; EBX,EBP
1639: ; Alters:
1640: ; GRAF_BIT_MASK (leaves it FF)
1641: ; Calls:
1642: ; None
1643: ;-----------------------------------------------------------------------;
1644:
1645: align 4
1646: middle_grey_dpx:
1647:
1648: ; mov dx,EGA_BASE + GRAF_ADDR ; Leave the Graphics controller
1649: mov al,GRAF_BIT_MASK ; address register pointing to
1650: out dx,al ; the bitmask register
1651: inc edx ; --> Graphics controller data register
1652: .errnz GRAF_DATA - GRAF_ADDR - 1
1653:
1654: mov ah,bl ; Keep brush index here
1655: mov ebx,ecx ; Save a copy of inner loop count here
1656:
1657: middle_grey_dpx_loop:
1658: xchg eax,ebx
1659: xchg bl,bh
1660: and ebx,00000111b
1661: errnz SIZE_PATTERN-8
1662: mov bh,[esi][ebx] ; Get next byte of brush
1663: inc bl ; --> byte of the brush
1664: xchg bh,bl
1665: xchg eax,ebx
1666: out dx,al
1667: mov ecx,ebx
1668: push esi
1669: mov esi,edi
1670: rep movsb
1671: pop esi
1672: sub edi,ebx
1673: add edi,ulNextScan_global ;next scan on screen
1674: dec ebp
1675: jnz middle_grey_dpx_loop
1676: PLAIN_RET
1677:
1678:
1679: ;----------------------------Private-Routine----------------------------;
1680: ; do_grey_dpx
1681: ;
1682: ; This is EGA special cased code for the dpx raster op in the case where
1683: ; the pattern (p) is grey (the same on all planes). We also come here
1684: ; for the special graying pattern rop. This is not a normal P,S, and D rop,
1685: ; but a hack for pmwin. It allows graying of things on the screen, meaning
1686: ; the background color is stuffed everywhere the pattern has a "1" bit.
1687: ;
1688: ; Entry:
1689: ; EBP --> BitBLT local variable frame
1690: ; Returns:
1691: ; Nothing
1692: ; Registers Destroyed:
1693: ; ALL but EBP
1694: ; Registers Preserved:
1695: ; EBP
1696: ; Calls:
1697: ; calc_parms
1698: ; edge_grey_dpx
1699: ; middle_grey_dpx
1700: ;-----------------------------------------------------------------------;
1701:
1702: align 4
1703: do_grey_dpx:
1704:
1705: call calc_parms
1706: mov dx,EGA_BASE + GRAF_ADDR
1707: mov ax,DR_XOR shl 8 + GRAF_DATA_ROT ; XOR mode for grey dpx
1708: out dx,ax
1709: mov dl,byte ptr fr.start_mask[0]
1710: mov dh,byte ptr fr.last_mask[0]
1711: or dx,dx
1712: jz do_grey_dpx_middle ;Only middle bytes exist
1713:
1714: mov eax,edi ;Assume we have a left edge
1715: inc eax ;+1 to get to start of middle bytes
1716: or dl,dl ;Is there really a left edge?
1717: jnz do_grey_dpx_have_lhs ; Yes, AX = correct middle byte start
1718: dec eax ; No, restore middle byte start
1719: xchg dl,dh ; Pretend only a lhs edge
1720: add edi,fr.inner_loop_count ; but make it be the rhs
1721:
1722: do_grey_dpx_have_lhs:
1723: push eax ;Save middle bytes start
1724: push ebx
1725: push ecx
1726: push esi
1727: push ebp
1728: add eax,fr.inner_loop_count ;--> possible rhs
1729: xchg eax,ebp
1730: call edge_grey_dpx
1731: did_gray_pat_edge:
1732: pop ebp
1733: pop esi
1734: pop ecx
1735: pop ebx
1736: pop edi ;Restore middle bytes start
1737:
1738: do_grey_dpx_middle:
1739: mov eax,fr.inner_loop_count
1740: or eax,eax
1741: jz do_grey_dpx_exit
1742: push ebp
1743: mov ebp,ecx
1744: xchg eax,ecx
1745: mov dx,EGA_BASE + GRAF_ADDR ;
1746: mov ax,MM_ALL shl 8 + GRAF_ENAB_SR ; Set Set/Reset to all "1" bits
1747: out dx,ax ; and Enable all planes (for
1748: .errnz MM_ALL - 0Fh ; grey_dpx)
1749: mov al,GRAF_SET_RESET ;
1750: out dx,ax ;
1751:
1752: gray_pat:
1753: call middle_grey_dpx
1754: pop ebp
1755:
1756: do_grey_dpx_exit:
1757: PLAIN_RET
1758:
1759:
1760: endProc check_device_special_cases
1761:
1762: _TEXT$01 ends
1763:
1764: end
1765:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.