![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dibs.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 dibs.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 ! root 1: page ,132 ! 2: title Dib Conversions ! 3: ;---------------------------Module-Header------------------------------; ! 4: ; Module Name: dibs.asm ! 5: ; ! 6: ; Copyright (c) 1992 Microsoft Corporation ! 7: ;-----------------------------------------------------------------------; ! 8: ! 9: .386 ! 10: ! 11: ifndef DOS_PLATFORM ! 12: .model small,c ! 13: else ! 14: ifdef STD_CALL ! 15: .model small,c ! 16: else ! 17: .model small,pascal ! 18: endif; STD_CALL ! 19: endif; DOS_PLATFORM ! 20: ! 21: ! 22: .xlist ! 23: include stdcall.inc ;calling convention cmacros ! 24: ! 25: include i386\cmacFLAT.inc ; FLATland cmacros ! 26: include i386\display.inc ; Display specific structures ! 27: include i386\ppc.inc ; Pack pel conversion structure ! 28: include i386\bitblt.inc ; General definitions ! 29: include i386\egavga.inc ! 30: .list ! 31: ! 32: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT ! 33: assume fs:nothing,gs:nothing ! 34: ! 35: EXTRNP comp_byte_interval ! 36: ! 37: ! 38: ; General equates ! 39: ! 40: ; BUGBUG this should be dynamically calculated ! 41: ! 42: CJ_PLANE equ (cj_max_scan+1) ;Extra byte makes algorithm easier ! 43: ! 44: .data ! 45: ! 46: ; Define the buffer for packed-pel to planer conversion. !!! when we do ! 47: ; conversion to planer bitmaps, this will have to come from the extra scan ! 48: ; we'll allocate in our planer color bitmaps !!! ! 49: ! 50: ; BUGBUG this should be allocated memory accessed via the DEVSURF, not static ! 51: ! 52: public ajConvertBuffer ! 53: ajConvertBuffer db (CJ_PLANE * 4) dup (0) ! 54: ! 55: .code ! 56: ! 57: _TEXT$03 SEGMENT DWORD USE32 PUBLIC 'CODE' ! 58: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING ! 59: ! 60: ; Define the default pixel mapping table. This table will be used when ! 61: ; converting from 4bpp to planer with no color translation. ! 62: ! 63: align 4 ! 64: ! 65: public aulDefBitMapping ! 66: aulDefBitMapping equ this dword ! 67: ! 68: dd 00000000000000000000000000000000b ;0000 ! 69: dd 00000000000000000000000000000001b ;0001 ! 70: dd 00000000000000000000000100000000b ;0010 ! 71: dd 00000000000000000000000100000001b ;0011 ! 72: dd 00000000000000010000000000000000b ;0100 ! 73: dd 00000000000000010000000000000001b ;0101 ! 74: dd 00000000000000010000000100000000b ;0110 ! 75: dd 00000000000000010000000100000001b ;0111 ! 76: dd 00000001000000000000000000000000b ;1000 ! 77: dd 00000001000000000000000000000001b ;1001 ! 78: dd 00000001000000000000000100000000b ;1010 ! 79: dd 00000001000000000000000100000001b ;1011 ! 80: dd 00000001000000010000000000000000b ;1100 ! 81: dd 00000001000000010000000000000001b ;1101 ! 82: dd 00000001000000010000000100000000b ;1110 ! 83: dd 00000001000000010000000100000001b ;1111 ! 84: ! 85: ! 86: ;-----------------------------------------------------------------------; ! 87: ; vDIB4n8ToPlaner ! 88: ; ! 89: ; Converts a scan of a 4bpp or 8bpp DIB into planer format for bitblt ! 90: ; ! 91: ; Entry: ! 92: ; EBP --> ppc structure ! 93: ; Exit: ! 94: ; ESI --> plane 0 of scan data ! 95: ; Registers Destroyed: ! 96: ; EAX,EBX,EDX,EBP ! 97: ; Registers Preserved: ! 98: ; ECX,EDI ! 99: ;-----------------------------------------------------------------------; ! 100: ! 101: ppc equ [ebp] ! 102: ! 103: vDIB4n8ToPlaner proc ! 104: ! 105: push ecx ! 106: push edi ! 107: ! 108: ; Load up the parameters for the blt ! 109: ! 110: mov esi,ppc.pSrc ;Source pointer ! 111: mov eax,ppc.iNextScan ;Index to next scan ! 112: add eax,esi ! 113: mov ppc.pSrc,eax ;Save next source pointer ! 114: xor eax,eax ;Creating a four bit index in eax ! 115: ! 116: ; pulXlate must be zero for 4bpp conversion since we will be using ! 117: ; ebx for creating an index. No problem since we don't need the ! 118: ; translation by the time we're in this code. ! 119: ! 120: mov ebx,ppc.pulXlate ;Color translation or zero ! 121: lea edi,ajConvertBuffer ;Where to store results ! 122: ! 123: ; Handle a partial first byte and all full bytes ! 124: ! 125: mov ecx,ppc.cLeftMiddle ;Get loop count for middle and left ! 126: jecxz vDIB4n8DoneFirst ;No first/inner ! 127: push ebp ! 128: push offset FLAT:VDIB4n8FinishFirst ;Set return address ! 129: push ppc.pfnLeftMiddle ;Set proc for left partial byte ! 130: mov ebp,ppc.pulConvert ;Base address of conversion table ! 131: xor edx,edx ;Init accumulated bits ! 132: ret ;To ppc.pfnLeftMiddle ! 133: VDIB4n8FinishFirst: ;It returns here ! 134: pop ebp ! 135: ! 136: vDIB4n8DoneFirst: ! 137: mov ecx,ppc.pfnRight ! 138: jecxz short vDIB4n8DoneRightSide ;No left side ! 139: and edx,01010101h ;Carryover from a partial 4bpp byte ! 140: push ebp ! 141: push offset FLAT:VDIB4n8FinishLast ;Set return address ! 142: push ecx ;Set function address ! 143: mov ecx,1 ;No looping ! 144: mov ebp,ppc.pulConvert ;Base address of conversion table ! 145: ret ;To ppc.pfnRight ! 146: VDIB4n8FinishLast: ;It returns here ! 147: pop ebp ! 148: ! 149: mov cl,ppc.cLeftShift ;Must align right side pels ! 150: shl edx,cl ! 151: mov [edi][CJ_PLANE*0][-1],dl ! 152: mov [edi][CJ_PLANE*1][-1],dh ! 153: shr edx,16 ! 154: mov [edi][CJ_PLANE*2][-1],dl ! 155: mov [edi][CJ_PLANE*3][-1],dh ! 156: ! 157: ; Load up the source pointer and exit ! 158: ! 159: vDIB4n8DoneRightSide: ! 160: pop edi ! 161: pop ecx ! 162: mov esi,ppc.pjConverted ! 163: ret ! 164: ! 165: vDIB4n8ToPlaner endp ! 166: ! 167: ppc equ <> ! 168: ! 169: ! 170: ;-----------------------------------------------------------------------; ! 171: ; vDIB4Convert* ! 172: ; ! 173: ; Converts the specified number of source 4 bpp bits into the ! 174: ; buffer. These are support routines for vDIB4Planer, where a ! 175: ; source byte converts into two aligned bits ! 176: ; ! 177: ; Entry: ! 178: ; EAX 31:8 = 0 ! 179: ; EBP --> Bit conversion table ! 180: ; ESI --> Source bitmap ! 181: ; EDI --> Planer destination ! 182: ; ECX = Loop count ! 183: ; Exit: ! 184: ; EBP --> Bit conversion table ! 185: ; ESI --> Next source byte ! 186: ; EDI --> Next planer destination ! 187: ; EDX = Last planer byte accumulated ! 188: ; Registers Destroyed: ! 189: ; EAX,ECX,EDX ! 190: ; Registers Preserved: ! 191: ;-----------------------------------------------------------------------; ! 192: ! 193: vDIB4Convert8:: ! 194: lodsb ! 195: mov ebx,eax ! 196: shr eax,4 ! 197: and ebx,00001111b ! 198: mov edx,[ebp][eax*4] ! 199: shl edx,1 ! 200: or edx,[ebp][ebx*4] ! 201: vDIB4Convert6:: ! 202: lodsb ! 203: shl edx,1 ! 204: mov ebx,eax ! 205: shr eax,4 ! 206: and ebx,00001111b ! 207: or edx,[ebp][eax*4] ! 208: shl edx,1 ! 209: or edx,[ebp][ebx*4] ! 210: vDIB4Convert4:: ! 211: lodsb ! 212: shl edx,1 ! 213: mov ebx,eax ! 214: shr eax,4 ! 215: and ebx,00001111b ! 216: or edx,[ebp][eax*4] ! 217: shl edx,1 ! 218: or edx,[ebp][ebx*4] ! 219: vDIB4Convert2:: ! 220: lodsb ! 221: shl edx,1 ! 222: mov ebx,eax ! 223: shr eax,4 ! 224: and ebx,00001111b ! 225: or edx,[ebp][eax*4] ! 226: shl edx,1 ! 227: or edx,[ebp][ebx*4] ! 228: mov [edi][CJ_PLANE*0],dl ! 229: mov [edi][CJ_PLANE*1],dh ! 230: ror edx,16 ! 231: mov [edi][CJ_PLANE*2],dl ! 232: mov [edi][CJ_PLANE*3],dh ! 233: inc edi ! 234: dec ecx ! 235: jnz vDIB4Convert8 ! 236: rol edx,16 ;Incase alignment of last byte ! 237: ret ! 238: ! 239: ! 240: ;-----------------------------------------------------------------------; ! 241: ; vDIB4NAConvert* ! 242: ; ! 243: ; Converts the specified number of source 4 bpp bits into the ! 244: ; buffer. These are support routines for vDIB4Planer, where a ! 245: ; source byte converts into two non-aligned bytes (we have to carry ! 246: ; a bit over into the next destination byte). ! 247: ; ! 248: ; Entry: ! 249: ; EAX 31:8 = 0 ! 250: ; EBP --> Bit conversion table ! 251: ; ESI --> Source bitmap ! 252: ; EDI --> Planer destination ! 253: ; ECX = Loop count ! 254: ; Exit: ! 255: ; EBP --> Bit conversion table ! 256: ; ESI --> Next source byte ! 257: ; EDI --> Next planer destination ! 258: ; EDX = first pel of next destination ! 259: ; Registers Destroyed: ! 260: ; EAX,ECX,EDX ! 261: ; Registers Preserved: ! 262: ;-----------------------------------------------------------------------; ! 263: ! 264: vDIB4NAConvert7:: ! 265: lodsb ! 266: shl edx,1 ;Carry over bit from last fetch ! 267: mov ebx,eax ! 268: shr eax,4 ! 269: and ebx,00001111b ! 270: or edx,[ebp][eax*4] ! 271: shl edx,1 ! 272: or edx,[ebp][ebx*4] ! 273: vDIB4NAConvert5:: ! 274: lodsb ! 275: shl edx,1 ! 276: mov ebx,eax ! 277: shr eax,4 ! 278: and ebx,00001111b ! 279: or edx,[ebp][eax*4] ! 280: shl edx,1 ! 281: or edx,[ebp][ebx*4] ! 282: vDIB4NAConvert3:: ! 283: lodsb ! 284: shl edx,1 ! 285: mov ebx,eax ! 286: shr eax,4 ! 287: and ebx,00001111b ! 288: or edx,[ebp][eax*4] ! 289: shl edx,1 ! 290: or edx,[ebp][ebx*4] ! 291: vDIB4NAConvert1:: ! 292: lodsb ! 293: shl edx,1 ! 294: mov ebx,eax ! 295: shr eax,4 ! 296: and ebx,00001111b ! 297: or edx,[ebp][eax*4] ! 298: mov [edi][CJ_PLANE*0],dl ! 299: mov [edi][CJ_PLANE*1],dh ! 300: shr edx,16 ! 301: mov [edi][CJ_PLANE*2],dl ! 302: mov [edi][CJ_PLANE*3],dh ! 303: inc edi ! 304: mov edx,[ebp][ebx*4] ;Start of next destination byte ! 305: dec ecx ! 306: jnz vDIB4NAConvert7 ! 307: ret ! 308: ! 309: ;-----------------------------------------------------------------------; ! 310: ; vDIB4NAConvert0 ! 311: ; ! 312: ; Last byte code for the 4bpp non-aligned case where the data already ! 313: ; exists in EDX, but we have to increment the destination pointer since ! 314: ; vDIB4n8ToPlaner assumes we stored the data and incremented the pointer ! 315: ; ! 316: ; Entry: ! 317: ; EDI --> destination ! 318: ; Exit: ! 319: ; EDI = EDI + 1 ! 320: ; Registers Destroyed: ! 321: ; None ! 322: ; Registers Preserved: ! 323: ; All but EDI ! 324: ;-----------------------------------------------------------------------; ! 325: ! 326: vDIB4NAConvert0 proc ! 327: ! 328: inc edi ! 329: vNOP:: ! 330: ret ! 331: ! 332: vDIB4NAConvert0 endp ! 333: ! 334: ! 335: ! 336: ;-----------------------------------------------------------------------; ! 337: ; The following table is indexed into to get the address of where to ! 338: ; enter the 4bpp conversion loops ! 339: ;-----------------------------------------------------------------------; ! 340: ! 341: apfn4bppConvert equ this dword ! 342: ! 343: dd offset FLAT:vDIB4Convert8 ! 344: dd offset FLAT:vDIB4NAConvert7 ! 345: dd offset FLAT:vDIB4Convert6 ! 346: dd offset FLAT:vDIB4NAConvert5 ! 347: dd offset FLAT:vDIB4Convert4 ! 348: dd offset FLAT:vDIB4NAConvert3 ! 349: dd offset FLAT:vDIB4Convert2 ! 350: dd offset FLAT:vDIB4NAConvert1 ! 351: ! 352: ;-----------------------------------------------------------------------; ! 353: ; The following table is indexed into to get the address of where to ! 354: ; enter the 4bpp conversion loops for a partial right hand side byte ! 355: ;-----------------------------------------------------------------------; ! 356: ! 357: apfn4bppConvertRHS equ this dword ! 358: ! 359: dd offset FLAT:vNOP ;Should never be called ! 360: dd offset FLAT:vDIB4Convert6 ;Convert three more source bytes ! 361: dd offset FLAT:vDIB4Convert6 ;Convert three source bytes ! 362: dd offset FLAT:vDIB4Convert4 ;Convert two more source bytes ! 363: dd offset FLAT:vDIB4Convert4 ;Convert two source bytes ! 364: dd offset FLAT:vDIB4Convert2 ;Convert one more source byte ! 365: dd offset FLAT:vDIB4Convert2 ;Convert one source byte ! 366: dd offset FLAT:vDIB4NAConvert0 ;Non-aligned, data in EDX already ! 367: ! 368: ;-----------------------------------------------------------------------; ! 369: ; vDIB8Convert* ! 370: ; ! 371: ; Converts the specified number of source 8 bpp bits into the ! 372: ; buffer. These are support routines for vDIB8Planer. ! 373: ; ! 374: ; Entry: ! 375: ; EAX 31:8 = 0 ! 376: ; EBP --> Bit conversion table ! 377: ; EBX --> Color translation table ! 378: ; ESI --> Source bitmap ! 379: ; EDI --> Planer destination ! 380: ; ECX = Loop count ! 381: ; Exit: ! 382: ; EBP --> Bit conversion table ! 383: ; EBX --> Color translation table ! 384: ; ESI --> Next source byte ! 385: ; EDI --> Next planer destination ! 386: ; Registers Destroyed: ! 387: ; EAX,ECX,EDX ! 388: ; Registers Preserved: ! 389: ; None ! 390: ;-----------------------------------------------------------------------; ! 391: ! 392: vDIB8Convert8:: ! 393: lodsb ;Get pel 1 ! 394: mov al,[ebx][eax*4] ;Color translation into 4 bits ! 395: mov edx,[ebp][eax*4] ! 396: vDIB8Convert7:: ! 397: lodsb ;Get pel 2 ! 398: shl edx,1 ! 399: mov al,[ebx][eax*4] ! 400: or edx,[ebp][eax*4] ! 401: vDIB8Convert6:: ! 402: lodsb ;Get pel 2 ! 403: shl edx,1 ! 404: mov al,[ebx][eax*4] ! 405: or edx,[ebp][eax*4] ! 406: vDIB8Convert5:: ! 407: lodsb ;Get pel 2 ! 408: shl edx,1 ! 409: mov al,[ebx][eax*4] ! 410: or edx,[ebp][eax*4] ! 411: vDIB8Convert4:: ! 412: lodsb ;Get pel 2 ! 413: shl edx,1 ! 414: mov al,[ebx][eax*4] ! 415: or edx,[ebp][eax*4] ! 416: vDIB8Convert3:: ! 417: lodsb ;Get pel 2 ! 418: shl edx,1 ! 419: mov al,[ebx][eax*4] ! 420: or edx,[ebp][eax*4] ! 421: vDIB8Convert2:: ! 422: lodsb ;Get pel 2 ! 423: shl edx,1 ! 424: mov al,[ebx][eax*4] ! 425: or edx,[ebp][eax*4] ! 426: vDIB8Convert1:: ! 427: lodsb ;Get pel 7 ! 428: shl edx,1 ! 429: mov al,[ebx][eax*4] ! 430: or edx,[ebp][eax*4] ! 431: mov [edi][CJ_PLANE*0],dl ! 432: mov [edi][CJ_PLANE*1],dh ! 433: ror edx,16 ! 434: mov [edi][CJ_PLANE*2],dl ! 435: mov [edi][CJ_PLANE*3],dh ! 436: inc edi ! 437: dec ecx ! 438: jnz vDIB8Convert8 ! 439: rol edx,16 ;Incase alignment of last byte ! 440: ret ! 441: ! 442: ;-----------------------------------------------------------------------; ! 443: ; The following table is indexed into to get the address of where to ! 444: ; enter the 8bpp conversion loop ! 445: ;-----------------------------------------------------------------------; ! 446: ! 447: apfn8bppConvert equ this dword ! 448: dd offset FLAT:vDIB8Convert8 ! 449: dd offset FLAT:vDIB8Convert7 ! 450: dd offset FLAT:vDIB8Convert6 ! 451: dd offset FLAT:vDIB8Convert5 ! 452: dd offset FLAT:vDIB8Convert4 ! 453: dd offset FLAT:vDIB8Convert3 ! 454: dd offset FLAT:vDIB8Convert2 ! 455: dd offset FLAT:vDIB8Convert1 ! 456: ! 457: ! 458: ;-----------------------------------------------------------------------; ! 459: ; vDIB8Preprocess() ! 460: ; ! 461: ; Performs whatever processing is necessary to prepare for a blt from ! 462: ; a 8bpp DIB to a planer format bitmap. ! 463: ; ! 464: ; Entry: ! 465: ; EBP --> Bitblt frame structure ! 466: ; Exit: ! 467: ; None ! 468: ; Registers Destroyed: ! 469: ; EAX,EBX,ECX,EDX,ESI,EDI ! 470: ; Registers Preserved: ! 471: ; EBP,EBX ! 472: ;-----------------------------------------------------------------------; ! 473: ! 474: fr equ [ebp] ! 475: ! 476: cProc vDIB8Preprocess ! 477: ! 478: push ebx ! 479: mov fr.ppcBlt.pulConvert,offset FLAT:aulDefBitMapping ! 480: ! 481: ; Align the blt so that the blt's phase will become 0. Both origins are ! 482: ; guaranteed to be positive and < 16 bits !!! ! 483: ! 484: movzx eax,fr.DestxOrg ;Align source and dest X origins ! 485: mov edx,eax ! 486: xchg ax,fr.SrcxOrg ;D31:16 is zero for both ! 487: add eax,fr.src.lp_bits ! 488: mov fr.ppcBlt.pSrc,eax ;Save address of first source pel ! 489: and edx,7 ;Always start in first byte of buffer ! 490: push edx ;Save for computing loop entry ! 491: movzx ebx,fr.xExt ;Compute exclusive right hand side (rhs) ! 492: add ebx,edx ! 493: push ebx ;Save rhs for shift count computation ! 494: ! 495: ; comp_byte_interval returns: ! 496: ; ! 497: ; EDI = offset to first byte to be altered in the scan ! 498: ; ESI = inner loop count (possibly 0) ! 499: ; AL = first byte mask (possibly 0) ! 500: ; AH = last byte mask (possibly 0) ! 501: ! 502: cCall comp_byte_interval ! 503: pop ebx ;Exclusive rhs ! 504: pop edx ;Inclusive lhs ! 505: ! 506: ; If only a partial destination byte will be altered, the mask will have ! 507: ; been returned in AL with AH and ESI 0. ! 508: ! 509: or ah,ah ;See if only a first byte ! 510: jnz short @f ;More than one byte to alter ! 511: or esi,esi ! 512: jnz @F ;More than a partial byte ! 513: ! 514: ; There will only be a partial byte. The normal flow-o-control falls apart ! 515: ; so we have to special case it. ! 516: ! 517: mov fr.ppcBlt.cLeftMiddle,esi ;No first/inner loop ! 518: mov eax,8 ! 519: sub eax,ebx ! 520: mov fr.ppcBlt.cLeftShift,al ;Set shift count to align last byte ! 521: mov eax,8 ! 522: sub ebx,edx ;EBX = # pels needed (<8) ! 523: sub eax,ebx ! 524: mov eax,apfn8bppConvert[eax*4] ! 525: jmp short v8bpp_have_last ! 526: ! 527: @@: ! 528: ! 529: ; More than a single byte will be written for the destination. Compute entry ! 530: ; into the convert loop based on the destination X origin. If the X dest ! 531: ; origin was zero, the first byte will have been combined into the inner loop ! 532: ; count ! 533: ! 534: cmp al,1 ;If partial first byte we need to bump ! 535: cmc ; the loop count by 1 ! 536: adc esi,0 ! 537: mov edx,apfn8bppConvert[edx*4] ! 538: mov al,ah ;Set last byte mask ! 539: mov fr.ppcBlt.pfnLeftMiddle,edx ! 540: v8bpp_have_first_inner: ! 541: mov fr.ppcBlt.cLeftMiddle,esi ;Save innerloop count (possibly 0) ! 542: ! 543: ; Compute the function and shift count for the last byte (if one exists) ! 544: ! 545: movzx eax,al ! 546: or eax,eax ! 547: jz short v8bpp_have_last ;No last byte, set pfn = 0 ! 548: mov al,8 ;D31:8 set to 0 with above movzx ! 549: sub eax,ebx ! 550: and eax,00000111b ! 551: mov fr.ppcBlt.cLeftShift,al ;Set shift count to align last byte ! 552: mov eax,apfn8bppConvert[eax*4] ! 553: v8bpp_have_last: ! 554: mov fr.ppcBlt.pfnRight,eax ! 555: ! 556: ; Set the address of routine which will be called from the compiled blt ! 557: ! 558: mov fr.ppcBlt.pfnConvert,offset FLAT:vDIB4n8ToPlaner ! 559: mov fr.ppcBlt.pjConverted,offset FLAT:ajConvertBuffer ! 560: pop ebx ! 561: cRet vDIB8Preprocess ! 562: ! 563: endProc vDIB8Preprocess ! 564: ! 565: ! 566: ! 567: ;-----------------------------------------------------------------------; ! 568: ; vDIB4Preprocess() ! 569: ; ! 570: ; Performs whatever processing is necessary to prepare for a blt from ! 571: ; a 4bpp DIB to a planer format bitmap. ! 572: ; ! 573: ; Entry: ! 574: ; EBP --> Bitblt frame structure ! 575: ; Exit: ! 576: ; None ! 577: ; Registers Destroyed: ! 578: ; EAX,EBX,ECX,EDX,ESI,EDI ! 579: ; Registers Preserved: ! 580: ; EBP,EBX ! 581: ;-----------------------------------------------------------------------; ! 582: ! 583: fr equ [ebp] ! 584: ! 585: cProc vDIB4Preprocess ! 586: ! 587: push ebx ! 588: ! 589: ; If a color translation vector was given, generate the new bit ! 590: ; conversion array ! 591: ! 592: mov eax,offset FLAT:aulDefBitMapping ! 593: cld ! 594: mov esi,fr.ppcBlt.pulXlate ! 595: or esi,esi ! 596: jz vDIB4_have_mapping_array ! 597: lea edi,fr.aulMap ! 598: mov ecx,16 ! 599: create_next_bit_mapping: ! 600: lodsd ! 601: mov eax,aulDefBitMapping[eax*4] ! 602: stosd ! 603: dec ecx ! 604: jnz create_next_bit_mapping ! 605: lea eax,[edi][-16*4] ! 606: vDIB4_have_mapping_array: ! 607: mov fr.ppcBlt.pulConvert,eax ! 608: ! 609: ! 610: ; Align the blt so that the blt's phase will become 0. Both origins are ! 611: ; guaranteed to be positive and < 16 bits !!! ! 612: ! 613: movzx eax,fr.DestxOrg ;Align source and dest X origins ! 614: mov edx,eax ;Save for later calculations ! 615: xchg ax,fr.SrcxOrg ;D31:16 is zero for both ! 616: ! 617: ; We never want to process a partial source byte. We will move the source ! 618: ; left if necessary, and adjust the extent if necessary. Note that if any ! 619: ; adjustments are made, we won't fetch past the end of the source nor ! 620: ; will we write beyond the end of our buffer (since we made it big enough ! 621: ; in the first place). ! 622: ! 623: ; We don't worry about adjusting the source origin before we save it ! 624: ; since we will be shifting it right later to round it to a byte address ! 625: ! 626: mov ecx,eax ! 627: shr ecx,1 ! 628: add ecx,fr.src.lp_bits ! 629: mov fr.ppcBlt.pSrc,ecx ;Save address of first pel ! 630: and eax,1 ;EAX = 1 if source is odd pel ! 631: movzx ebx,fr.xExt ! 632: sub edx,eax ;Move dest left if necessary ! 633: add ebx,eax ;Also bump extent if moved ! 634: and edx,7 ;Start dest in first byte of buffer ! 635: inc ebx ;Round extent to a multiple of 2 ! 636: and bl,11111110b ! 637: add ebx,edx ;Exclusive right hand side ! 638: ! 639: ; A problem: When moving the source left a pel, we can encounter a situation ! 640: ; wherein the first pel written is in bit position 0. However, it should be ! 641: ; noted that this pel is not part of the blt, so we have to skip over the ! 642: ; byte containing it to get to the correct first pel (which will be bit 7 ! 643: ; of the next byte). ! 644: ! 645: cmp dl,7 ! 646: je @F ! 647: xor ax,ax ! 648: @@: ! 649: add eax,offset FLAT:ajConvertBuffer ! 650: mov fr.ppcBlt.pjConverted,eax ! 651: ! 652: ; comp_byte_interval returns: ! 653: ; ! 654: ; EDI = offset to first byte to be altered in the scan ! 655: ; ESI = inner loop count (possibly 0) ! 656: ; AL = first byte mask (possibly 0) ! 657: ; AH = last byte mask (possibly 0) ! 658: ! 659: push edx ;Save for computing loop entry ! 660: push ebx ;Save rhs for shift count computation ! 661: cCall comp_byte_interval ! 662: pop ebx ;Exclusive rhs ! 663: pop edx ;Inclusive lhs ! 664: ! 665: ; If only a partial destination byte will be altered, the mask will have ! 666: ; been returned in AL with AH and ESI 0. ! 667: ! 668: or ah,ah ;See if only a first byte ! 669: jnz short @f ;More than one byte to alter ! 670: or esi,esi ! 671: jnz short @f ;More than one byte ! 672: ! 673: ; There will only be a partial byte. The normal flow-o-control falls apart ! 674: ; so we have to special case it. ! 675: ! 676: mov fr.ppcBlt.cLeftMiddle,esi ;No first/inner loop ! 677: mov eax,8 ! 678: sub eax,ebx ! 679: mov fr.ppcBlt.cLeftShift,al ;Set shift count to align last byte ! 680: mov eax,8 ! 681: sub ebx,edx ;EBX = # pels needed (<8) ! 682: sub eax,ebx ! 683: mov eax,apfn4bppConvertRHS[eax*4] ! 684: jmp short v4bpp_have_last ! 685: ! 686: @@: ! 687: ! 688: ; More than a single byte will be written for the destination. Compute entry ! 689: ; into the convert loop based on the destination X origin. If the X dest ! 690: ; origin was zero, the first byte will have been combined into the inner loop ! 691: ; count ! 692: ! 693: cmp al,1 ;If partial first byte we need to bump ! 694: cmc ; the loop count by 1 ! 695: adc esi,0 ! 696: mov ecx,apfn4bppConvert[edx*4] ! 697: mov al,ah ;Set last byte mask ! 698: mov fr.ppcBlt.pfnLeftMiddle,ecx ! 699: v4bpp_have_first_inner: ! 700: mov fr.ppcBlt.cLeftMiddle,esi ;Save innerloop count (possibly 0) ! 701: ! 702: ; Compute the function and shift count for the last byte (if one exists) ! 703: ! 704: movzx eax,al ! 705: or eax,eax ! 706: jz short v4bpp_have_last ;No last byte, set pfn = 0 ! 707: mov al,8 ;D31:8 set to 0 with above movzx ! 708: sub eax,ebx ! 709: and eax,00000111b ! 710: mov fr.ppcBlt.cLeftShift,al ;Set shift count to align last byte ! 711: mov eax,apfn4bppConvertRHS[eax*4] ! 712: v4bpp_have_last: ! 713: mov fr.ppcBlt.pfnRight,eax ! 714: ! 715: ; Set the address of the routine which will be called from the compiled blt ! 716: ! 717: mov fr.ppcBlt.pfnConvert,offset FLAT:vDIB4n8ToPlaner ! 718: pop ebx ! 719: cRet vDIB4Preprocess ! 720: ! 721: endProc vDIB4Preprocess ! 722: ! 723: ! 724: ;----------------------------Private-Routine----------------------------; ! 725: ; packed_pel_comp_y ! 726: ; ! 727: ; Compute y-related parameters. ! 728: ; ! 729: ; The parameters related to the Y coordinate and BLT direction ! 730: ; are computed. The parameters include: ! 731: ; ! 732: ; a) Index to next scan line ! 733: ; b) Starting Y address calculation ! 734: ; d) Index to next plane ! 735: ; ! 736: ; Entry: ! 737: ; EBP --> Blt frame ! 738: ; AX = Y coordinate ! 739: ; ECX = BLT direction ! 740: ; 0000 = Y+ ! 741: ; FFFF = Y- ! 742: ; BX = inclusive Y extent ! 743: ; Returns: ! 744: ; None ! 745: ; Registers Preserved: ! 746: ; EBP,ECX,EBX,EDX ! 747: ; Registers Destroyed: ! 748: ; EAX,ESI,EDI,flags ! 749: ; Calls: ! 750: ; None ! 751: ; History: ! 752: ;-----------------------------------------------------------------------; ! 753: ! 754: fr equ [ebp] ! 755: ! 756: cProc packed_pel_comp_y ! 757: ! 758: push edx ! 759: mov fr.src.next_plane,CJ_PLANE ;Index to next plane of data ! 760: movsx esi,fr.src.width_b ;Need bmWidthBytes couple-o-times ! 761: movzx eax,ax ! 762: mul esi ;Compute Y address ! 763: add fr.ppcBlt.pSrc,eax ;Add to base address ! 764: ! 765: xor esi,ecx ;1's complement if Y- ! 766: sub esi,ecx ;2's complement if Y- ! 767: mov fr.ppcBlt.iNextScan,esi ;Set index to next scan line ! 768: pop edx ! 769: cRet packed_pel_comp_y ! 770: ! 771: endProc packed_pel_comp_y ! 772: ! 773: _TEXT$03 ends ! 774: ! 775: end ! 776: ! 777:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.