![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cblt.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 cblt.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 root 1: page ,132
2: title BitBLT
3: ;---------------------------Module-Header------------------------------;
4: ; Module Name: cblt.asm
5: ;
6: ; Copyright (c) 1992 Microsoft Corporation
7: ;-----------------------------------------------------------------------;
8: .386
9:
10: ;!!! All the code to convert from color to mono in this file needs to
11: ;!!! be deleted. We don't need to do it anymore.
12:
13:
14:
15:
16: ifndef DOS_PLATFORM
17: .model small,c
18: else
19: ifdef STD_CALL
20: .model small,c
21: else
22: .model small,pascal
23: endif; STD_CALL
24: endif; DOS_PLATFORM
25:
26: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
27: assume fs:nothing,gs:nothing
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:
37: include i386\cmacFLAT.inc ; FLATland cmacros
38: include i386\display.inc ; Display specific structures
39: include i386\ppc.inc ; Pack pel conversion structure
40: include i386\bitblt.inc ; General definitions
41: include i386\ropdefs.inc ; Rop definitions
42: include i386\egavga.inc ; EGA register definitions
43: include i386\devdata.inc
44: .list
45:
46: extrn roptable:byte
47: ;-----------------------------Public-Routine----------------------------;
48: ; CBLT
49: ;
50: ; Compile a BLT onto the stack.
51: ;
52: ; Entry:
53: ; EDI --> memory on stack to receive BLT program
54: ; EBP --> fr structure
55: ; Returns:
56: ; Nothing
57: ;-----------------------------------------------------------------------;
58:
59: fr equ [ebp] ;For consistancy with other sources
60:
61: cProc cblt
62:
63: subttl Compile - Outer Loop
64: page
65:
66: ; If converting a packed pel format to planer format, add the code
67: ; to convert one source scan into planer format
68:
69: test fr.ppcBlt.fb,PPC_NEEDED
70: jz no_pack_pel_conversion
71: mov al,I_MOV_EBP_DWORD_I ;Give conversion routine access
72: stosb ; to conversion data
73: lea eax,fr.ppcBlt
74: stosd
75: mov al,I_CALL_DISP32 ;Call the static conversion code
76: stosb
77: mov eax,fr.ppcBlt.pfnConvert
78: sub eax,edi
79: sub eax,4 ;4 for length of displacement
80: stosd
81: no_pack_pel_conversion:
82:
83: ; Initialize plane indicator.
84:
85: mov ax,(PLANE_1*256)+I_MOV_BL_BYTE_I
86: stosw
87:
88: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
89: ; Create the outerloop code. The first part of this code will save
90: ; the scan line count register, destination pointer, and the source
91: ; pointer (if there is a source).
92: ;
93: ; The generated code should look like:
94: ;
95: ; push ecx ;Save scan line count
96: ; push edi ;Save destination pointer
97: ; < push esi > ;Save source pointer
98: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
99:
100: mov fr.pNextPlane,edi ;Save address of next plane code
101: mov bl,fr.the_flags
102: mov ax,I_PUSH_ECX_PUSH_EDI ;Save scan line count, destination ptr
103: stosw
104: test bl,F0_SRC_PRESENT ;Is a source needed?
105: jz cblt_2020 ; No
106: mov al,I_PUSH_ESI ; Yes, save source pointer
107: stosb
108: cblt_2020:
109:
110: subttl Compile - Plane Selection
111: page
112: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
113: ; If the destination device is color and the display is involved in
114: ; the blt, then the color plane selection logic must be added in.
115: ; If the destination is monochrome, then no plane logic is needed.
116: ; Two color memory bitmaps will not cause the plane selection logic
117: ; to be copied.
118: ;
119: ; The generated code should look like:
120: ;
121: ; < push ebx > ;Save plane index
122: ; < plane selection > ;Select plane
123: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
124:
125: test bl,F0_DEST_IS_COLOR ;Is the destination color?
126: jz cblt_pattern_fetch ; No
127: mov al,I_PUSH_EBX ;Save plane index
128: stosb
129: test bl,F0_DEST_IS_DEV+F0_SRC_IS_DEV ;Is the device involved?
130: jz cblt_pattern_fetch ; No
131:
132: ; The device is involved for a color blt. Copy the logic for selecting
133: ; the read/write plane
134:
135: mov esi,offset FLAT:cps ;--> plane select logic
136: mov ecx,LENGTH_CPS
137: rep movsb
138:
139: subttl Compile - Pattern Fetch
140: page
141:
142: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
143: ; Set up any pattern fetch code that might be needed.
144: ; The pattern code has many fixups, so it isn't taken from a
145: ; template. It is just stuffed as it is created.
146: ;
147: ; Entry: None
148: ;
149: ; Exit: DH = pattern
150: ;
151: ; Uses: AX,BX,CX,DH,flags
152: ;
153: ; For solid color brushes:
154: ;
155: ; mov dh,color
156: ;
157: ; For monochrome brushes:
158: ;
159: ; mov ebx,12345678h ;Load address of the brush
160: ; mov dh,7[ebx] ;Get next brush byte
161: ; mov al,[12345678h] ;Get brush index
162: ; add al,direction ;Add displacement to next byte (+1/-1)
163: ; and al,00000111b ;Keep it in range
164: ; mov [12345678h],al ;Store displacement to next plane's bits
165: ;
166: ; For color brushes:
167: ;
168: ; mov ebx,12345678h ;Load address of the brush
169: ; mov dh,7[bx] ;Get next brush byte
170: ; mov al,[12345678h] ;Get brush index
171: ; add al,SIZE Pattern ;Add displacement to next plane's bits
172: ; and al,00011111b ;Keep it within the brush
173: ; mov [12345678h],al ;Store displacement to next plane's bits
174: ;
175: ; The address of the increment for the brush is saved for
176: ; the plane looping logic if the destination is a three plane
177: ; color device. For a four plane color device, the AND
178: ; automatically handles the wrap and no fixup is needed at
179: ; the end of the plane loop.
180: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
181:
182: cblt_pattern_fetch:
183: test bl,F0_PAT_PRESENT ;Is a pattern needed?
184: jz cblt_initial_byte_fetch ; No, skip pattern code
185: mov al,fr.brush_accel ;Solid color needs no fetch logic
186: test al,SOLID_BRUSH
187: jz cblt_nonsolid_brush
188: and al,MM_ALL
189: shl eax,16
190: mov ax,I_TEST_BL_BYTE_I
191: stosd
192: dec edi ;Was only a three byte instruction
193: mov eax,I_SETNZ_DH
194: stosd
195: dec edi ;Was only a three byte instruction
196: mov ax,I_NEG_DH
197: stosw
198: jmp short cblt_initial_byte_fetch
199:
200: cblt_nonsolid_brush:
201: mov al,I_MOV_EBX_DWORD_I ;mov ebx,lpPBrush
202: stosb
203: mov eax,fr.lpPBrush
204: stosd
205: mov ax,I_MOV_DH_EBX_DISP8 ;mov dh,pat_row[ebx]
206: stosw
207: mov edx,edi ;Save address of the brush index
208: mov al,fr.pat_row ;Set initial pattern row
209: mov bh,00000111b ;Set brush index mask
210: and al,bh ;Make sure it's legal at start
211: stosb
212: mov al,I_MOV_AL_MEM
213: stosb ;mov al,[xxxxxxxx]
214: mov eax,edx
215: stosd
216: mov al,I_ADD_AL_BYTE_I
217: mov ah,direction ;Set brush index
218: errnz INCREASE-1 ;Must be a 1
219: errnz DECREASE+1 ;Must be a -1
220:
221: test bl,F0_COLOR_PAT ;Color pattern required?
222: jz cblt_2060 ; No
223: mov fr.addr_brush_index,edx ;Save address of brush index
224: mov ah,SIZE_PATTERN ;Set increment to next plane
225: mov bh,00011111b ;Set brush index mask
226:
227: cblt_2060:
228: stosw
229: mov ah,bh ;and al,BrushIndexMask
230: mov al,I_AND_AL_BYTE_I
231: stosw
232: mov al,I_MOV_MEM_AL
233: stosb ;mov [xxxxxxxx],al
234: mov eax,edx
235: stosd
236:
237:
238: subttl Compile - Initial Byte Fetch
239: page
240: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
241: ; Create the initial byte code. This may consist of one or two
242: ; initial fetches (if there is a source), followed by the required
243: ; logic action. The code should look something like:
244: ;
245: ; BLTouterloop:
246: ; < mov bp,mask_p > ;Load phase mask for entire loop
247: ; < xor bh,bh > ;Clear previous unused bits
248: ;
249: ; ; Perform first byte fetch
250: ;
251: ; < lodsb > ;Get source byte
252: ; < color<==>mono munge > ;Color <==> mono conversion
253: ; < phase alignment > ;Align bits as needed
254: ;
255: ; ; If an optional second fetch is needed, perform one
256: ;
257: ; < lodsb > ;Get source byte
258: ; < color to mono munge > ;Color to mono munging
259: ; < phase alignment > ;Align bits as needed
260: ;
261: ; logical action ;Perform logical action required
262: ;
263: ; mov ah,[edi] ;Get destination
264: ; and ax,cx ;Saved unaltered bits
265: ; or al,ah ; and mask in altered bits
266: ; stosb ;Save the result
267: ;
268: ; The starting address of the first fetch/logical combination will be
269: ; saved so that the code can be copied later instead of recreating it
270: ; (if there are two fecthes, the first fetch will not be copied)
271: ;
272: ; The length of the code up to the masking for altered/unaltered bits
273: ; will be saved so the code can be copied into the inner loop.
274: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
275:
276: cblt_initial_byte_fetch:
277: xor dx,dx
278: or dh,fr.phase_h ;Is the phase 0? (also get the phase)
279: jz cblt_3020 ; Yes, so no phase alignment needed
280: mov al,I_SIZE_OVERRIDE
281: stosb
282: mov al,I_MOV_BP_WORD_I ;Set up the phase mask
283: stosb
284: mov ax,fr.mask_p ;Place the mask into the instruction
285: stosw
286: mov ax,I_XOR_BH_BH ;Clear previous unused bits
287: stosw
288:
289: cblt_3020:
290: mov fr.start_fl,edi ;Save starting address of action
291: test fr.the_flags,F0_SRC_PRESENT ;Is there a source?
292: jz cblt_4000 ; No, don't generate fetch code
293:
294:
295: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
296: ; Generate the required sequence of instructions for a fetch
297: ; sequence. Only the minimum code required is generated.
298: ;
299: ; The code generated will look something like the following:
300: ;
301: ; BLTfetch:
302: ; < lodsb > ;Get the next byte
303: ; < color munging > ;Mono <==> color munging
304: ;
305: ; ; If the phase alignment isn't zero, then generate the minimum
306: ; ; phase alignment needed. RORs or ROLs will be generated,
307: ; ; depending on the fastest sequence. If the phase alignment
308: ; ; is zero, than no phase alignment code will be generated.
309: ;
310: ; < ror al,n > ;Rotate as needed
311: ; < mov ah,al > ;Mask used, unused bits
312: ; < and ax,bp > ;(BP) = phase mask
313: ; < or al,bh > ;Mask in old unused bits
314: ; < mov bh,ah > ;Save new unused bits
315: ;
316: ;
317: ; The nice thing about the above is it is possible for the fetch to
318: ; degenerate into a simple LODSB instruction.
319: ;
320: ; Currently: BL = the_flags
321: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
322:
323: cblt_3040:
324: mov fr.moore_flags,0 ;Assume REP cannot be used
325: shl bl,1 ;Color conversion?
326: jnc cblt_3180 ; No, we were lucky this time
327: errnz F0_GAG_CHOKE-10000000b
328: js cblt_3100 ;Mono ==> color
329: errnz F0_COLOR_PAT-01000000b
330:
331: subttl Compile - Initial Byte Fetch, Color ==> Mono
332: page
333:
334: ; !!! Color to mono should not be needed anymore since the Engine will
335: ; !!! not be calling me to do it! Let's remove this code!
336:
337:
338: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
339: ; Generate the code to go from color to mono. Color to mono
340: ; should map all colors that are background to 1's (white), and
341: ; all colors which aren't background to 0's (black). If the source
342: ; is the display, then the color compare register will be used.
343: ; If the source is a memory bitmap, each byte of the plane will be
344: ; XORed with the color from that plane, with the results all ORed
345: ; together. The final result will then be complemented, giving
346: ; the desired result.
347: ;
348: ; The generated code for bitmaps should look something like:
349: ;
350: ; mov al,next_plane[esi] ;Get C1 byte of source
351: ; mov ah,2*next_plane[esi] ;Get C2 byte of source
352: ; xor ax,C1BkColor+(C2BkColor*256) ;XOR with plane's color
353: ; or ah,al ;OR the result
354: ; mov al,3*next_plane[esi] ;Get C3 byte of source
355: ; xor al,C3BkColor
356: ; or ah,al
357: ; lodsb ;Get C0 source
358: ; xor al,C0BkColor ;XOR with C0BkColor
359: ; or al,ah ;OR with previous result
360: ; not al ;NOT to give 1's where background
361: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
362:
363: cblt_3070:
364: test bl,F0_SRC_IS_DEV SHL 1 ;If device, use color compare register
365: jz cblt_3080 ;It's a memory bitmap
366:
367: ; We're in luck, the color compare register can be used. Set up
368: ; for a color read, and use the normal mono fetch code. Show the
369: ; innerloop code that the REP instruction can be used if this is
370: ; a source copy.
371:
372: mov fr.moore_flags,F1_REP_OK
373: mov ecx,edx ;Save dx
374: mov ah,fr.bkColor.SPECIAL ;Get SPECIAL byte of color
375: and ah,MM_ALL
376: mov al,GRAF_COL_COMP ;Stuff color into compare register
377: mov dx,EGA_BASE+GRAF_ADDR
378: out dx,ax
379: mov ax,GRAF_CDC ;Set Color Don't Care register
380: out dx,ax
381: mov ax,M_COLOR_READ SHL 8 + GRAF_MODE
382: out dx,ax
383: mov edx,ecx
384: jmp cblt_3180 ;Go generate mono fetch code
385:
386: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
387: ; The source is a memory bitmap. Generate the code to compute
388: ; the result of the four planes:
389: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
390:
391: cblt_3080:
392: mov ax,I_MOV_AL_ESI_DISP32
393: stosw
394: mov eax,fr.src.next_plane
395: stosd
396: mov ebx,eax ;Save plane width
397: mov ax,I_MOV_AH_ESI_DISP32
398: stosw
399: lea eax,[ebx*2]
400: stosd
401: mov al,I_SIZE_OVERRIDE
402: stosb
403: mov al,I_XOR_AX_WORD_I
404: stosb
405: mov al,fr.bkColor.SPECIAL ;get the color index byte
406: mov ah,al ;have the same in AH
407: and ax,(C2_BIT shl 8) or C1_BIT
408: neg al
409: sbb al,al ;al will be 0ffh if plane bit is 1
410: neg ah
411: sbb ah,ah ;ah wil be 0ffh if plane bit is 1
412: stosw
413: mov ax,I_OR_AH_AL
414: stosw
415:
416: mov ax,I_MOV_AL_ESI_DISP32
417: stosw
418: lea eax,[ebx*2][ebx]
419: stosd
420: mov al,I_XOR_AL_BYTE_I
421: mov ah,fr.bkColor.SPECIAL
422: and ah,C3_BIT
423: neg ah
424: sbb ah,ah
425: stosw
426: mov ax,I_OR_AH_AL
427: stosw
428:
429: mov ax,I_LODSB+(I_XOR_AL_BYTE_I*256)
430: stosw
431: mov al,fr.bkColor.SPECIAL
432: shr al,1 ;get C0_BIT into carry
433: sbb al,al ;make it 0ffh if bit was set
434: .errnz C0_BIT - 00000001b
435: stosb ;save the modified value
436: errnz pcol_C0
437: mov ax,I_OR_AL_AH
438: stosw
439: mov ax,I_NOT_AL
440: stosw
441: jmp cblt_3240 ;Go create logic code
442:
443: subttl Compile - Initial Byte Fetch, Mono ==> Color
444: page
445: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
446: ; The conversion is mono to color. Generate the code to
447: ; do the conversion, and generate the table which will
448: ; have the conversion values in it.
449: ;
450: ; When going from mono to color, 1 bits are considered to be
451: ; the background color, and 0 bits are considered to be the
452: ; foreground color.
453: ;
454: ; For each plane:
455: ;
456: ; If the foreground=background=1, then 1 can be used in
457: ; place of the source.
458: ;
459: ; If the foreground=background=0, then 0 can be used in
460: ; place of the source.
461: ;
462: ; If the foreground=0 and background=1, then the source
463: ; can be used as is.
464: ;
465: ; If the foreground=1 and background=0, then the source
466: ; must be complemented before using.
467: ;
468: ; Looks like a boolean function to me.
469: ;
470: ; An AND mask and an XOR mask will be computed for each plane,
471: ; based on the above. The source will then be processed against
472: ; the table. The generated code should look like
473: ;
474: ; lodsb
475: ; and al,[xxxx]
476: ; xor al,[xxxx+1]
477: ;
478: ; The table for munging the colors as stated above should look like:
479: ;
480: ; BackGnd ForeGnd Result AND XOR
481: ; 1 1 1 00 FF
482: ; 0 0 0 00 00
483: ; 1 0 S FF 00
484: ; 0 1 not S FF FF
485: ;
486: ; From this, it can be seen that the XOR mask is the same as the
487: ; foreground color. The AND mask is the XOR of the foreground
488: ; and the background color. Not too hard to compute
489: ;
490: ; It can also be seen that if the background color is white and the
491: ; foreground (text) color is black, then the conversion needn't be
492: ; generated (it just gives the source). This is advantageous since
493: ; it will allow phased aligned source copies to use REP MOVSW.
494: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
495:
496: ; Check to see if the background color is black, and the
497: ; foreground color is white. This can be determined by
498: ; looking at the accelerator flags in the physical color.
499:
500: cblt_3100:
501: mov ah,fr.TextColor.SPECIAL
502: xor ah,MONO_BIT ;Map black to white
503: and ah,fr.bkColor.SPECIAL ;AND in background color
504: cmp ah,MONO_BIT+ONES_OR_ZEROS
505: jne cblt_3110 ;Not black
506: mov fr.moore_flags,F1_REP_OK+F1_NO_MUNGE ;Show reps as ok, no color munge table
507: jmp short cblt_3180 ;Normal fetch required
508:
509: ; No way around it. The color conversion table and code
510: ; must be generated.
511:
512: cblt_3110:
513: mov cl,fr.bkColor.SPECIAL ;Get BackGround Colors
514: mov ch,fr.TextColor.SPECIAL ;Get ForeGround Colors
515: xor cl,ch
516: shr cl,1
517: sbb al,al
518: shr ch,1
519: sbb ah,ah
520: mov word ptr fr.ajM2C.(pcol_C0 * 2),ax
521: shr cl,1
522: sbb al,al
523: shr ch,1
524: sbb ah,ah
525: mov word ptr fr.ajM2C.(pcol_C1 * 2),ax
526: shr cl,1
527: sbb al,al
528: shr ch,1
529: sbb ah,ah
530: mov word ptr fr.ajM2C.(pcol_C2 * 2),ax
531: shr cl,1
532: sbb al,al
533: shr ch,1
534: sbb ah,ah
535: mov word ptr fr.ajM2C.(pcol_C3 * 2),ax
536: errnz <TextColor - bkColor - 4>
537:
538: ; Generate the code for munging the color as stated above.
539:
540: mov ax,I_LODSB
541: stosb ;lodsb
542: mov ax,I_AND_AL_MEM ;and al,[xxxx]
543: stosw
544: lea eax,fr.ajM2C ; Set address of color munge
545: stosd
546: mov ebx,eax ; Save address
547: mov ax,I_XOR_AL_MEM ;xor al,[xxxx]
548: stosw
549: lea eax,1[ebx] ; Set address of XOR mask
550: stosd
551: jmp short cblt_3240
552:
553: ; Just need to generate the normal fetch sequence (lodsb)
554:
555: cblt_3180:
556: mov al,I_LODSB ;Generate source fetch
557: stosb
558:
559: subttl Compile - Phase Alignment
560: page
561: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
562: ; Generate the phase alignment if any.
563: ;
564: ; It is assumed that AL contains the source byte
565: ;
566: ; Currently:
567: ; DH = phase alignment
568: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
569:
570: cblt_3240:
571: mov ecx,edi ;end of fetch code
572: sub ecx,fr.start_fl ;start of fetch code
573: mov fr.cFetchCode,ecx ;save size of fetch code
574: xor ecx,ecx ;Might have garbage in it
575: or dh,dh ;Any phase alignment?
576: jz cblt_3280 ; No, so skip alignment
577: mov cl,dh ;Get horizontal phase for rotating
578: mov ax,I_ROL_AL_N ;Assume rotate left n times
579: cmp cl,5 ;4 or less rotates?
580: jc cblt_3260 ; Yes
581: neg cl ; No, compute ROR count
582: add cl,8
583: mov ah,HIGH I_ROR_AL_N
584: errnz <(LOW I_ROL_AL_N)-(LOW I_ROR_AL_N)>
585:
586: cblt_3260:
587: stosw ;Stuff the phase alignment rotates
588: mov al,cl ; then the phase alignment code
589: stosb
590:
591: ; Do not generate phase masking if there is only 1 src And only 1 dest byte.
592: ; This is not just an optimization, see comments where these flags are set.
593:
594: xor ch,ch
595: mov al,fr.first_fetch
596: and al,FF_ONLY_1_SRC_BYTE or FF_ONLY_1_DEST_BYTE
597: xor al,FF_ONLY_1_SRC_BYTE or FF_ONLY_1_DEST_BYTE
598: jz cblt_3280
599: mov esi,offset FLAT:phase_align
600: mov ecx,PHASE_ALIGN_LEN
601: rep movsb
602:
603: cblt_3280:
604: test fr.first_fetch,FF_TWO_INIT_FETCHES ;Generate another fetch?
605: jz cblt_4000 ; No
606:
607: ; A second fetch needs to be stuffed. Copy the one just created.
608:
609: mov esi,edi ;Get start of fetch logic
610: xchg esi,fr.start_fl ;Set new start, get old
611: mov ecx,edi ;Compute how long fetch is
612: sub ecx,esi ; and move the bytes
613: rep movsb
614:
615: subttl Compile - ROP Generation
616: page
617: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
618: ; Create the logic action code
619: ;
620: ; The given ROP will be converted into the actual code that
621: ; performs the ROP.
622: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
623:
624: ; Copy the ROP template into the BLT
625:
626: cblt_4000:
627: mov ax,fr.operands ;Get back rop data
628: mov bl,ah ;Get count of number of bits to move
629: and ebx,HIGH ROPLength
630: shr ebx,2
631: movzx ecx,roptable+256[ebx] ;Get length into cx
632: errnz ROPLength-0001110000000000b
633:
634: mov ebx,eax ;Get offset of the template
635: and ebx,ROPOffset
636: lea esi,roptable[ebx] ;--> the template
637: rep movsb ;Move the template
638:
639: cblt_4020:
640: mov bx,ax ;Keep rop around
641: or ah,ah ;Generate a negate?
642: jns cblt_4040 ; No
643: mov ax,I_NOT_AL
644: stosw
645:
646: public cblt_4040
647: cblt_4040:
648: mov fr.end_fl,edi ;Save end of fetch/logic operation
649:
650: subttl Compile - Mask And Save
651: page
652: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
653: ; Generate code to mask and save the result. If the destination
654: ; isn't in a register, it will be loaded from ES:[DI] first. The
655: ; mask operation will then be performed, and the result stored.
656: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
657:
658: mov ax,I_MOV_AH_DEST ; ah,[edi]
659: stosw
660:
661: mov esi,offset FLAT:masked_store;Move rest of masked store template
662: movsb ;Move size override
663: movsd
664: movsw
665: errnz MASKED_STORE_LEN-7 ;Must be seven bytes long
666: mov ax,fr.start_mask ;Stuff start mask into
667: xchg ah,al ; the template
668:
669: mov [edi][MASKED_STORE_MASK],ax
670:
671: mov fr.end_fls,edi ;Save end of fetch/logic/store operation
672:
673: subttl Compile - Inner Loop Generation
674: page
675: ;-----------------------------------------------------------------------;
676: ; Now for the hard stuff; The inner loop (said with a "gasp!").
677: ;
678: ; If there is no innerloop, then no code will be generated
679: ; (now that's fast!).
680: ;-----------------------------------------------------------------------;
681:
682: cblt_5000:
683: mov edx,fr.inner_loop_count ;Get the loop count
684: or dx,dx ;If the count is null
685: jz cblt_6000 ; don't generate any code
686:
687: ;!!! Since we no longer pass in the old style rops, we can;t enable this code
688: ;!!! and shold remove/alter it someday. Besides, most of it is in special.asm
689: if 0 ;!!!
690:
691: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
692: ; We have something for a loop count. If this just happens to be
693: ; a source copy (S) with a phase of zero, then the innerloop degenerates
694: ; to a repeated MOVSB instruction. This little special case is
695: ; worth checking for and handling!
696: ;
697: ; Also, if this is one of the special cases {P, Pn, DDx, DDxn}, then it
698: ; will also be special cased since these are all pattern fills (pattern,
699: ; not pattern, 0, 1).
700: ;
701: ; The same code can be shared for these routines, with the exception
702: ; that patterns use a STOSx instruction instead of a MOVSx instruction
703: ; and need a value loaded in AX
704: ;
705: ; So we lied a little. If a color conversion is going on, then the
706: ; REP MOVSB might not be usable. If the F1_REP_OK flag has been set, then
707: ; we can use it. The F1_REP_OK flag will be set for a mono ==> color
708: ; conversion where the background color is white and the foreground
709: ; color is black, or for a color ==> mono conversion with the screen
710: ; as the source (the color compare register will be used).
711: ;
712: ; For the special cases {P, Pn, DDx, DDxn}, color conversion is
713: ; not possible, so ignore it for them.
714: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
715:
716: mov bl,byte ptr fr.Rop ;Get the raster op
717: test bl,EPS_INDEX ;Can this be special cased?
718: jnz cblt_5500 ; No
719: errnz <HIGH EPS_INDEX>
720: errnz SPEC_PARSE_STR_INDEX ;The special case index must be 0
721:
722: test bl,EPS_OFF ;Is this a source copy
723: jz cblt_5040 ; Yes
724: errnz <SOURCE_COPY AND 11b> ;Offset for source copy must be 0
725:
726: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
727: ; We should have one of the following fill operations:
728: ;
729: ; P - Pattern
730: ; Pn - NOT pattern
731: ; DDx - 0 fill
732: ; DDxn - 1 fill
733: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
734:
735: mov ax,I_MOV_AL_0FFH ;Assume this is a 0 or 1 fill
736: test bl,01h ;Is it 0 or 1 fill?
737: jz cblt_5020 ; Yes, initialize AX with 0FFh
738: mov ax,I_MOV_AL_DH ; No, initialize AX with pattern
739:
740: errnz PAT_COPY-0000000000100001b
741: errnz NOTPAT_COPY-0000000000000001b
742: errnz FILL_BLACK-0000000001000010b
743: errnz FILL_WHITE-0000000001100010b
744:
745: cblt_5020:
746: stosw
747: mov ax,I_MOV_AH_AL
748: stosw
749: mov si,I_STOSB ;Set up for repeated code processor
750: test bl,LogPar ;If Pn or 0, then complement pattern
751: jnz cblt_5060 ; Is just P or 1
752: errnz <HIGH LogPar>
753: mov al,I_SIZE_OVERRIDE
754: stosb
755: mov ax,I_NOT_AX ; Is Pn or 0, complement AX
756: stosw
757: jmp short cblt_5060
758:
759: errnz PAT_COPY-00100001b
760: errnz NOTPAT_COPY-00000001b
761: errnz FILL_BLACK-01000010b
762: errnz FILL_WHITE-01100010b
763:
764:
765: ; This is a source copy. The phase must be zero for a source copy
766: ; to be condensed into a REP MOVSx.
767:
768: cblt_5040:
769: test fr.phase_h,0FFh ;Is horizontal phase zero?
770: jnz cblt_5500 ; No, can't condense source copy
771: mov si,I_MOVSB ;Set register for moving bytes
772:
773: ; For a color conversion, F1_REP_OK must be set.
774:
775: test fr.the_flags,F0_GAG_CHOKE ;Color conversion?
776: jz cblt_5060 ; No, rep is OK to use
777: test fr.moore_flags,F1_REP_OK ; Yes, can we rep it?
778: jz cblt_5500 ; No, do it the hard way
779:
780:
781: ;-----------------------------------------------------------------------;
782: ; This is a source copy or pattern fill. Process an odd byte with
783: ; a MOVSB or STOSB, then process the rest of the bytes with a REP
784: ; MOVSW or a REP STOSW. If the REP isn't needed, leave it out.
785: ;
786: ; Don't get caught on this like I did! If the direction of the
787: ; BLT is from right to left (decrementing addresses), then both
788: ; the source and destination pointers must be decremented by one
789: ; so that the next two bytes are processed, not the next byte and
790: ; the byte just processed. Also, after all words have been processed,
791: ; the source and destination pointers must be incremented by one to
792: ; point to the last byte (since the last MOVSW or STOSW would have
793: ; decremented both pointers by 2).
794: ;
795: ; If the target machine is an 8086, then it would be well worth the
796: ; extra logic to align the fields on word boundaries before the MOVSxs
797: ; if at all possible.
798: ;
799: ; The generated code should look something like:
800: ;
801: ; WARP8: ;This code for moving left to right
802: ; movsb ;Process an odd byte
803: ; mov ecx,gl_inner_loop_count/2 ;Set word count
804: ; rep ;If a count, then repeat is needed
805: ; movsw ;Move words until done
806: ;
807: ;
808: ; WARP8: ;This code for moving left to right
809: ; movsb ;Process an odd byte
810: ; dec si ;adjust pointer for moving words
811: ; dec di
812: ; mov ecx,gl_inner_loop_count/2 ;Set word count
813: ; rep ;If a count, then repeat is needed
814: ; movsw ;Move words until done
815: ; inc si ;adjust since words were moved
816: ; inc di
817: ;
818: ;
819: ; Of course, if any part of the above routine isn't needed, it isn't
820: ; generated (i.e. the generated code might just be a single MOVSB)
821: ;-----------------------------------------------------------------------;
822:
823: cblt_5060:
824: shr edx,1 ;Byte count / 2 for words
825: jnc cblt_5080 ; No odd byte to move
826: mov ax,si ; Odd byte, move it
827: stosb
828:
829: cblt_5080:
830: jz cblt_5140 ;No more bytes to move
831: xor bx,bx ;Flag as stepping from left to right
832: cmp bl,fr.step_direction ;Moving from the right to the left?
833: errnz STEPLEFT ; (left direction must be zero)
834: jnz cblt_5100 ; No
835: mov ax,I_DEC_ESI_DEC_EDI ; Yes, decrement both pointers
836: stosw
837: mov bx,I_INC_ESI_INC_EDI ;Set up to increment the pointers later
838:
839: 0cblt_5100:
840: cmp edx,1 ;Move one word or many words?
841: jz cblt_5120 ; Only one word
842: mov al,I_MOV_ECX_DWORD_I ; Many words, load count
843: stosb
844: mov eax,edx
845: stosd
846: mov al,I_REP ;a repeat instruction
847: stosb
848:
849: cblt_5120:
850: mov al,I_SIZE_OVERRIDE
851: stosb
852: mov ax,si ;Set the word instruction
853: inc ax
854: stosb
855: errnz I_MOVSW-I_MOVSB-1 ;The word form of the instruction
856: errnz I_STOSW-I_STOSB-1 ; must be the byte form + 1
857:
858: or bx,bx ;Need to increment the pointers?
859: jz cblt_5140 ; No
860: mov ax,bx ; Yes, increment both pointers
861: stosw
862:
863: cblt_5140:
864: jmp cblt_6000 ;Done setting up the innerloop
865: page
866:
867: endif
868:
869: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
870: ; There is some count for the innerloop of the BLT. Generate the
871: ; required BLT. Two or four copies of the BLT will be placed on the
872: ; stack. This allows the LOOP instruction at the end to be distributed
873: ; over two or four bytes instead of 1, saving 11 or 12 clocks for each
874: ; byte (for 4). Multiply 12 clocks by ~ 16K and you save a lot of
875: ; clocks!
876: ;
877: ; If there are less than four (two) bytes to be BLTed, then no looping
878: ; instructions will be generated. If there are more than four (two)
879: ; bytes, then there is the possibility of an initial jump instruction
880: ; to enter the loop to handle the modulo n result of the loop count.
881: ;
882: ; The innerloop code will look something like:
883: ;
884: ; < mov cx,loopcount/n> ;load count if >n innerloop bytes
885: ; < jmp short ??? > ;If a first jump is needed, do one
886: ;
887: ; BLTloop:
888: ; replicate initial byte BLT code up to n times
889: ;
890: ; < loop BLTloop > ;Loop until all bytes processed
891: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
892:
893: cblt_5500:
894: mov ebx,fr.end_fl ;Compute size of the fetch code
895: sub ebx,fr.start_fl
896: inc ebx ;A stosb will be appended
897: mov esi,4 ;Assume replication 4 times
898: mov cl,2 ; (shift count two bits left)
899: cmp ebx,32 ;Small enough for 4 times?
900: jc cblt_5520 ; Yes, replicate 4 times
901: shr esi,1 ; No, replicate 2 times
902: dec ecx
903:
904: cblt_5520:
905: cmp edx,esi ;Generate a loop? (edx = loopcount)
906: jle cblt_5540 ; No, just copy code
907: mov al,I_MOV_ECX_DWORD_I
908: stosb ;mov cx,loopcount/n
909: mov eax,edx ;Compute loop count
910: shr eax,cl
911: stosd
912: shl eax,cl ;See if loopcount MOD n is 0
913: sub eax,edx
914: jz cblt_5540 ;Zero, no odd count to handle
915:
916: page
917: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
918: ; There is an odd portion of bytes to be processed. Increment
919: ; the loop counter for the odd pass through the loop and then
920: ; compute the displacement for entering the loop.
921: ;
922: ; To compute the displacement, subtract the number of odd bytes
923: ; from the modulus being used (i.e. 4-3=1). This gives the
924: ; number of bytes to skip over the first time through the loop.
925: ;
926: ; Multiply this by the number of bytes for a logic sequence,
927: ; and the result will be the displacement for the jump.
928: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
929:
930: inc dword ptr [edi][-4] ;Not zero, adjust for partial loop
931: add eax,esi ;Compute where to enter the loop at
932: push edx
933: mul ebx
934: pop edx
935: mov ecx,eax
936: mov al,I_JMP_DISP32 ;Stuff jump instruction
937: stosb
938: mov eax,ecx ;Stuff displacement for jump
939: stosd
940:
941: ;-----------------------------------------------------------------------;
942: ; Currently: EDX = loop count
943: ; ESI = loop modulus
944: ; EBX = size of one logic operation
945: ; EDI --> next location in the loop
946: ;-----------------------------------------------------------------------;
947:
948: cblt_5540:
949: mov ecx,ebx ;Set move count
950: mov ebx,edx ;Set maximum for move
951: cmp ebx,esi ;Is the max > what's left?
952: jle cblt_5560 ; No, just use what's left
953: mov ebx,esi ; Yes, copy the max
954:
955: cblt_5560:
956: sub edx,esi ;If dx > 0, then loop logic needed
957: mov esi,fr.start_fl ;--> fetch code to copy
958: mov eax,ecx ;Save a copy of fetch length
959: rep movsb ;Move fetch code and stuff stosb
960: mov esi,edi ;--> new source (and top of loop)
961: sub esi,eax
962: mov byte ptr [edi][-1],I_STOSB
963: dec ebx ;One copy has been made
964: push edx
965: mul ebx ;Compute # bytes left to move
966: pop edx
967: mov ecx,eax ;Set move count
968: rep movsb ;Move the fetches
969: sub esi,eax ;Restore pointer to start of loop
970:
971: page
972:
973: ; The innermost BLT code has been created and needs the looping
974: ; logic added to it. If there is any looping to be done, then
975: ; generate the loop code. The code within the innerloop may be
976: ; greater than 126 bytes, so a LOOP instruction may not be used
977: ; in this case.
978:
979: cblt_5580:
980: or edx,edx ;Need a loop?
981: jle cblt_6000 ; No, don't generate one
982: mov al,I_DEC_ECX
983: stosb
984: mov ax,I_JNZ_DISP32
985: stosw
986: mov eax,esi ;Compute offset of loop
987: sub eax,edi
988: sub eax,4 ;Bias by DISP32
989: stosd
990:
991:
992: subttl Compile - Last Byte Processing
993: page
994: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
995: ; All the innerloop stuff has been processed. Now generate the code for
996: ; the final byte if there is one. This code is almost identical to the
997: ; code for the first byte except there will only be one fetch (if a
998: ; fetch is needed at all).
999: ;
1000: ; The code generated will look something like:
1001: ;
1002: ; < fetch > ;Get source byte
1003: ; < align > ;Align source if needed
1004: ; action ;Perform desired action
1005: ; mask and store
1006: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1007:
1008: cblt_6000:
1009: mov dx,fr.last_mask ;Get last byte mask
1010: or dh,dh ;Is there a last byte to be processed?
1011: jz cblt_6100 ; No.
1012:
1013: mov ecx,fr.end_fls ;Get end of fetch/logic/store operation
1014: mov esi,fr.start_fl ;Get start of fetch/logic sequence
1015: sub ecx,esi ;Compute length of the code
1016: test fr.first_fetch,FF_NO_LAST_FETCH
1017: jz cblt_include_fetch
1018: test fr.the_flags,F0_SRC_PRESENT ; was there a fetch?
1019: jz cblt_was_no_fetch
1020: cmp fr.phase_h,0 ; Phase zero case is not combined
1021: ; into innerloop as it should be.
1022: ; If the final byte is full then we
1023: ; better not remove the lodsb ( i.e.
1024: je cblt_include_fetch ; 0 - 0 = 0 would make us think we could)
1025:
1026: mov eax,fr.cFetchCode ; don't copy the fetch (lodsb)
1027: add esi,eax
1028: sub ecx,eax
1029:
1030: cblt_was_no_fetch:
1031: cblt_include_fetch:
1032:
1033: rep movsb ;Copy the fetch/action/store code
1034: xchg dh,dl
1035: mov [edi][MASKED_STORE_MASK],dx ;Stuff last byte mask into the code
1036: skip_save:
1037: subttl Compile - Looping Logic
1038: page
1039:
1040: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1041: ; Looping logic.
1042: ;
1043: ; The looping logic must handle monochrome bitmaps, color bitmaps,
1044: ; huge bitmaps, the device, the presence or absence of a source
1045: ; or pattern, and mono <==> color interactions.
1046: ;
1047: ; The type of looping logic is always based on the destination.
1048: ;
1049: ; Plane Update Facts:
1050: ;
1051: ; 1) If the destination device is color, then there will be
1052: ; logic for plane selection. Plane selection is performed
1053: ; at the start of the loop for the display. Plane selection
1054: ; for bitmaps is performed at the end of the loop in anticipation
1055: ; of the next plane.
1056: ;
1057: ; The following applies when the destination is color:
1058: ;
1059: ; a) The destination update consists of:
1060: ;
1061: ; 1) If the destination is the display, the next plane will
1062: ; be selected by the plane selection code at the start
1063: ; of the scan line loop.
1064: ;
1065: ; 2) If not the display, then the PDevice must a bitmap.
1066: ; The next plane will be selected by updating the
1067: ; destination offset by the next_plane value.
1068: ;
1069: ;
1070: ; b) If F0_GAG_CHOKE isn't specified, then there may be a source.
1071: ; If there is a source, it must be color, and the update
1072: ; consists of:
1073: ;
1074: ; 1) If the source is the display, the next plane will be
1075: ; selected by the plane selection code at the start of
1076: ; the loop.
1077: ;
1078: ; 2) If not the display, then the PDevice must a bitmap.
1079: ; The next plane will be selected by updating the
1080: ; destination offset by the next_plane value.
1081: ;
1082: ;
1083: ; c) If F0_GAG_CHOKE is specified, then the source must be a
1084: ; monochrome bitmap which is undergoing mono to color
1085: ; conversion. The AND & XOR mask table which is used
1086: ; for the conversion will have to be updated, unless
1087: ; the F1_NO_MUNGE flag is set indicating that the color
1088: ; conversion really wasn't needed.
1089: ;
1090: ; The source's pointer will not be updated. It will
1091: ; remain pointing to the same scan of the source until
1092: ; all planes of the destination have been processed.
1093: ;
1094: ;
1095: ; d) In all cases, the plane mask rotation code will be
1096: ; generated. If the plane indicator doesn't overflow,
1097: ; then start at the top of the scan line loop for the
1098: ; next plane.
1099: ;
1100: ; If the plane indicator overflows, then:
1101: ;
1102: ; 1) If there is a pattern present, it's a color
1103: ; pattern fetch. The index of which scan of
1104: ; the brush to use will have to be updated.
1105: ;
1106: ; 2) Enter the scan line update routine
1107: ;
1108: ;
1109: ; 2) If the destination is monochrome, then there will be no
1110: ; plane selection logic.
1111: ;
1112: ; If F0_GAG_CHOKE is specified, then color ==> mono conversion
1113: ; is taking place. Any plane selection logic is internal
1114: ; to the ROP byte fetch code. Any color brush was pre-
1115: ; processed into a monochrome brush, so no brush updating
1116: ; need be done
1117: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1118:
1119: subttl Looping Logic - Plane Selection
1120: page
1121:
1122: ; Get saved parameters off of the stack.
1123: ;
1124: ; < pop ebx > ;Get plane indicator
1125: ; < pop esi > ;Get source pointer
1126: ; pop edi ;Get destination pointer
1127: ; pop ecx ;Get loop count
1128:
1129: cblt_6100:
1130: mov bh,fr.the_flags ;These flags will be used a lot
1131: test bh,F0_DEST_IS_COLOR ;Is the destination color?
1132: jz cblt_6120 ; No
1133: mov al,I_POP_EBX ;Restore plane index
1134: stosb
1135:
1136: cblt_6120:
1137: test bh,F0_SRC_PRESENT ;Is a source needed?
1138: jz cblt_6140 ; No
1139: mov al,I_POP_ESI ; Yes, get source pointer
1140: stosb
1141:
1142: cblt_6140:
1143: mov ax,I_POP_EDI_POP_ECX ;Get destination pointer
1144: stosw ;Get loop count
1145: test bh,F0_DEST_IS_COLOR ;Color scanline update?
1146: jz cblt_6300 ; No, just do the mono scanline update
1147:
1148: ; The scanline update is for color. Generate the logic to update
1149: ; a brush, perform plane selection, process mono ==> color conversion,
1150: ; and test for plane overflow.
1151:
1152: cblt_6160:
1153: or bh,bh ;Color conversion?
1154: jns cblt_6180 ; No
1155: errnz F0_GAG_CHOKE-10000000b
1156:
1157: page
1158: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1159: ; The source is monochrome. Handle mono ==> color conversion.
1160: ; The AND & XOR mask table will need to be rotated for the next
1161: ; pass over the source.
1162: ;
1163: ; The source scanline pointer will not be updated until all planes
1164: ; have been processed for the current scan.
1165: ;
1166: ; If F1_NO_MUNGE has been specified, then the color conversion table
1167: ; and the color conversion code was not generated, and no update
1168: ; code will be needed.
1169: ;
1170: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1171:
1172: test fr.moore_flags,F1_NO_MUNGE ;Is there really a conversion table?
1173: jnz short cblt_6200 ; No, so skip the code
1174:
1175: mov al,I_MOV_EBP_DWORD_I ;lea ebp,fr.ajM2C
1176: stosb
1177: lea eax,fr.ajM2c ;Get address of table
1178: stosd
1179: mov esi,offset FLAT:rot_and_xor ;--> rotate code
1180: mov cx,LEN_ROT_AND_XOR
1181: rep movsb
1182: jmp short cblt_6200
1183:
1184: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1185: ; If there is a source, it must be color. If it is a memory
1186: ; bitmap, then the next plane must be selected, else it is
1187: ; the display and the next plane will be selected through
1188: ; the hardware registers.
1189: ;
1190: ; < add si,next_plane>
1191: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1192:
1193: cblt_6180:
1194: test bh,F0_SRC_PRESENT ;Is there really a source?
1195: jz cblt_6200 ;No source.
1196: test bh,F0_SRC_IS_DEV ;Is the source the display?
1197: jnz cblt_6200 ; Yes, use hardware plane selection
1198: mov ax,I_ADD_ESI_DWORD_I ; No, generate plane update
1199: stosw ;Add si,next_plane
1200: mov eax,fr.src.next_plane
1201: stosd
1202:
1203: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1204: ; If the destination isn't the device, then it must be a color
1205: ; memory bitamp, and it's pointer will have to be updated by
1206: ; bmWidthPlanes. If it is the display, then the next plane
1207: ; will be selected through the hardware registers.
1208: ;
1209: ; < add di,next_plane>
1210: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1211:
1212: cblt_6200:
1213: test bh,F0_DEST_IS_DEV ;Is the destination the display
1214: jnz cblt_6220 ; Yes, don't generate update code
1215: mov ax,I_ADD_EDI_DWORD_I ; No, update bitmap to the next plane
1216: stosw
1217: mov eax,fr.dest.next_plane
1218: stosd
1219:
1220:
1221: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1222: ; The source and destination pointers have been updated.
1223: ; Now generate the plane looping logic.
1224: ;
1225: ; < shl bl,1 > ;Select next plane
1226: ; < jnc StartOfLoop > ; Yes, go process next
1227: ; < mov bl,PLANE_1 > ;Reset plane indicator
1228: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1229:
1230: cblt_6220:
1231: mov ax,I_SHL_BL_1 ;Stuff plane looping logic
1232: stosw
1233:
1234: mov edx,fr.pNextPlane ;Compute relative offset of
1235: sub edx,edi ; start of loop
1236: sub edx,6 ;Bias offset by length of jnc inst.
1237: mov ax,I_JNC_DISP32
1238: stosw ;jnc StartOfLoop
1239: mov eax,edx
1240: stosd
1241:
1242: subttl Looping Logic - Color Brush Update
1243: page
1244:
1245: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1246: ; The plane update logic has been copied. If a pattern was
1247: ; involved for a color BLT, then the pattern index will need
1248: ; to be updated to the next scanline for three plane mode.
1249: ;
1250: ; This will involve subtracting off 3*SIZE_PATTERN (MonoPlane),
1251: ; and adding in the increment. The result must be masked with
1252: ; 00000111b to select the correct source. Note that the update
1253: ; can be done with an add instruction and a mask operation.
1254: ;
1255: ; inc index+MonoPlane inc-MonoPlane result AND 07h
1256: ;
1257: ; 1 0+32 = 32 1-32 = -31 1 1
1258: ; 1 7+32 = 39 1-32 = -31 8 0
1259: ; -1 0+32 = 32 -1-32 = -33 FF 7
1260: ; -1 7+32 = 39 -1-32 = -33 6 6
1261: ;
1262: ; < mov al,[12345678] > ;Get brush index
1263: ; < add al,n > ;Add displacement to next byte
1264: ; < and al,00000111b > ;Keep it in range
1265: ; < mov [12345678],al > ;Store displacement to next byte
1266: ;
1267: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1268:
1269: test bh,F0_PAT_PRESENT ;Is a pattern involved?
1270: jz cblt_6300 ; No
1271: test fr.brush_accel,SOLID_BRUSH
1272: jnz cblt_6300 ;Solid color fetch needs no updating
1273: mov al,I_MOV_AL_MEM
1274: stosb ;mov al,[xxxxxxxx]
1275: mov edx,fr.addr_brush_index
1276: mov eax,edx
1277: stosd
1278: mov al,I_ADD_AL_BYTE_I
1279: mov ah,fr.direction ;add al,bais
1280: sub ah,oem_brush_mono ;Anybody ever fly one of these things?
1281: errnz INCREASE-1 ;Must be a 1
1282: errnz DECREASE+1 ;Must be a -1
1283: stosw
1284: mov ax,0700h+I_AND_AL_BYTE_I ;and al,00000111b
1285: stosw
1286: mov al,I_MOV_MEM_AL
1287: stosb ;mov [xxxxxxxx],al
1288: mov eax,edx
1289: stosd
1290:
1291: subttl Looping Logic - Scan Line Update
1292: page
1293: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1294: ; Generate the next scanline code. The next scan line code must
1295: ; handle monochrome bitmaps, the device, the presence or absence
1296: ; of a source.
1297: ;
1298: ; Also color bitmaps, and mono <==> color interactions.
1299: ;
1300: ; < add si,gl_src.next_scan> ;Normal source scan line update
1301: ; add di,gl_dest.next_scan ;Normal destination scan line update
1302: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
1303:
1304: ;!!! We have the problem in that this code assumes that cPlanes*cjBytesScan
1305: ;!!! is the same as next_scan. This might not always be the case, and we
1306: ;!!! should do somehting about fixing this. This would require pushing an
1307: ;!!! extra copy of pScan_n_Plane0 and then adding next-scan to this when we
1308: ;!!! have exhausted the planes for scan n
1309:
1310: cblt_6300:
1311: test bh,F0_SRC_PRESENT ;Is there a source?
1312: jz cblt_6340 ; No, skip source processing
1313: mov ax,I_ADD_ESI_DWORD_I ;add esi,increment
1314: stosw
1315: mov eax,fr.src.next_scan
1316: stosd
1317:
1318: cblt_6340:
1319: mov ax,I_ADD_EDI_DWORD_I ;add edi,increment
1320: stosw
1321: mov eax,fr.dest.next_scan
1322: stosd
1323:
1324: ; Compile the scan line loop. The code simply jumps to the start
1325: ; of the outer loop if more scans exist to be processed.
1326:
1327: cblt_6380:
1328: mov al,I_DEC_ECX
1329: stosb
1330: mov ax,I_JNZ_DISP32
1331: stosw
1332: mov eax,fr.blt_addr ;Compute relative offset of
1333: sub eax,edi ; start of loop
1334: sub eax,4 ;Adjust jump bias for DISP32
1335: stosd ; and store it into jump
1336:
1337: cblt_6420:
1338: mov al,I_RET ;Stuff the far return instruction
1339: stosb
1340:
1341: cRet cblt
1342: endProc cblt
1343:
1344: _TEXT$01 ends
1345:
1346: end
1347:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.