![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to blt.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 blt.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: blt.asm ! 5: ; ! 6: ; Copyright (c) 1992 Microsoft Corporation ! 7: ;-----------------------------------------------------------------------; ! 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: .code ! 24: ! 25: _TEXT$02 SEGMENT DWORD USE32 PUBLIC 'CODE' ! 26: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING ! 27: ! 28: .xlist ! 29: include stdcall.inc ; calling convention cmacros ! 30: ! 31: include i386\cmacFLAT.inc ; FLATland cmacros ! 32: include i386\display.inc ; Display specific structures ! 33: include i386\ppc.inc ; Pack pel conversion structure ! 34: include i386\bitblt.inc ; General definitions ! 35: include i386\ropdefs.inc ; Rop definitions ! 36: include i386\roptable.inc ; Raster op tables ! 37: include i386\egavga.inc ; EGA register definitions ! 38: include i386\strucs.inc ; Structure definitions ! 39: .list ! 40: ! 41: ! 42: EXTRNP cblt ! 43: EXTRNP check_device_special_cases ! 44: EXTRNP packed_pel_comp_y ! 45: EXTRNP vDIB4Preprocess ! 46: EXTRNP vDIB8Preprocess ! 47: ! 48: ; The following two bitmask tables are used for fetching ! 49: ; the first and last byte used-bits bitmask. ! 50: ! 51: public bitmask_tbl1 ! 52: bitmask_tbl1 label byte ! 53: db 11111111b ;Masks for leftmost byte ! 54: db 01111111b ! 55: db 00111111b ! 56: db 00011111b ! 57: db 00001111b ! 58: db 00000111b ! 59: db 00000011b ! 60: db 00000001b ! 61: ! 62: public bitmask_tbl2 ! 63: bitmask_tbl2 label byte ! 64: db 10000000b ;Masks for rightmost byte ! 65: db 11000000b ! 66: db 11100000b ! 67: db 11110000b ! 68: db 11111000b ! 69: db 11111100b ! 70: db 11111110b ! 71: db 11111111b ! 72: ! 73: ; phase_tbl1 is used for loading the "used" bits and "saved" bits ! 74: ; bitmasks for cases 1,2,3 where the step direction is left to ! 75: ; right. If it weren't for the case of zero, this could be done ! 76: ; with a simple rotate of 00FF. For cases 4,5,6, a simple rotate ! 77: ; can create the mask needed. ! 78: ! 79: public phase_tbl1 ! 80: phase_tbl1 label word ! 81: db 11111111b,00000000b ;Used bits, saved bits ! 82: db 00000001b,11111110b ! 83: db 00000011b,11111100b ! 84: db 00000111b,11111000b ! 85: db 00001111b,11110000b ! 86: db 00011111b,11100000b ! 87: db 00111111b,11000000b ! 88: db 01111111b,10000000b ! 89: ! 90: ProcName xxxvCompiledBlt,vCompiledBlt,56 ! 91: ! 92: xxxvCompiledBlt proc uses esi edi ebx,\ ! 93: __pdsurfDst :ptr, \ ! 94: __DestxOrg :dword, \ ! 95: __DestyOrg :dword, \ ! 96: __pdsurfSrc :ptr, \ ! 97: __SrcxOrg :dword, \ ! 98: __SrcyOrg :dword, \ ! 99: __xExt :dword, \ ! 100: __yExt :dword, \ ! 101: __Rop :dword, \ ! 102: __lpPBrush :ptr, \ ! 103: __bkColor :dword, \ ! 104: __TextColor :dword, \ ! 105: __pulXlateVec :dword, \ ! 106: __pptlBrush :ptr ! 107: ! 108: local fr[SIZE FRAME]:byte ! 109: ! 110: cld ;Let's make no assumptions about this! ! 111: ! 112: ; We be hacking, so copy all the parameters into the local frame right now, ! 113: ; so that the subroutines will have access to them. ! 114: ! 115: mov eax,__pdsurfDst ! 116: mov fr.pdsurfDst,eax ! 117: mov eax,__DestxOrg ! 118: mov fr.DestxOrg,ax ! 119: mov eax,__DestyOrg ! 120: mov fr.DestyOrg,ax ! 121: mov eax,__pdsurfSrc ! 122: mov fr.pdsurfSrc,eax ! 123: mov eax,__SrcxOrg ! 124: mov fr.SrcxOrg,ax ! 125: mov eax,__SrcyOrg ! 126: mov fr.SrcyOrg,ax ! 127: mov eax,__xExt ! 128: mov fr.xExt,ax ! 129: mov eax,__yExt ! 130: mov fr.yExt,ax ! 131: mov eax,__Rop ! 132: mov fr.Rop,eax ! 133: mov eax,__lpPBrush ! 134: mov fr.lpPBrush,eax ! 135: mov eax,__bkColor ! 136: mov fr.bkColor,eax ! 137: mov eax,__TextColor ! 138: mov fr.TextColor,eax ! 139: mov eax,__pulXlateVec ! 140: mov fr.ppcBlt.pulXlate,eax ! 141: mov eax,__pptlBrush ! 142: mov fr.pptlBrush,eax ! 143: ! 144: subttl ROP Preprocessing ! 145: page ! 146: ! 147: ;-----------------------------------------------------------------------; ! 148: ; Get the encoded raster operation, and map the raster op if needed. ! 149: ; ! 150: ; To map the ROPS 80h through FFh to 00h through 7Fh, take the ! 151: ; 1's complement of the ROP, and invert the "negate needed" flag. ! 152: ;-----------------------------------------------------------------------; ! 153: ! 154: xor ax,ax ;Assume not 80h : FFh ! 155: mov bl,byte ptr fr.Rop ! 156: or bl,bl ;Is this in the second half (80-FF)? ! 157: jns parse_10 ; No, rop index is correct ! 158: not bl ; Yes, want the inverse ! 159: mov ah,HIGH NEGATE_NEEDED ;Want to invert the not flag ! 160: errnz <LOW NEGATE_NEEDED> ! 161: ! 162: parse_10: ! 163: movzx ebx,bl ! 164: xor ax,roptable[ebx*2] ;Get ROP, maybe toggle negate flag ! 165: mov fr.operands,ax ;Save the encoded raster operation ! 166: ! 167: mov bl,ah ;Set fr.the_flags for source and pattern ! 168: and bl,HIGH (SOURCE_PRESENT+PATTERN_PRESENT) ! 169: ror bl,1 ! 170: ! 171: errnz <SOURCE_PRESENT - 0010000000000000b> ! 172: errnz <PATTERN_PRESENT - 0100000000000000b> ! 173: errnz <F0_SRC_PRESENT - 00010000b> ! 174: errnz <F0_PAT_PRESENT - 00100000b> ! 175: ! 176: parse_end: ! 177: ! 178: ! 179: ;-----------------------------------------------------------------------; ! 180: ; pdevice_processing ! 181: ; ! 182: ; Check the required bitmaps for validity, get their parameters ! 183: ; and store the information locally. ! 184: ; ! 185: ; BL = Initial fr.the_flags ! 186: ; F0_SRC_PRESENT set if source needed ! 187: ; F0_PAT_PRESENT set if pattern needed ! 188: ;-----------------------------------------------------------------------; ! 189: ! 190: xor bh,bh ;BH = real fr.the_flags ! 191: mov fr.ppcBlt.fb,bh ;No packed pel converison ! 192: test bl,F0_SRC_PRESENT ;Is a source needed? ! 193: jz pdevice_decode_dest ; No, skip source validation ! 194: mov esi,fr.pdsurfSrc ;Get pointer to source ! 195: lea edi,fr.src ;--> where parameters will go ! 196: push ebp ! 197: lea ebp,fr.ppcBlt ! 198: cCall copy_dev ;Get all the data ! 199: pop ebp ! 200: test fr.ppcBlt.fb,PPC_NEEDED ;Will we be converting from packed pel? ! 201: jz pdevice_decode_dest ; No ! 202: MovAddr eax,vDIB8Preprocess,0 ! 203: cmp fr.ppcBlt.iFormat,BMF_8BPP ! 204: je short @F ! 205: MovAddr eax,vDIB4Preprocess,0 ! 206: @@: ! 207: push ebp ; Yes, do serious messing around ! 208: lea ebp,fr ; Needs a frame pointer ! 209: call eax ! 210: pop ebp ! 211: ! 212: pdevice_decode_dest: ! 213: mov esi,fr.pdsurfDst ;Get pointer to destination ! 214: lea edi,fr.dest ;--> where parameters will go ! 215: cCall copy_dev ;Get all the data ! 216: ! 217: ; The pattern fetch code will be based on the color format of the ! 218: ; destination. If the destination is mono, then a mono fetch will be ! 219: ; performed. If the destination is color, then a color fetch will be ! 220: ; performed. ! 221: ! 222: or bh,bl ;Merge in F0_SRC_PRESENT, F0_PAT_PRESENT ! 223: test bh,F0_DEST_IS_COLOR ;Show color pattern needed if ! 224: jz pdevice_chk_color_conv ; destination is color ! 225: or bh,F0_COLOR_PAT ! 226: ! 227: ; Check for color conversion. If so, then set F0_GAG_CHOKE. ! 228: ; Color conversion will exist if the source and destination are of ! 229: ; different color formats. ! 230: ! 231: pdevice_chk_color_conv: ! 232: test bh,F0_SRC_PRESENT ;Is there a source? ! 233: jz pdevice_set_dest_flag ; No, cannot be converting. ! 234: mov al,bh ! 235: and al,F0_SRC_IS_COLOR+F0_DEST_IS_COLOR ! 236: jz pdevice_set_src_flag ;Both are monochrome ! 237: xor al,F0_SRC_IS_COLOR+F0_DEST_IS_COLOR ! 238: jz pdevice_set_src_flag ;Both are color ! 239: or bh,F0_GAG_CHOKE ;Mono ==> color or color ==> mono ! 240: mov al,fr.bkColor.SPECIAL ! 241: mov ah,fr.TextColor.SPECIAL ! 242: errnz C0_BIT+C1_BIT+C2_BIT+C3_BIT-0Fh ! 243: and ax,0F0Fh ! 244: mov fr.both_colors,ax ! 245: ! 246: ; Setup the scan line update flag in the source device structure. ! 247: ; The source will use a monochrome style update if it is the display, ! 248: ; it is monochrome, or it is color and the destination device is ! 249: ; monochrome. ! 250: ! 251: pdevice_set_src_flag: ! 252: mov al,bh ;Set 'Z' if to use color update ! 253: and al,F0_SRC_IS_DEV+F0_SRC_IS_COLOR+F0_DEST_IS_COLOR ! 254: xor al,F0_SRC_IS_COLOR+F0_DEST_IS_COLOR ! 255: jnz pdevice_set_dest_flag ;Use the mono update ! 256: or fr.src.dev_flags,COLOR_UP;Show color scan update ! 257: ! 258: ; Setup the scan line update flag in the destination device ! 259: ; structure. The destination will use a monochrome update ! 260: ; if it is monochrome or the display. It will use a color ! 261: ; update if it is a color bitmap. ! 262: ! 263: pdevice_set_dest_flag: ! 264: mov al,bh ;Set 'Z' if to use color destination ! 265: and al,F0_DEST_IS_DEV+F0_DEST_IS_COLOR; update code ! 266: xor al,F0_DEST_IS_COLOR ! 267: jnz pdevice_proc_end ;Mono update ! 268: or fr.dest.dev_flags,COLOR_UP;Show color scan update ! 269: pdevice_proc_end: ! 270: ! 271: ! 272: push ebp ;Set up pointer to frame variables ! 273: lea ebp,fr ! 274: cCall pattern_preprocessing ! 275: pop ebp ! 276: ! 277: subttl Phase Processing (X) ! 278: page ! 279: ! 280: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ; ! 281: ; Now the real work comes along: In which direction will the ! 282: ; copy be done? Refer to the 10 possible types of overlap that ! 283: ; can occur (10 cases, 4 resulting types of action required). ! 284: ; ! 285: ; If there is no source bitmap involved in this particular BLT, ! 286: ; then the path followed must allow for this. This is done by ! 287: ; setting both the destination and source parameters equal. ! 288: ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ; ! 289: ! 290: phase_processing: ! 291: phase_processing_x: ! 292: mov dx,fr.xExt ;Get X extent ! 293: dec dx ;Make X extent inclusive ! 294: mov bx,fr.DestxOrg ;Get destination X origin ! 295: mov di,bx ! 296: and bx,00000111b ;Get offset of destination within byte ! 297: ! 298: ; If there is no source, then just use the pointer to the destination ! 299: ; bitmap and load the same parameters, which will cause the "equality" ! 300: ; path to be followed in the set-up code. This path is the favored ! 301: ; path for the case of no source bitmap. ! 302: ! 303: mov ax,di ;Assume no source needed ! 304: test fr.the_flags,F0_SRC_PRESENT;Is a source needed? ! 305: jz phase_proc_10 ; No, just use destination parameters ! 306: mov ax,fr.SrcxOrg ; Yes, get source origin X ! 307: mov fr.first_fetch,FF_TWO_INIT_FETCHES ! 308: ; Assume two initial fetches (if no ! 309: ; source, then it will be set = 1 ! 310: ; later) ! 311: phase_proc_10: ! 312: mov si,ax ! 313: and ax,00000111b ;Get offset of source within byte ! 314: cmp si,di ;Which direction will we be moving? ! 315: jl phase_proc_30 ;Move from right to left ! 316: ! 317: ; The starting X of the source rectangle is >= the starting X of ! 318: ; the destination rectangle, therefore we will be moving bytes ! 319: ; starting from the left and stepping right. ! 320: ; ! 321: ; Alternatively, this is the path taken if there is no source ! 322: ; bitmap for the current BLT. ! 323: ; ! 324: ; Rectangle cases: 3,4,5,6,8 ! 325: ! 326: sub al,bl ;Compute horiz. phase (source-dest) ! 327: mov fr.step_direction,STEPRIGHT ;Set direction of move ! 328: movzx ebx,bx ! 329: mov ah,[ebx].bitmask_tbl1 ;Get starting byte mask ! 330: ja phase_proc_two_fetches ;Scan line case 2, everything is ! 331: ; already set for this case. ! 332: ! 333: ; Scan line cases 1 and 3: ! 334: ; ! 335: ; The correct first byte fetch needs to be set for the beginning ! 336: ; of the outer loop, and the phase must be made into a positive ! 337: ; number. ! 338: ; ! 339: ; This is the path that will be followed if there is no source bitmap ! 340: ; for the current BLT. ! 341: ! 342: mov fr.first_fetch,FF_ONE_INIT_FETCH;Set one initial fetch ! 343: jmp short pp_only_one_init_fetch ! 344: ! 345: ;-----------------------------------------------------------------------; ! 346: ; If we get all the bits we need in the first fetch then a second ! 347: ; (unnecessary) fetch could cause a GP Fault. So let's examine this: ! 348: ; The number of bits from (SI mod 8) to the end of the byte is the number ! 349: ; of available bits we get on the first fetch. This is (8 - (SI mod 8)). ! 350: ; If this is greater than or equal to xExt then we have all the bits we ! 351: ; need and we better not do the second fetch (even though the phase ! 352: ; relationship may suggest we need it). ! 353: ; ! 354: ; Conclusion: If (8 - (SI mod 8)) >= xExt then DO NOT make second fetch. ! 355: ;-----------------------------------------------------------------------; ! 356: ! 357: phase_proc_two_fetches: ! 358: mov cx,8 ! 359: sub cl,bl ! 360: sub cl,al ! 361: ! 362: ; We can save a couple cycles here since xExt - 1 is already in DX. ! 363: ; The condition CX >= xExt is the same as CX > DX. ! 364: ! 365: cmp cx,dx ;CX = (SI mod 8), DX = (xExt - 1) ! 366: jle pp_second_fetch_really_needed ! 367: ! 368: ! 369: ;-----------------------------------------------------------------------; ! 370: ; We are here BECAUSE the xExt is so small that we can get all the bits ! 371: ; on the scanline with a single lodsb (no byte boundary is crossed) AND ! 372: ; the phase relationship indicates that a second initial fetch is needed. ! 373: ; ! 374: ; We will override it and only do one fetch. However, if we simply ! 375: ; fail to do the second fetch then the phase code will screw us. ! 376: ; It will be expecting the bits to get fetched in the first fetch, saved ! 377: ; after the rotate, and mixed in in the second fetch's phase code. ! 378: ; So after the first fetch the bits have been saved in BH, and ANDed out ! 379: ; of the src data in AL. ! 380: ; ! 381: ; The solution is to set a flag here that tells the phase generation code ! 382: ; not to generate the usual masking part of the phase code. ! 383: ; ! 384: ; Short Bitblt Cases: (8 bits or less) ! 385: ; ! 386: ; 1) neither crosses byte boundary. ! 387: ; ! 388: ; a) phase requires second initial fetch ! 389: ; ! 390: ; Kill the phase masking. It will screw us. There will ! 391: ; be just one lodsb and one stosb and the first byte mask ! 392: ; will protect the dest bits that should not get hit. ! 393: ; ! 394: ; b) phase requires only one initial fetch ! 395: ; ! 396: ; Phase masking is irrelevant. Removing it would ! 397: ; be an optimiztation. ! 398: ; ! 399: ; 2) dest crosses byte boundary, but src does not ! 400: ; ! 401: ; a) phase requires second initial fetch ! 402: ; ! 403: ; impossible situation: the way we determine that a 2nd fetch ! 404: ; is necessary is if the first fetch does not get enough needed ! 405: ; bits to satisfy the first dest byte. Here the first fetch ! 406: ; gets ALL the bits and the first dest byte needs less than ! 407: ; ALL because it crosses a byte boundary. ! 408: ; ! 409: ; b) phase requires only one initial fetch ! 410: ; ! 411: ; Intervention would be bad. None is necessary since the 2nd ! 412: ; initial fetch will not be done. If we do intervene we will ! 413: ; cause trouble: Killing the masking will prevent the ! 414: ; "saved bits" from being saved. The first byte masking ! 415: ; can kill off these bits in AL and they will never ! 416: ; make it to the second stosb. ! 417: ; ! 418: ; 3) src crosses byte boundary (dest may or may not) ! 419: ; (this is known to be untrue at this point) ! 420: ; ! 421: ; There are bits we need in the second fetch, so a second ! 422: ; initial fetch can not cause a GP fault. Therefore do ! 423: ; everything the same as we would have before. ! 424: ; ! 425: ; ! 426: ; Conclusion: Intervention to kill the phase masking is ! 427: ; necessary iff ! 428: ; [src does not cross byte boundary] AND ! 429: ; dest does not cross byte boundary AND ! 430: ; [phase requires second initial fetch]. ! 431: ; and bad if ! 432: ; dest crosses byte boundary, but [src does not] ! 433: ; ! 434: ; Statements in [] are known to be true at this point. ! 435: ; ! 436: ; Solution: ! 437: ; ! 438: ; If we always kill the phase-masking when neither crosses a byte ! 439: ; boundary and never kill it otherwise then everyone will be happy ! 440: ; (regardless of other conditions like whether phase requests a 2nd ! 441: ; initial fetch). ! 442: ;-----------------------------------------------------------------------; ! 443: ! 444: mov fr.first_fetch,FF_ONLY_1_SRC_BYTE ! 445: .errnz FF_ONE_INIT_FETCH ! 446: ! 447: pp_second_fetch_really_needed: ! 448: pp_only_one_init_fetch: ! 449: mov ch,ah ! 450: ! 451: ;-----------------------------------------------------------------------; ! 452: ; We now have the correct phase and the correct first character fetch ! 453: ; routine set. Save the phase and ... ! 454: ; ! 455: ; currently: AL = phase ! 456: ; BL = dest start mod 8 ! 457: ; CH = first byte mask ! 458: ; DX = inclusive X bit count ! 459: ; SI = source X start (if there is a source) ! 460: ; DI = destination X start ! 461: ;-----------------------------------------------------------------------; ! 462: ! 463: phase_proc_20: ! 464: add al,8 ;Phase must be positive ! 465: and al,00000111b ! 466: ! 467: ; To calculate the last byte mask, the inclusive count can be ! 468: ; added to the start X MOD 8 value, and the result taken MOD 8. ! 469: ; This is attractive since this is what is needed later for ! 470: ; calculating the inclusive byte count, so save the result ! 471: ; of the addition for later. ! 472: ! 473: add bx,dx ;Add inclusive extent to dest MOD 8 ! 474: mov dx,bx ;Save for innerloop count !!! ! 475: and ebx,00000111b ;Set up bx for a base reg ! 476: mov cl,[ebx].bitmask_tbl2 ;Get last byte mask ! 477: ! 478: ;-----------------------------------------------------------------------; ! 479: ; To avoid GP faults, we must never do an extra fetch we don't need. ! 480: ; When we're ready for the last fetch there may already be enough bits ! 481: ; saved from the previous fetch (which we plan to combine with the bits ! 482: ; in the fetch we are about to do). If so then we'd better not do this ! 483: ; last fetch (it could cause a GP fault). ! 484: ; ! 485: ; The number of bits we have left from the previous byte is (8 - AL) ! 486: ; AL is the phase. (1 + BL) is the number of bits we actually need ! 487: ; to write to the final destination byte. ! 488: ; ! 489: ; So if (8 - AL) >= (1 + BL) then DO NOT do the last fetch. This ! 490: ; simplifies: if (BL + AL) <= 7 then DO NOT do the last fetch. ! 491: ;-----------------------------------------------------------------------; ! 492: ! 493: add bl,al ! 494: cmp bl,7 ! 495: jg phase_proc_last_fetch_needed ! 496: or fr.first_fetch,FF_NO_LAST_FETCH ! 497: phase_proc_last_fetch_needed: ! 498: ! 499: mov bl,al ;Compute offset into phase mask table ! 500: movzx ebx,bx ! 501: mov bx,[ebx*2].phase_tbl1 ;Get the phase mask ! 502: ! 503: ; Currently: ! 504: ; AL = phase ! 505: ; BX = phase mask ! 506: ; CL = last byte mask ! 507: ; CH = first byte mask ! 508: ; DX = inclusive bit count + dest start MOD 8 ! 509: ; SI = source X start (if there is a source) ! 510: ; DI = destination starting X ! 511: ! 512: jmp phase_proc_50 ;Finish here ! 513: ! 514: ; The starting X of the source rectangle is < the X of the destination ! 515: ; rectangle, therefore we will be moving bytes starting from the right ! 516: ; and stepping left. ! 517: ; ! 518: ; This code should never be reached if there is no source bitmap ! 519: ; for the current BLT. ! 520: ; ! 521: ; Rectangle cases: 1,2,7 ! 522: ! 523: phase_proc_30: ! 524: mov fr.step_direction,ah ;Set direction of move ! 525: errnz STEPLEFT ! 526: movzx ebx,bx ! 527: mov cl,[ebx].bitmask_tbl1 ;Get last byte mask ! 528: push bx ! 529: add ax,dx ;Find end of the source ! 530: ! 531: ; To calculate the first byte mask, the inclusive count is ! 532: ; added to the start MOD 8 value, and the result taken MOD 8. ! 533: ; This is attractive since this is what is needed later for ! 534: ; calculating the inclusive byte count, so save the result ! 535: ; of the addition for later. ! 536: ! 537: add bx,dx ;Find end of the destination ! 538: add di,dx ;Will need to update dest start address ! 539: add si,dx ; and source's too ! 540: mov dx,bx ;Save inclusive bit count + start MOD 8 ! 541: and ax,00000111b ;Get source offset within byte ! 542: and ebx,00000111b ;Get dest offset within byte ! 543: mov ch,[ebx].bitmask_tbl2 ;Get start byte mask ! 544: cmp al,bl ;Compute horiz. phase (source-dest) ! 545: jb pp_double_fetch ;Scan line case 5, everything is ! 546: ; already set for this case. ! 547: ! 548: ; Scan line cases 4 and 6: ! 549: ; ! 550: ; The correct first byte fetch needs to be set for the beginning ! 551: ; of the outer loop ! 552: ! 553: mov fr.first_fetch,FF_ONE_INIT_FETCH;Set initial fetch routine ! 554: jmp short pp_one_initial_fetch ! 555: ! 556: ;-----------------------------------------------------------------------; ! 557: ; If only-one-fetch is already set, then the following is a NOP. ! 558: ; It doesn't seem worth the effort to check and jmp around. ! 559: ; ! 560: ; If we get all the bits we need in the first fetch then a second ! 561: ; (unnecessary) fetch could cause a GP Fault. So let's examine this: ! 562: ; ! 563: ; (DX + SI) points to the first pel (remember we're stepping left). ! 564: ; So the number of needed bits we get in the first fetch is ! 565: ; ((DX + SI + 1) mod 8). This is currently equal to AX. ! 566: ; If AX >= xExt then we'd better not do two init fetches. ! 567: ;-----------------------------------------------------------------------; ! 568: ! 569: pp_double_fetch: ! 570: dec fr.xExt ! 571: cmp ax,fr.xExt ! 572: jl pp_double_fetch_really_needed ! 573: mov fr.first_fetch,FF_ONLY_1_SRC_BYTE ! 574: .errnz FF_ONE_INIT_FETCH ! 575: pp_double_fetch_really_needed: ! 576: inc fr.xExt ! 577: ! 578: pp_one_initial_fetch: ! 579: sub al,bl ;Compute horiz. phase (source-dest) ! 580: add al,8 ;Ensure phase positive ! 581: and al,00000111b ! 582: ! 583: ;-----------------------------------------------------------------------; ! 584: ; To avoid GP faults must never do an extra fetch we don't need. ! 585: ; The last byte fetch is unnecessary if Phase is greater than or equal ! 586: ; to 8 - BL. Phase is the number of bits we still have from the previous ! 587: ; fetch. 8 - BL is the number of bits we actually need to write to the ! 588: ; final destination byte. So if AL - (8 - BL) >= 0 skip the last fetch. ! 589: ;-----------------------------------------------------------------------; ! 590: ! 591: pop bx ! 592: add bl,al ! 593: sub bl,8 ! 594: jl pp_need_last_fetch ! 595: or fr.first_fetch,FF_NO_LAST_FETCH ! 596: pp_need_last_fetch: ! 597: phase_proc_40: ! 598: ! 599: ;-----------------------------------------------------------------------; ! 600: ; We now have the correct phase and the correct first character fetch ! 601: ; routine set. Generate the phase mask and save it. ! 602: ; ! 603: ; currently: AL = phase ! 604: ; CH = first byte mask ! 605: ; CL = last byte mask ! 606: ; DX = inclusive bit count + start MOD 8 ! 607: ! 608: mov ah,cl ;Save last mask ! 609: mov cl,al ;Create the phase mask ! 610: mov bx,00FFh ; by shifting this ! 611: shl bx,cl ; according to the phase ! 612: mov cl,ah ;Restore last mask ! 613: ; jmp phase_proc_50 ;Go compute # of bytes to BLT ! 614: errn$ phase_proc_50 ! 615: ! 616: ! 617: ; The different processing for the different X directions has been ! 618: ; completed, and the processing which is the same regardless of ! 619: ; the X direction is about to begin. ! 620: ; ! 621: ; The phase mask, the first/last byte masks, the X byte offsets, ! 622: ; and the number of innerloop bytes must be calculated. ! 623: ; ! 624: ; ! 625: ; Nasty stuff coming up here! We now have to determine how ! 626: ; many bits will be BLTed and how they are aligned within the bytes. ! 627: ; This is how it's done (or how I'm going to do it): ! 628: ; ! 629: ; The number of bits (inclusive number that is) is added to the ! 630: ; start MOD 8 value ( the left side of the rectangle, minimum X ! 631: ; value), then the result is divided by 8. Then: ! 632: ; ! 633: ; ! 634: ; 1) If the result is 0, then only one destination byte is being ! 635: ; BLTed. In this case, the start & ending masks will be ANDed ! 636: ; together, the innerloop count (# of full bytes to BLT) will ! 637: ; be zeroed, and the fr.last_mask set to all 0's (don't alter any ! 638: ; bits in last byte which will be the byte following the first ! 639: ; (and only) byte). ! 640: ; ! 641: ; | x x x x x| | ! 642: ; |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| ! 643: ; 0 1 2 3 4 5 6 7 ! 644: ; ! 645: ; start MOD 8 = 3, extent-1 = 4 ! 646: ; 3+7 DIV 8 = 0, only altering one byte ! 647: ; ! 648: ; ! 649: ; ! 650: ; 2) If the result is 1, then only two bytes will be BLTed. ! 651: ; In this case, the start and ending masks are valid, and ! 652: ; all that needs to be done is set the innerloop count to 0. ! 653: ; (it is true that the last byte could have all bits affected ! 654: ; the same as if the innerloop count was set to 1 and the ! 655: ; last byte mask was set to 0, but I don't think there would be ! 656: ; much time saved special casing this). ! 657: ; ! 658: ; | x x x x x x x|x x x x x x x| ! 659: ; |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| ! 660: ; 0 1 2 3 4 5 6 7 ! 661: ; ! 662: ; start MOD 8 = 1, extent-1 = 14 ! 663: ; 3+14 DIV 8 = 1. There is a first and last ! 664: ; byte but no innerloop count ! 665: ; ! 666: ; ! 667: ; ! 668: ; 3) If the result is >1, then there is some number of entire ! 669: ; bytes to be BLted by the innerloop. In this case the ! 670: ; number of innerloop bytes will be the result - 1. ! 671: ; ! 672: ; | x|x x x x x x x x|x ! 673: ; |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| ! 674: ; 0 1 2 3 4 5 6 7 ! 675: ; ! 676: ; start MOD 8 = 7, extent-1 = 9 ! 677: ; 7+9 DIV 8 = 2. There is a first and last ! 678: ; byte and an innerloop count of 1 (result - 1) ! 679: ; ! 680: ; Currently: AL = horizontal phase ! 681: ; BX = horizontal phase mask ! 682: ; CH = first byte mask ! 683: ; CL = last byte mask ! 684: ; DX = left side X MOD 8 + inclusive X count ! 685: ; SI = source start X ! 686: ; DI = dest start X ! 687: ! 688: phase_proc_50: ! 689: mov fr.phase_h,al ;Save horizontal phase ! 690: mov fr.mask_p,bx ;Save phase mask ! 691: shr dx,3 ;/8 to get full byte count ! 692: jnz phase_proc_60 ;Result is >0, check it out ! 693: ! 694: ; There will only be one byte affected. Therefore the two byte masks ! 695: ; must be combined, the last byte mask cleared, and the innerloop ! 696: ; count set to zero. ! 697: ! 698: or fr.first_fetch,FF_ONLY_1_DEST_BYTE ! 699: and ch,cl ;Combine the two masks ! 700: xor cl,cl ;Clear out the last byte mask ! 701: inc dx ;Now just fall through to set ! 702: errn$ phase_proc_60 ; the innerloop count to 0! ! 703: ! 704: phase_proc_60: ! 705: dec dx ;Dec count (might become 0 just like ! 706: movzx edx,dx ; we want), and save it ! 707: mov fr.inner_loop_count,edx ! 708: mov bl,ch ! 709: mov ch,cl ;Compute last byte mask ! 710: not cl ; and save it ! 711: mov fr.last_mask,cx ! 712: mov bh,bl ;Compute start byte mask ! 713: not bl ; and save it ! 714: mov fr.start_mask,bx ! 715: ! 716: ; There may or may not be a source bitmap for the following address ! 717: ; computation. If there is no source, then the vertical setup code ! 718: ; will be entered with both the source and destination Y's set to the ! 719: ; destination Y and the address calculation skipped. If there is a ! 720: ; source, then the address calculation will be performed and the ! 721: ; vertical setup code entered with both the source and destination Y's. ! 722: ! 723: phase_processing_y: ! 724: shr di,3 ;Compute byte offset of destination ! 725: movzx edi,di ; and add to current destination ! 726: add fr.dest.lp_bits,edi ; offset ! 727: ! 728: mov dx,fr.DestyOrg ;Get destination Y origin ! 729: mov ax,dx ;Assume no source ! 730: mov cl,fr.the_flags ! 731: test cl,F0_SRC_PRESENT ;Is a source needed? ! 732: jz phase_proc_70 ; No, skip source set-up ! 733: shr si,3 ;Compute byte offset of source ! 734: movzx esi,si ; and add to current source offset ! 735: add fr.src.lp_bits,esi ! 736: mov ax,fr.SrcyOrg ;Get source Y origin ! 737: ! 738: ! 739: subttl Phase Processing (Y) ! 740: page ! 741: ! 742: ; The horizontal parameters have been calculated. Now the vertical ! 743: ; parameters must be calculated. ! 744: ; ! 745: ; Currently: ! 746: ; DX = destination Y origin ! 747: ; AX = source Y origin (destination origin if no source) ! 748: ; CL = fr.the_flags ! 749: ! 750: phase_proc_70: ! 751: mov bx,fr.yExt ;Get the Y extent of the BLT ! 752: dec bx ;Make it inclusive ! 753: ! 754: ! 755: ; The BLT will be Y+ if the top of the source is below or equal ! 756: ; to the top of the destination (cases: 1,4,5,7,8). The BLT ! 757: ; will be Y- if the top of the source is above the top of the ! 758: ; destination (cases: 2,3,6) ! 759: ; ! 760: ; ! 761: ; !...................! ! 762: ; !D ! ! 763: ; ____! ..x ! ! 764: ; |S ! : ! Start at top of S walking down ! 765: ; | ! ! ! 766: ; | !...................! ! 767: ; | : ! 768: ; |____________________: ! 769: ; ! 770: ; ! 771: ; __________________ ! 772: ; |S | ! 773: ; | ..................... Start at bottom of S walking up ! 774: ; | !D ! ! 775: ; | ! : ! ! 776: ; |____! ..x ! ! 777: ; ! ! ! 778: ; !.................... ! 779: ! 780: ! 781: mov ch,INCREASE ;Set Y direction for top to bottom ! 782: cmp ax,dx ;Which direction do we move? ! 783: jge phase_proc_80 ;Step down screen (cases: 1,4,5,7,8) ! 784: ! 785: ! 786: ; Direction will be from bottom of the screen up (Y-) ! 787: ; ! 788: ; This code will not be executed if there is no source since ! 789: ; both Y's were set to the destination Y. ! 790: ! 791: ! 792: add dx,bx ;Find bottom scan line index for ! 793: add ax,bx ; destination and source ! 794: mov ch,DECREASE ;Set pattern increment ! 795: ! 796: phase_proc_80: ! 797: mov fr.pat_row,dl ;Set pattern row and increment ! 798: mov fr.direction,ch ! 799: sar ch,1 ;Map FF==>FF, 01==>00 ! 800: errnz DECREASE-0FFFFFFFFh ! 801: errnz INCREASE-00001h ! 802: ! 803: ! 804: ; The Y direction has been computed. Compute the rest of the ! 805: ; Y parameters. These include the actual starting address, ! 806: ; the scan line and plane increment values, and whether or not ! 807: ; the extents will cross a 64K boundary. ! 808: ; ! 809: ; Currently: ! 810: ; DX = Y of starting destination scan ! 811: ; AX = Y of starting source scan ! 812: ; CH = BLT direction ! 813: ; 00 = increasing BLT, Y+ ! 814: ; FF = decreasing BLT, Y- ! 815: ; CL = fr.the_flags ! 816: ; BX = inclusive Y extent ! 817: ! 818: ! 819: phase_proc_90: ! 820: test cl,F0_SRC_PRESENT ;Is a source needed? ! 821: movsx ecx,ch ; (Want ECX = +/- 1) ! 822: jz phase_proc_100 ; No, skip source set-up ! 823: test fr.ppcBlt.fb,PPC_NEEDED ;Packed pel conversion needed? ! 824: jz phase_proc_95 ; No, use normal setup ! 825: push ebp ; Yes, perform packed pel work ! 826: lea ebp,fr ! 827: cCall packed_pel_comp_y ! 828: pop ebp ! 829: jmp short phase_proc_100 ! 830: ! 831: phase_proc_95: ! 832: push dx ;Save destination Y ! 833: push ebp ;Mustn't trash frame pointer ! 834: lea ebp,fr.src ;--> source data structure ! 835: cCall compute_y ;Process as needed ! 836: pop ebp ! 837: pop dx ;Restore destination Y ! 838: ! 839: phase_proc_100: ! 840: push ebp ;Mustn't trash frame pointer ! 841: mov ax,dx ;Put destination Y in ax ! 842: lea ebp,fr.dest ;--> destination data structure ! 843: cCall compute_y ! 844: pop ebp ;Restore frame pointer ! 845: ! 846: push ebp ! 847: lea ebp,fr ! 848: cCall check_device_special_cases ! 849: pop ebp ! 850: jc bitblt_exit ;C ==> BLT done w/special case ! 851: ! 852: ! 853: subttl Memory allocation for BLT compilation ! 854: page ! 855: cblt_allocate: ! 856: sub esp,MAX_BLT_SIZE ! 857: mov edi,esp ! 858: mov fr.blt_addr,edi ;Save the address for later ! 859: push ebp ! 860: lea ebp,fr ! 861: cCall cblt ;compile the BLT onto the stack ! 862: pop ebp ! 863: ! 864: ; The BLT has been created on the stack. Set up the initial registers, ! 865: ; set the direction flag as needed, and execute the BLT. ! 866: ! 867: mov esi,fr.src.lp_bits ;--> source device's first byte ! 868: mov edi,fr.dest.lp_bits ;--> destination device's first byte ! 869: mov cx,fr.yExt ;Get count of lines to BLT ! 870: cld ;Assume this is the direction ! 871: cmp fr.step_direction,STEPRIGHT ;Stepping to the right? ! 872: jz call_blt_do_it ; Yes ! 873: std ! 874: call_blt_do_it: ! 875: push ebp ;MUST SAVE THIS ! 876: call fr.blt_addr ;Call the FAR process ! 877: pop ebp ! 878: add esp,MAX_BLT_SIZE ;Return BLT space ! 879: errn$ bitblt_exit ! 880: ! 881: bitblt_exit: ! 882: ! 883: ; Here we test if the VGA was involved and skip reseting the VGA state if ! 884: ; it was not involved. ! 885: ! 886: test fr.the_flags,F0_DEST_IS_DEV + F0_SRC_IS_DEV ! 887: jz ega_not_involved ! 888: ! 889: ; Restore EGA registers to the default state. ! 890: ! 891: mov dx,EGA_BASE + SEQ_DATA ! 892: mov al,MM_ALL ! 893: out dx,al ! 894: mov dl,GRAF_ADDR ! 895: mov ax,0FF00h + GRAF_BIT_MASK ! 896: out dx,ax ! 897: mov ax,DR_SET shl 8 + GRAF_DATA_ROT ! 898: out dx,ax ! 899: mov ax,GRAF_ENAB_SR ! 900: out dx,ax ! 901: ega_not_involved: ! 902: ! 903: mov eax,1 ;Clear out error register (good exit) ! 904: cld ;Leave direction cleared ! 905: cRet vCompiledBlt ! 906: ! 907: xxxvCompiledBlt endp ! 908: ! 909: ! 910: ! 911: ;----------------------------Private-Routine----------------------------; ! 912: ; copy_device ! 913: ; ! 914: ; Copy device information to frame. ! 915: ; ! 916: ; Entry: ! 917: ; ESI = pdsurf ! 918: ; EDI --> frame DEV structure ! 919: ; EBP --> PPC structure (for source only) ! 920: ; BH = fr.the_flags, accumulated so far ! 921: ; Returns: ! 922: ; BH = fr.the_flags, accumulated so far ! 923: ; Carry clear if no error ! 924: ; EBP --> PPC structure ! 925: ; Error Returns: ! 926: ; None ! 927: ; Calls: ! 928: ; None ! 929: ; History: ! 930: ; Sun 22-Feb-1987 16:29:09 -by- Walt Moore [waltm] ! 931: ; Created. ! 932: ;-----------------------------------------------------------------------; ! 933: ! 934: cProc copy_dev ! 935: ! 936: mov eax,[esi].dsurf_sizlSurf.sizl_cx ! 937: mov [edi].width_bits,ax ! 938: mov eax,[esi].dsurf_sizlSurf.sizl_cy ! 939: mov [edi].height,ax ! 940: mov eax,[esi].dsurf_lNextScan ! 941: mov [edi].width_b,ax ! 942: mov eax,[esi].dsurf_pvBitmapStart ! 943: mov [edi].lp_bits,eax ! 944: mov eax,[esi].dsurf_lNextPlane ! 945: mov [edi].next_plane,eax ! 946: mov al,[esi].dsurf_iFormat ! 947: shl bh,1 ! 948: cmp al,BMF_PHYSDEVICE ! 949: sete ah ! 950: or bh,ah ! 951: errnz F0_SRC_IS_DEV-00001000b ! 952: errnz F0_DEST_IS_DEV-0000010b ! 953: ! 954: shl bh,1 ! 955: cmp al,BMF_1BPP ! 956: je copy_dev_20 ;Mono, color bit is clear ! 957: or bh,F0_DEST_IS_COLOR ! 958: errnz F0_SRC_IS_COLOR-00000100b ! 959: errnz F0_DEST_IS_COLOR-00000001b ! 960: ! 961: ; The source may be a packed pel source, which will have to be converted ! 962: ! 963: cmp al,BMF_DEVICE ;4 plane format ! 964: je copy_dev_20 ; Yes, no packed pel conversion ! 965: cmp al,BMF_PHYSDEVICE ! 966: je copy_dev_20 ; ditto ! 967: ! 968: mov [ebp].iFormat,al ;Save source format ! 969: mov [ebp].fb,PPC_NEEDED ;Show conversion needed ! 970: copy_dev_20: ! 971: ! 972: mov al,bh ;Set IS_COLOR and IS_DEVICE ! 973: and al,IS_COLOR+IS_DEVICE ; flags in the Device Flags ! 974: errnz IS_COLOR-F0_DEST_IS_COLOR ;Must be same bits ! 975: mov [edi].dev_flags,al ! 976: cRet copy_dev ! 977: ! 978: endProc copy_dev ! 979: ! 980: ! 981: ;----------------------------Private-Routine----------------------------; ! 982: ; pattern_preprocessing ! 983: ; ! 984: ; If a pattern is needed, make sure that it isn't a hollow ! 985: ; brush. If it is a hollow brush, then return an error. ! 986: ; ! 987: ; The type of brush to use will be set, and the brush pointer ! 988: ; updated to point to the mono bits if the mono brush will be ! 989: ; used. The type of brush used will match the destination device. ! 990: ; ! 991: ; If the destination is mono and the source is color, then a mono ! 992: ; brush fetch will be used, with the color brush munged in advance ! 993: ; according to the background/foreground colors passed: ! 994: ; ! 995: ; All brush pixels which match the background color should be set ! 996: ; to white (1). All other brush pixels should be set to black (0). ! 997: ; ! 998: ; If the physical color is stored as all 1's or 0's for each ! 999: ; plane, then by XORing the physical color for a plane with the ! 1000: ; corresponding byte in the brush, and ORing the results, this ! 1001: ; will give 0's where the color matched, and 1's where the colors ! 1002: ; didn't match. Inverting this result will then give 1's where ! 1003: ; the brush matched the background color and 0's where it did not. ! 1004: ; ! 1005: ; If both the source and destination are color, or the source is mono ! 1006: ; and the destination color, then the color portion of the brush will ! 1007: ; be used. ! 1008: ; ! 1009: ; If both the source and destination are mono, then the monochrome ! 1010: ; portion of the brush will be used. ! 1011: ; ! 1012: ; Entry: ! 1013: ; BH = fr.the_flags ! 1014: ; EBP = fr ! 1015: ; Returns: ! 1016: ; Carry flag clear if no error ! 1017: ; Error Returns: ! 1018: ; Carry flag set if error (null lpPBrush, or hollow brush) ! 1019: ; Registers Preserved: ! 1020: ; EBP ! 1021: ; Registers Destroyed: ! 1022: ; AX,BX,CX,DX,SI,DI,DS,ES,flags ! 1023: ; Calls: ! 1024: ; None ! 1025: ; History: ! 1026: ; Sat 15-Aug-1987 18:20:34 -by- Wesley O. Rupel [wesleyr] ! 1027: ; Added 4-plane support. ! 1028: ; Sun 22-Feb-1987 16:29:09 -by- Walt Moore [waltm] ! 1029: ; Created. ! 1030: ;-----------------------------------------------------------------------; ! 1031: ! 1032: ;------------------------------Pseudo-Code------------------------------; ! 1033: ; { ! 1034: ; } ! 1035: ;-----------------------------------------------------------------------; ! 1036: ! 1037: cProc pattern_preprocessing ! 1038: ! 1039: mov [ebp].the_flags,bh ;Save flag values ! 1040: test bh,F0_PAT_PRESENT ;Pattern required? ! 1041: jz pattern_preproc_end ; No, skip pattern check ! 1042: mov esi,[ebp].lpPBrush ;--> physical brush ! 1043: mov dl,[esi].oem_brush_accel;Save brush accelerator ! 1044: mov [ebp].brush_accel,dl ; in local variable frame ! 1045: test dl,SOLID_BRUSH ;Don't need to rotate a solid brush ! 1046: jnz pattern_preproc_end ! 1047: ! 1048: ; !!! hack-o-ramma. rotate the brush on the frame for now. ! 1049: ! 1050: push ebx ! 1051: mov edx,00000111b ! 1052: lea edi,[ebp].a_brush.oem_brush_C0 ;EDI --> temp brush area ! 1053: mov [ebp].lpPBrush,edi ! 1054: mov ebx,[ebp].pptlBrush ! 1055: mov ecx,dword ptr [ebx][0] ! 1056: and ecx,edx ! 1057: mov ebx,dword ptr [ebx][4] ! 1058: and ebx,edx ! 1059: mov ch,4 ! 1060: ! 1061: pattern_preproc_color: ! 1062: lodsb ! 1063: and ebx,edx ! 1064: ror al,cl ! 1065: mov byte ptr [edi][ebx],al ! 1066: inc ebx ! 1067: ! 1068: lodsb ! 1069: and ebx,edx ! 1070: ror al,cl ! 1071: mov byte ptr [edi][ebx],al ! 1072: inc ebx ! 1073: ! 1074: lodsb ! 1075: and ebx,edx ! 1076: ror al,cl ! 1077: mov byte ptr [edi][ebx],al ! 1078: inc ebx ! 1079: ! 1080: lodsb ! 1081: and ebx,edx ! 1082: ror al,cl ! 1083: mov byte ptr [edi][ebx],al ! 1084: inc ebx ! 1085: ! 1086: lodsb ! 1087: and ebx,edx ! 1088: ror al,cl ! 1089: mov byte ptr [edi][ebx],al ! 1090: inc ebx ! 1091: ! 1092: lodsb ! 1093: and ebx,edx ! 1094: ror al,cl ! 1095: mov byte ptr [edi][ebx],al ! 1096: inc ebx ! 1097: ! 1098: lodsb ! 1099: and ebx,edx ! 1100: ror al,cl ! 1101: mov byte ptr [edi][ebx],al ! 1102: inc ebx ! 1103: ! 1104: lodsb ! 1105: and ebx,edx ! 1106: ror al,cl ! 1107: mov byte ptr [edi][ebx],al ! 1108: inc ebx ! 1109: ! 1110: add edi,8 ! 1111: dec ch ! 1112: jnz pattern_preproc_color ! 1113: pop ebx ! 1114: ! 1115: pattern_preproc_end: ! 1116: clc ! 1117: cRet pattern_preprocessing ! 1118: ! 1119: endProc pattern_preprocessing ! 1120: ! 1121: ! 1122: ;----------------------------Private-Routine----------------------------; ! 1123: ; compute_y ! 1124: ; ! 1125: ; Compute y-related parameters. ! 1126: ; ! 1127: ; The parameters related to the Y coordinate and BLT direction ! 1128: ; are computed. The parameters include: ! 1129: ; ! 1130: ; a) Index to next scan line ! 1131: ; b) Starting Y address calculation ! 1132: ; d) Index to next plane ! 1133: ; ! 1134: ; Entry: ! 1135: ; EBP --> DEV structure to use (src or dest) ! 1136: ; AX = Y coordinate ! 1137: ; ECX = BLT direction ! 1138: ; 0000 = Y+ ! 1139: ; FFFF = Y- ! 1140: ; BX = inclusive Y extent ! 1141: ; Returns: ! 1142: ; ECX = BLT direction ! 1143: ; EBX = inclusive count ! 1144: ; Registers Preserved: ! 1145: ; EBP ! 1146: ; Registers Destroyed: ! 1147: ; AX,DX,SI,DI,flags ! 1148: ; Calls: ! 1149: ; None ! 1150: ; History: ! 1151: ;-----------------------------------------------------------------------; ! 1152: ! 1153: cProc compute_y ! 1154: ! 1155: movsx esi,[ebp].width_b ;Need bmWidthBytes a couple of times ! 1156: movzx eax,ax ! 1157: mul esi ;Compute Y address ! 1158: add [ebp].lp_bits,eax ! 1159: xor esi,ecx ;1's complement if Y- ! 1160: sub esi,ecx ;2's complement if Y- ! 1161: ! 1162: test [ebp].dev_flags,IS_DEVICE ! 1163: jnz compute_y_done ! 1164: test [ebp].dev_flags,IS_COLOR ! 1165: jz compute_y_done ! 1166: ! 1167: ! 1168: ; !!! I need to rewrite how next scan is handled. Currently, for +Y, next scan is 0, ! 1169: ; !!! and for -Y it is 2* -lNextScan ! 1170: ! 1171: add esi,esi ;Assume -Y (comp 2 * -lNextScan) ! 1172: and esi,ecx ;ESI = 0 if +Y, or 2 * -lNextScan ! 1173: ! 1174: compute_y_done: ! 1175: mov [ebp].next_scan,esi ;Set index to next scan line ! 1176: cRet compute_y ;All done with device, small bitmaps ! 1177: ! 1178: endProc compute_y ! 1179: ! 1180: _TEXT$02 ends ! 1181: ! 1182: end ! 1183:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.