![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpybits.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 cpybits.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 ! root 1: ;!!! This is all temp crap to be replaced when the blinker is written ! 2: ! 3: ;---------------------------Module-Header------------------------------; ! 4: ; Module Name: cpybits.asm ! 5: ; ! 6: ; Copyright (c) 1992 Microsoft Corporation ! 7: ;-----------------------------------------------------------------------; ! 8: page ,132 ! 9: title DrvCopyBits Support ! 10: .386 ! 11: ! 12: ifndef DOS_PLATFORM ! 13: .model small,c ! 14: else ! 15: ifdef STD_CALL ! 16: .model small,c ! 17: else ! 18: .model small,pascal ! 19: endif; STD_CALL ! 20: endif; DOS_PLATFORM ! 21: ! 22: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT ! 23: assume fs:nothing,gs:nothing ! 24: ! 25: .xlist ! 26: include stdcall.inc ;calling convention cmacros ! 27: include i386\egavga.inc ;VGA register definitions ! 28: include i386\strucs.inc ! 29: .list ! 30: ! 31: ! 32: .data ! 33: ! 34: ; Reuse the work area from the dib conversion code. ! 35: ! 36: ; BUGBUG this should be allocated memory accessed via the DEVSURF, not static ! 37: ! 38: extrn ajConvertBuffer:byte ;Buffer for converting to/from display ! 39: ! 40: ; BUGBUG this should be dynamically calculated ! 41: ! 42: CJ_WORK_PLANE equ cj_max_scan+1 ;Width of each plane in ajConvertBuffer ! 43: ! 44: .code ! 45: ! 46: ; ausLo16 is used to convert the low nibble of a byte into 4bpp packed pel ! 47: ! 48: ausLo16 equ this word ! 49: ! 50: dw 0000h ;0000 ! 51: dw 0100h ;0001 ! 52: dw 1000h ;0010 ! 53: dw 1100h ;0011 ! 54: dw 0001h ;0100 ! 55: dw 0101h ;0101 ! 56: dw 1001h ;0110 ! 57: dw 1101h ;0111 ! 58: dw 0010h ;1000 ! 59: dw 0110h ;1001 ! 60: dw 1010h ;1010 ! 61: dw 1110h ;1011 ! 62: dw 0011h ;1100 ! 63: dw 0111h ;1101 ! 64: dw 1011h ;1110 ! 65: dw 1111h ;1111 ! 66: ! 67: ; aulHi16 is used to convert the hi nibble of a byte into 4bpp packed pel ! 68: ! 69: aulHi16 equ this dword ! 70: ! 71: dd 00000000h ;0000 ! 72: dd 01000000h ;0001 ! 73: dd 10000000h ;0010 ! 74: dd 11000000h ;0011 ! 75: dd 00010000h ;0100 ! 76: dd 01010000h ;0101 ! 77: dd 10010000h ;0110 ! 78: dd 11010000h ;0111 ! 79: dd 00100000h ;1000 ! 80: dd 01100000h ;1001 ! 81: dd 10100000h ;1010 ! 82: dd 11100000h ;1011 ! 83: dd 00110000h ;1100 ! 84: dd 01110000h ;1101 ! 85: dd 10110000h ;1110 ! 86: dd 11110000h ;1111 ! 87: ! 88: ; ajRightMasks turns an exclusive bit position (0-7) into a mask of bits ! 89: ; to alter for the right hand side of the blt ! 90: ! 91: ajRightMasks equ this byte ! 92: ! 93: db 11111111b ;0 should never be used ! 94: db 01111111b ;1 ! 95: db 00111111b ;2 ! 96: db 00011111b ;3 ! 97: db 00001111b ;4 ! 98: db 00000111b ;5 ! 99: db 00000011b ;6 ! 100: db 00000001b ;7 ! 101: ! 102: ; ajLeftMasks turns a bit position (0-7) into a mask of bits to alter for ! 103: ; the left hand side of the blt ! 104: ! 105: ajLeftMasks equ this byte ! 106: ! 107: db 11111111b ;0 should never be used ! 108: db 10000000b ;1 ! 109: db 11000000b ;2 ! 110: db 11100000b ;3 ! 111: db 11110000b ;4 ! 112: db 11111000b ;5 ! 113: db 11111100b ;6 ! 114: db 11111110b ;7 ! 115: ! 116: ! 117: CB_4BPP_SCAN equ (CX_SCREEN_MAX / 2) ;# bytes for a 4bpp screen scan ! 118: ! 119: ;-----------------------------Public-Routine----------------------------; ! 120: ; vConvertVGAScan ! 121: ; ! 122: ; Converts a VGA scan into a 4bpp format with a given phase alignment, ! 123: ; and returns a pointer to the converted buffer. ! 124: ; ! 125: ; pdsurfsrc - pointer to source surface (must be VGA display memory) ! 126: ; xSrc - X origin of the source ! 127: ; ySrc - Y origin of the source ! 128: ; pjDstBase - Base address of the destination ! 129: ; xDst - X origin of the destination ! 130: ; yDst - Y origin of the destination ! 131: ; cxPels - Number of pels in X ! 132: ; cyTotalScans - Number of scans in overall operation ! 133: ; lDelta - Width in bytes of a destination scan ! 134: ; iFormat - Format of destination ! 135: ; pulXlate - Color translation vector ! 136: ;-----------------------------------------------------------------------; ! 137: ! 138: ProcName xxxvConvertVGA2DIB,vConvertVGA2DIB,44 ! 139: ! 140: xxxvConvertVGA2DIB proc uses esi edi ebx,\ ! 141: pdsurfsrc :ptr DEVSURF, \ ! 142: xSrc :dword, \ ! 143: ySrc :dword, \ ! 144: pjDstBase :dword, \ ! 145: xDst :dword, \ ! 146: yDst :dword, \ ! 147: cxPels :dword, \ ! 148: cyTotalScans :dword, \ ! 149: lDelta :dword, \ ! 150: iFormat :dword, \ ! 151: pulXlate :dword ! 152: ! 153: ;-----------------------------------------------------------------------; ! 154: ; Local variables and their meaning ! 155: ; ! 156: ; cjScreenCopy This is the number of bytes to copy from each scan ! 157: ; into ajConvertBuffer. ! 158: ; jLeftMask This is the left-hand side (lhs) mask used when copying ! 159: ; the converted data to the destination ! 160: ; jRightMask This is the right-hand side (lhs) mask used when copying ! 161: ; the converted data to the destination ! 162: ; cRightShift This is the number of bits that the converted data needs ! 163: ; to be shifted right to align with the destination. ! 164: ; cjRightShift This is the number of bytes which must be shifted right ! 165: ; by cRightShift ! 166: ; cCopy This is the number of full (e.g. not masked) bytes which ! 167: ; must be copied to the destination ! 168: ; pjWork Pointer to the work area where ! 169: ; a) color converted data is written into ! 170: ; b) bits are phase-aligned if needed ! 171: ; c) data is read from for the final copy to the DIB ! 172: ; pjSrc Address of scan 0 in memory ! 173: ; pjDst Address of scan 0 in memory ! 174: ; cyScans Number of scans to do in current bank ! 175: ; ulScanWidth Offset from start of one scan to start of next ! 176: ; ulBottomSrcScan Bottom scan line of source rectangle (non-inclusive) ! 177: ;-----------------------------------------------------------------------; ! 178: ! 179: local cjScreenCopy :dword ! 180: local jLeftMask :byte ! 181: local jRightMask :byte ! 182: local cRightShift :byte ! 183: local cjRightShift :dword ! 184: local cCopy :dword ! 185: local pfnXlate :ptr ! 186: local pjWork :ptr ! 187: local cjSkip :dword ! 188: local pjSrc :dword ! 189: local pjDst :dword ! 190: local cyScans :dword ! 191: local ulScanWidth :dword ! 192: local ulBottomSrcScan :dword ! 193: ! 194: local ajColorConv[16]:byte ! 195: local ajWork[CB_4BPP_SCAN+4]:byte ! 196: local aj8bpp[CX_SCREEN_MAX+8]:byte ! 197: ! 198: ! 199: ;----------------------------------------------------------------------; ! 200: ; Loop through source banks, copying & converting one bank at a time. ! 201: ! 202: ; Calculate the bottom scan line of the source rectangle (non-inclusive). ! 203: ! 204: mov eax,ySrc ! 205: add eax,cyTotalScans ! 206: mov ulBottomSrcScan,eax ! 207: ! 208: mov ecx,pdsurfsrc ;point to source surface ! 209: mov eax,[ecx].dsurf_lNextScan ! 210: mov ulScanWidth,eax ;local copy of scan line width ! 211: ! 212: ; Map in the bank containing the top scan to fill, if it's not mapped in ! 213: ; already. ! 214: ! 215: mov eax,ySrc ;top scan line of source ! 216: ! 217: cmp eax,[ecx].dsurf_rcl1WindowClip.yTop ;is fill top less than ! 218: ; current bank? ! 219: jl short map_init_bank ;yes, map in proper bank ! 220: cmp eax,[ecx].dsurf_rcl1WindowClip.yBottom ;fill top greater than ! 221: ; current bank? ! 222: jl short init_bank_mapped ;no, proper bank already mapped ! 223: map_init_bank: ! 224: ! 225: ; Map in the bank containing the top scan line of the fill. ! 226: ! 227: ptrCall <dword ptr [ecx].dsurf_pfnBankControl>,<ecx,eax,JustifyTop> ! 228: ! 229: init_bank_mapped: ! 230: ! 231: bank_loop: ! 232: ! 233: ; Set the start address of the source bitmap. ! 234: ; Note that the start of the bitmap will change each time through the ! 235: ; bank loop, because the start of the bitmap is varied to map the ! 236: ; desired scan line to the banking window. ! 237: ! 238: mov eax,pdsurfsrc ;point to source surface ! 239: mov ebx,[eax].dsurf_pvBitmapStart ;start of scan 0 in bitmap ! 240: mov pjSrc,ebx ! 241: ! 242: ; Set the start address of the destination bitmap. ! 243: ! 244: mov ebx,pjDstBase ! 245: mov pjDst,ebx ! 246: ! 247: ; Figure out how many scan lines we'll fill in the current bank. ! 248: ! 249: mov ebx,ulBottomSrcScan ;bottom of destination rectangle ! 250: cmp ebx,[eax].dsurf_rcl1WindowClip.yBottom ! 251: ;which comes first, the bottom of the ! 252: ; dest rect or the bottom of the ! 253: ; current bank? ! 254: jl short BottomScanSet ;fill bottom comes first, so draw to ! 255: ; that; this is the last bank in fill ! 256: mov ebx,[eax].dsurf_rcl1WindowClip.yBottom ! 257: ;bank bottom comes first; draw to ! 258: ; bottom of bank ! 259: BottomScanSet: ! 260: sub ebx,ySrc ;# of scans to fill in bank ! 261: mov cyScans,ebx ! 262: push ebx ;remember # of scans in bank ! 263: ! 264: call DoOneBank ;copy and convert within the current bank ! 265: ! 266: pop ebx ;restore # of scans in bank ! 267: ! 268: sub cyTotalScans,ebx ;count off this bank's scans from total ! 269: jz short banks_done ;no more scans; done ! 270: add yDst,ebx ;advance to the next destination scan ! 271: ; to copy to ! 272: mov edi,pdsurfsrc ! 273: mov eax,[edi].dsurf_rcl1WindowClip.yBottom ! 274: mov ySrc,eax ;remember where the top of the bank ! 275: ; we're about to map in is (same as ! 276: ; bottom of bank we just did) ! 277: ! 278: ptrCall <dword ptr [edi].dsurf_pfnBankControl>,<edi,eax,JustifyTop> ! 279: ;map in the bank ! 280: ! 281: jmp bank_loop ;fill the next bank ! 282: ! 283: ! 284: ; Done. ! 285: ! 286: align 4 ! 287: banks_done: ! 288: ! 289: cRet vConvertVGA2DIB ! 290: ! 291: ;----------------------------------------------------------------------; ! 292: ; Copies and converts bits within a single bank. ! 293: ! 294: align 4 ! 295: DoOneBank: ! 296: ! 297: cld ! 298: ! 299: ; Compute the number of bytes to copy from the screen, and the starting ! 300: ; address of the source ! 301: ! 302: mov eax,ySrc ;Compute addr of first source scan ! 303: mov ebx,xSrc ! 304: imul eax,ulScanWidth ! 305: mov ecx,ebx ! 306: shr ebx,3 ! 307: add eax,ebx ! 308: add pjSrc,eax ! 309: ! 310: ; Compute the number of bytes to actually transfer from the screen ! 311: ! 312: mov eax,cxPels ;Compute rhs ! 313: add eax,ecx ! 314: dec eax ;Make rhs inclusive ! 315: shr ecx,3 ;Compute byte of lhs ! 316: shr eax,3 ;Compute byte of rhs ! 317: sub eax,ecx ;Compute number of bytes for copy ! 318: inc eax ;(because rhs inclusive, always inc) ! 319: mov cjScreenCopy,eax ! 320: ! 321: ; Compute the address of the starting destination scan. ! 322: ! 323: mov eax,yDst ! 324: imul lDelta ! 325: add pjDst,eax ! 326: ! 327: ; Set up for the preprocess loops and invoke the correct one. First make ! 328: ; some assumptions about defaults ! 329: ! 330: xor eax,eax ! 331: mov cRightShift,al ;No shifting needed ! 332: mov jLeftMask,al ;No left masking needed ! 333: mov jRightMask,al ;No right masking needed ! 334: lea eax,ajWork ;Intermediate work area ! 335: mov pjWork,eax ! 336: ! 337: mov esi,cxPels ! 338: mov ebx,xSrc ! 339: mov edx,xDst ! 340: ! 341: mov eax,iFormat ! 342: dec eax ! 343: jz preproc_1bpp ! 344: dec eax ! 345: jz preproc_4bpp ! 346: .errnz BMF_1BPP-1 ! 347: .errnz BMF_4BPP-2 ! 348: .errnz BMF_8BPP-3 ! 349: ! 350: ; Destination is 8bpp. Copy will be phased aligned from the conversion buffer ! 351: ; to the destination. ! 352: ! 353: preproc_8bpp: ! 354: add pjDst,edx ;Offset to first pel in DIB ! 355: and ebx,7 ;Offset to first pel for final copy ! 356: mov cjSkip,ebx ! 357: mov cCopy,esi ;Number of bytes for final copy ! 358: lea eax,aj8bpp ;Intermediate work area ! 359: mov pjWork,eax ! 360: mov pfnXlate,offset FLAT:cvt_to_8bpp ! 361: jmp preproc_done ! 362: ! 363: ! 364: ; Destination is 4bpp. Copy will either be phase aligned or be off by 4 in ! 365: ; which case we will phase align the entire buffer before copying. ! 366: ! 367: preproc_4bpp: ! 368: lea eax,[esi][edx] ;Compute rhs for later ! 369: test dl,1 ;Odd if left mask needed ! 370: jz @F ! 371: mov jLeftMask,11110000b ! 372: dec esi ;One less pel in inner loop ! 373: @@: ! 374: test al,1 ;Odd if right mask needed ! 375: jz @F ! 376: mov jRightMask,00001111b ! 377: dec esi ;One less pel in inner loop ! 378: @@: ! 379: ! 380: and ebx,7 ;Offset for final copy is xSrc mod 8 ! 381: ! 382: ; If the source and destination have different alignments, we'll have to ! 383: ; compute phase alignment stuff. ! 384: ! 385: mov eax,ebx ! 386: xor eax,edx ! 387: shr eax,1 ! 388: jnc @F ! 389: mov eax,cjScreenCopy ;* 4 for size of data in buffer ! 390: shl eax,2 ! 391: inc eax ;+ 1 to shift into last byte! ! 392: mov cjRightShift,eax ! 393: mov cRightShift,4 ;Shift entire buffer right 4 pels ! 394: inc ebx ;First pel just moved right ! 395: @@: ! 396: ! 397: ; Finish calculating the other parameters ! 398: ! 399: shr edx,1 ;Offset to first pel in DIB ! 400: add pjDst,edx ! 401: shr ebx,1 ! 402: mov cjSkip,ebx ! 403: shr esi,1 ! 404: mov cCopy,esi ;# of inner bytes for final copy ! 405: ! 406: mov eax,offset FLAT:copy_to_dest;Assume no color translation needed ! 407: cmp pulXlate,0 ! 408: je @F ! 409: mov eax,offset FLAT:cvt_to_4bpp ;Addreess of color xlate routine ! 410: @@: ! 411: mov pfnXlate,eax ! 412: jmp preproc_done ! 413: ! 414: ! 415: ; Destination is 1bpp. Copy most likely will require masking and phase ! 416: ; alignment. ! 417: ! 418: preproc_1bpp: ! 419: mov edi,00000007h ;A handy mask used a lot ! 420: xor ecx,ecx ;CL = lhs mask, CH = rhs mask ! 421: lea eax,[esi][edx] ;Compute rhs for later ! 422: test edx,edi ;See if partial byte ! 423: jz preproc_1bpp_done_lhs ;No partial lhs byte ! 424: mov ecx,edx ! 425: neg ecx ! 426: and ecx,edi ;CL = # bits in lhs, CH = 0 ! 427: sub esi,ecx ;Compute # remaining bytes ! 428: mov cl,ajLeftMasks[ecx] ;Get lhs mask ! 429: jnc preproc_1bpp_done_lhs ;Didn't combine into one byte ! 430: and eax,edi ;Combine rhs mask with lhs mask ! 431: and cl,ajRightMasks[eax] ! 432: xor esi,esi ;No more bytes ! 433: xor eax,eax ;To show no rhs ! 434: jmp short preproc_1bpp_have_masks ! 435: ! 436: preproc_1bpp_done_lhs: ! 437: and eax,edi ;See if partial rhs byte ! 438: jz preproc_1bpp_have_masks ;No partial rhs byte ! 439: mov ch,ajRightMasks[eax] ! 440: sub esi,eax ;Compute # remaining bytes ! 441: ! 442: preproc_1bpp_have_masks: ! 443: mov jLeftMask,cl ;Set left and right masks ! 444: mov jRightMask,ch ! 445: shr esi,3 ;# of inner bytes for final copy ! 446: mov cCopy,esi ! 447: ! 448: ; Compute offset to first byte in destination DIB ! 449: ! 450: mov eax,edx ! 451: shr eax,3 ! 452: add pjDst,eax ! 453: ! 454: ; Compute phase alignment parameters ! 455: ! 456: xor ecx,ecx ;Assume cjSkip is 0 ! 457: and edx,edi ! 458: and ebx,edi ! 459: sub edx,ebx ;Determine phase alignment ! 460: jz preproc_finish_1bpp ;No phase alignment needed ! 461: ! 462: ; We're really shifting left, so we'll set it up to shift right a lot, and ! 463: ; get the first byte of the final move from byte 1 of the work area. ! 464: ! 465: adc ecx,ecx ;Set cjSkip = 0 or 1 ! 466: and edx,edi ;3 LSBs is shift count ! 467: mov cRightShift,dl ;Phase for the shift ! 468: mov eax,cjScreenCopy ;Size of data in buffer ! 469: inc eax ;+ 1 to shift into last byte! ! 470: mov cjRightShift,eax ! 471: preproc_finish_1bpp: ! 472: mov cjSkip,ecx ;No skipping needed ! 473: mov esi,pulXlate ;Copy color translation table to the ! 474: lea edi,ajColorConv ; frame because we are out of regs. ! 475: mov ecx,16 ! 476: @@: ! 477: lodsd ! 478: stosb ! 479: dec ecx ! 480: jnz @B ! 481: ! 482: mov pfnXlate,offset FLAT:cvt_to_1bpp ! 483: ! 484: preproc_done: ! 485: ! 486: process_next_scan: ! 487: ! 488: mov edi,offset FLAT:ajConvertBuffer ! 489: mov edx,EGA_BASE + GRAF_ADDR ! 490: mov eax,GRAF_READ_MAP ! 491: copy_next_plane: ! 492: mov esi,pjSrc ;ESI --> first Source byte ! 493: out dx,ax ;Set read plane ! 494: mov ecx,cjScreenCopy ;Set number of bytes to read ! 495: mov ebx,edi ! 496: rep movsb ! 497: lea edi,[ebx][CJ_WORK_PLANE];EDI --> next scan in convert buf ! 498: inc ah ;Set next read plane ! 499: cmp ah,4 ! 500: jb copy_next_plane ! 501: ! 502: ; The scan has been read in from the VGA. Convert it into 4bpp format which ! 503: ; will be needed for doing the color conversion. ! 504: ! 505: lea edi,ajWork ;Convert dwords into here ! 506: mov esi,offset FLAT:ajConvertBuffer ! 507: mov ecx,cjScreenCopy ;# of source bytes to convert ! 508: ! 509: cvt_next_src_byte: ! 510: xor eax,eax ! 511: mov al,[esi][CJ_WORK_PLANE*3] ;Get data for plane C3 ! 512: mov ebx,eax ! 513: and ebx,00001111b ! 514: shr eax,4 ! 515: mov edx,aulHi16[ebx*4] ! 516: or dx,ausLo16[eax*2] ! 517: shl edx,1 ! 518: mov al,[esi][CJ_WORK_PLANE*2] ;Get data for plane C2 ! 519: mov ebx,eax ! 520: and ebx,00001111b ! 521: shr eax,4 ! 522: or edx,aulHi16[ebx*4] ! 523: or dx,ausLo16[eax*2] ! 524: shl edx,1 ! 525: mov al,[esi][CJ_WORK_PLANE*1] ;Get data for plane C1 ! 526: mov ebx,eax ! 527: and ebx,00001111b ! 528: shr eax,4 ! 529: or edx,aulHi16[ebx*4] ! 530: or dx,ausLo16[eax*2] ! 531: shl edx,1 ! 532: lodsb ;Get data for plane C0 ! 533: mov ebx,eax ! 534: and ebx,00001111b ! 535: shr eax,4 ! 536: or edx,aulHi16[ebx*4] ! 537: or dx,ausLo16[eax*2] ! 538: mov eax,edx ! 539: stosd ;8 pels down! ! 540: dec ecx ! 541: jnz cvt_next_src_byte ! 542: ! 543: ! 544: ; Perform the format conversion ! 545: mov ecx,cjScreenCopy ;Set lopp count ! 546: lea esi,ajWork ;Set source pointer ! 547: mov edi,pjWork ;Set destination pointer ! 548: mov ebx,pulXlate ;Set color translate vector ! 549: xor eax,eax ;Init D31:D8 to 0 ! 550: jmp pfnXlate ;Invoke correct conversion routine ! 551: ! 552: ; Convert from 4bpp to 8bpp with color translation ! 553: ! 554: cvt_to_8bpp: ! 555: lodsb ;Get two nibbles worth ! 556: mov edx,eax ! 557: shr eax,4 ! 558: and edx,00001111b ! 559: mov al,[ebx][eax*4] ! 560: stosb ! 561: mov al,[ebx][edx*4] ! 562: stosb ! 563: lodsb ;Get two nibbles worth ! 564: mov edx,eax ! 565: shr eax,4 ! 566: and edx,00001111b ! 567: mov al,[ebx][eax*4] ! 568: stosb ! 569: mov al,[ebx][edx*4] ! 570: stosb ! 571: lodsb ;Get two nibbles worth ! 572: mov edx,eax ! 573: shr eax,4 ! 574: and edx,00001111b ! 575: mov al,[ebx][eax*4] ! 576: stosb ! 577: mov al,[ebx][edx*4] ! 578: stosb ! 579: lodsb ;Get two nibbles worth ! 580: mov edx,eax ! 581: shr eax,4 ! 582: and edx,00001111b ! 583: mov al,[ebx][eax*4] ! 584: stosb ! 585: mov al,[ebx][edx*4] ! 586: stosb ! 587: dec ecx ! 588: jnz cvt_to_8bpp ! 589: jmp copy_to_dest ! 590: ! 591: ; Convert from 4bpp to 4bpp with color translation. ! 592: ! 593: cvt_to_4bpp: ! 594: lodsb ;Get two nibbles worth ! 595: mov edx,eax ! 596: shr eax,4 ! 597: and edx,00001111b ! 598: mov al,[ebx][eax*4] ! 599: shl al,4 ! 600: or al,[ebx][edx*4] ! 601: stosb ! 602: lodsb ;Get two nibbles worth ! 603: mov edx,eax ! 604: shr eax,4 ! 605: and edx,00001111b ! 606: mov al,[ebx][eax*4] ! 607: shl al,4 ! 608: or al,[ebx][edx*4] ! 609: stosb ! 610: lodsb ;Get two nibbles worth ! 611: mov edx,eax ! 612: shr eax,4 ! 613: and edx,00001111b ! 614: mov al,[ebx][eax*4] ! 615: shl al,4 ! 616: or al,[ebx][edx*4] ! 617: stosb ! 618: lodsb ;Get two nibbles worth ! 619: mov edx,eax ! 620: shr eax,4 ! 621: and edx,00001111b ! 622: mov al,[ebx][eax*4] ! 623: shl al,4 ! 624: or al,[ebx][edx*4] ! 625: stosb ! 626: dec ecx ! 627: jnz cvt_to_4bpp ! 628: jmp copy_to_dest ! 629: ! 630: ! 631: ; Convert from 4bpp to 1bpp with color translation. ! 632: ! 633: ! 634: cvt_to_1bpp: ! 635: lodsb ;Get two nibbles worth ! 636: mov edx,eax ! 637: shr eax,4 ! 638: and edx,00001111b ! 639: mov bl,ajColorConv[eax] ! 640: shl bl,1 ! 641: or bl,ajColorConv[edx] ! 642: lodsb ! 643: mov edx,eax ! 644: shr eax,4 ! 645: and edx,00001111b ! 646: shl bl,1 ! 647: or bl,ajColorConv[eax] ! 648: shl bl,1 ! 649: or bl,ajColorConv[edx] ! 650: lodsb ;Get two nibbles worth ! 651: mov edx,eax ! 652: shr eax,4 ! 653: and edx,00001111b ! 654: shl bl,1 ! 655: or bl,ajColorConv[eax] ! 656: shl bl,1 ! 657: or bl,ajColorConv[edx] ! 658: lodsb ;Get two nibbles worth ! 659: mov edx,eax ! 660: shr eax,4 ! 661: and edx,00001111b ! 662: shl bl,1 ! 663: or bl,ajColorConv[eax] ! 664: shl bl,1 ! 665: or bl,ajColorConv[edx] ! 666: mov al,bl ! 667: stosb ! 668: dec ecx ! 669: jnz cvt_to_1bpp ! 670: ! 671: ! 672: ; Copy to the destination. This unfortunately may involve phase alignment ! 673: ! 674: copy_to_dest: ! 675: movzx ecx,cRightShift ! 676: jecxz copy_aligned_to_dest ! 677: mov edi,pjWork ! 678: mov ebx,cjRightShift ! 679: phase_align_it: ! 680: mov ah,dl ;Get previous unused bits ! 681: mov al,byte ptr [edi] ! 682: mov dl,al ! 683: shr eax,cl ! 684: stosb ! 685: dec ebx ! 686: jnz phase_align_it ! 687: ! 688: copy_aligned_to_dest: ! 689: mov esi,pjWork ! 690: add esi,cjSkip ! 691: mov edi,pjDst ! 692: ! 693: mov dl,jLeftMask ! 694: or dl,dl ! 695: jz @F ! 696: lodsb ! 697: mov ah,byte ptr [edi] ! 698: xor ah,al ! 699: and ah,dl ! 700: xor al,ah ! 701: stosb ! 702: @@: ! 703: mov ecx,cCopy ! 704: rep movsb ! 705: ! 706: mov dl,jRightMask ! 707: or dl,dl ! 708: jz @F ! 709: lodsb ! 710: mov ah,byte ptr [edi] ! 711: xor ah,al ! 712: and ah,dl ! 713: xor al,ah ! 714: stosb ! 715: @@: ! 716: ! 717: mov eax,ulScanWidth ! 718: add pjSrc,eax ! 719: mov eax,lDelta ! 720: add pjDst,eax ! 721: dec cyScans ! 722: jnz process_next_scan ! 723: ! 724: PLAIN_RET ;we're done with this bank ! 725: ! 726: xxxvConvertVGA2DIB endp ! 727: ! 728: end ! 729:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.