![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dib2vga.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 dib2vga.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 ! root 1: ;---------------------------Module-Header------------------------------; ! 2: ; Module Name: dib2vga.asm ! 3: ; ! 4: ; Copyright (c) 1992 Microsoft Corporation ! 5: ;-----------------------------------------------------------------------; ! 6: ;-----------------------------------------------------------------------; ! 7: ; ! 8: ; VOID vDIB2VGA(DEVSURF * pdsurfDst, DEVSURF * pdsurfSrc, ! 9: ; RECTL * prclDst, POINTL * pptlSrc, UCHAR *pConv); ! 10: ; ! 11: ; Performs accelerated copies of DIB pixels to the VGA screen. ! 12: ; ! 13: ; pdsurfDst = pointer to dest surface, which must be the VGA ! 14: ; ! 15: ; pdsurfSrc = pointer to source surface, which must be a 4 bpp DIB. Only the ! 16: ; lNextScan and pvBitmapStart fields need to be set ! 17: ; ! 18: ; prclDst = pointer to rectangle describing area of VGA to be copied to ! 19: ; ! 20: ; pptlSrc = pointer to point structure describing the upper left corner ! 21: ; of the copy in the source DIB ! 22: ; ! 23: ; pConv = pointer to set of four 256-byte tables used for conversion ! 24: ; from DIB4 to VGA, created by vSetDIB4ToVGATables ! 25: ; ! 26: ;-----------------------------------------------------------------------; ! 27: ;-----------------------------------------------------------------------; ! 28: ; ! 29: ; VOID vSetDIB4ToVGATables(UCHAR * pucConvTable); ! 30: ; ! 31: ; Creates the four 256-byte tables used for conversion from DIB4 to VGA. ! 32: ; ! 33: ; pucConvTable = pointer to 1K of storage into which the conversion ! 34: ; tables are placed ! 35: ; ! 36: ;-----------------------------------------------------------------------; ! 37: ;-----------------------------------------------------------------------; ! 38: ; ! 39: ; Note: The general-purpose buffer attached to the PDEV that we used for ! 40: ; temp storage (pvBankBufferPlane0) must be at least 1K+4 bytes wide to ! 41: ; support ! 42: ; ! 43: ; Note: Assumes the destination rectangle has a positive height and width. ! 44: ; Will not work properly if this is not the case. ! 45: ; ! 46: ; Note: The source must be a standard DIB4 bitmap, and the destination ! 47: ; must be VGA display memory. ! 48: ; ! 49: ; Note: Performance would benefit if we did more scans at a time in each ! 50: ; plane on processor/VGA combinations that supported higher conversion ! 51: ; and display memory writing speeds. ! 52: ; ! 53: ;-----------------------------------------------------------------------; ! 54: ! 55: .386 ! 56: ! 57: ifndef DOS_PLATFORM ! 58: .model small,c ! 59: else ! 60: ifdef STD_CALL ! 61: .model small,c ! 62: else ! 63: .model small,pascal ! 64: endif; STD_CALL ! 65: endif; DOS_PLATFORM ! 66: ! 67: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT ! 68: assume fs:nothing,gs:nothing ! 69: ! 70: .xlist ! 71: include stdcall.inc ;calling convention cmacros ! 72: include i386\egavga.inc ! 73: include i386\strucs.inc ! 74: ! 75: .list ! 76: ! 77: ;-----------------------------------------------------------------------; ! 78: ! 79: .data ! 80: ! 81: ;-----------------------------------------------------------------------; ! 82: ; Masks to be applied to the source data for the 8 possible clip ! 83: ; alignments. ! 84: ;-----------------------------------------------------------------------; ! 85: ! 86: jLeftMasks db 0ffh, 07fh, 03fh, 01fh, 00fh, 007h, 003h, 001h ! 87: jRightMasks db 0ffh, 080h, 0c0h, 0e0h, 0f0h, 0f8h, 0fch, 0feh ! 88: ! 89: ;-----------------------------------------------------------------------; ! 90: ; The following tables *must* start on 256-byte boundaries, so that a ! 91: ; table look-up may be accomplished by loading BL. ! 92: ;-----------------------------------------------------------------------; ! 93: ! 94: ;-----------------------------------------------------------------------; ! 95: ; Table used to multiplex bits from form accumulated from DIB4 to VGA ! 96: ; planar byte format for plane 0. Translation is from 64207531 source ! 97: ; DIB format (where 0 is leftmost, 7 is rightmost) to 76543210 VGA ! 98: ; format (where 7 is leftmost, 0 is rightmost). ! 99: if 0 ! 100: align 256 ! 101: ;@@@ ! 102: db 256-20h dup (?) ! 103: ;@@@ ! 104: ;DIB4_to_VGA_plane0_table label byte ! 105: x=0 ! 106: rept 256 ! 107: db ((x and 10h) shl 3)+((x and 01h) shl 6)+\ ! 108: (x and 20h) +((x and 02h) shl 3)+\ ! 109: ((x and 40h) shr 3)+ (x and 04h) +\ ! 110: ((x and 80h) shr 6)+((x and 08h) shr 3) ! 111: x=x+1 ! 112: endm ! 113: ;-----------------------------------------------------------------------; ! 114: ; Table used to multiplex bits from form accumulated from DIB4 to VGA ! 115: ; planar byte format for plane 0. Translation is from 46025713 source ! 116: ; DIB format (where 0 is leftmost, 7 is rightmost) to 76543210 VGA ! 117: ; format (where 7 is leftmost, 0 is rightmost). ! 118: ! 119: ;DIB4_to_VGA_plane1_table label byte ! 120: x=0 ! 121: rept 256 ! 122: db ((x and 20h) shl 2)+((x and 02h) shl 5)+\ ! 123: ((x and 10h) shl 1)+((x and 01h) shl 4)+\ ! 124: ((x and 80h) shr 4)+((x and 08h) shr 1)+\ ! 125: ((x and 40h) shr 5)+((x and 04h) shr 2) ! 126: x=x+1 ! 127: endm ! 128: ;-----------------------------------------------------------------------; ! 129: ; Table used to multiplex bits from form accumulated from DIB4 to VGA ! 130: ; planar byte format for plane 0. Translation is from 20643175 source ! 131: ; DIB format (where 0 is leftmost, 7 is rightmost) to 76543210 VGA ! 132: ; format (where 7 is leftmost, 0 is rightmost). ! 133: ! 134: ;DIB4_to_VGA_plane2_table label byte ! 135: x=0 ! 136: rept 256 ! 137: db ((x and 40h) shl 1)+((x and 04h) shl 4)+\ ! 138: ((x and 80h) shr 2)+((x and 08h) shl 1)+\ ! 139: ((x and 10h) shr 1)+((x and 01h) shl 2)+\ ! 140: ((x and 20h) shr 4)+((x and 02h) shr 1) ! 141: x=x+1 ! 142: endm ! 143: ;-----------------------------------------------------------------------; ! 144: ; Table used to multiplex bits from form accumulated from DIB4 to VGA ! 145: ; planar byte format for plane 0. Translation is from 02461357 source ! 146: ; DIB format (where 0 is leftmost, 7 is rightmost) to 76543210 VGA ! 147: ; format (where 7 is leftmost, 0 is rightmost). ! 148: ! 149: ;DIB4_to_VGA_plane3_table label byte ! 150: x=0 ! 151: rept 256 ! 152: db (x and 80h) +((x and 08h) shl 3)+\ ! 153: ((x and 40h) shr 1)+((x and 04h) shl 2)+\ ! 154: ((x and 20h) shr 2)+((x and 02h) shl 1)+\ ! 155: ((x and 10h) shr 3)+ (x and 01h) ! 156: x=x+1 ! 157: endm ! 158: endif ! 159: ;-----------------------------------------------------------------------; ! 160: ! 161: .code ! 162: ! 163: _TEXT$01 SEGMENT DWORD USE32 PUBLIC 'CODE' ! 164: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING ! 165: ! 166: ;-----------------------------------------------------------------------; ! 167: ! 168: cProc vSetDIB4ToVGATables,4,< \ ! 169: uses esi edi ebx, \ ! 170: pucConvTable : dword > ! 171: ! 172: mov ebx,pucConvTable ! 173: ! 174: ; Generate the table used to multiplex bits from form accumulated from DIB4 ! 175: ; to VGA planar byte format for plane 0. Translation is from 64207531 source ! 176: ; DIB format (where 0 is leftmost, 7 is rightmost) to 76543210 VGA ! 177: ; format (where 7 is leftmost, 0 is rightmost). ! 178: ! 179: mov ecx,256 ! 180: sub al,al ! 181: plane0_conv_table_loop: ! 182: sub dl,dl ! 183: mov ah,al ! 184: and ah,10h ! 185: shl ah,3 ! 186: or dl,ah ! 187: mov ah,al ! 188: and ah,01h ! 189: shl ah,6 ! 190: or dl,ah ! 191: mov ah,al ! 192: and ah,20h ! 193: or dl,ah ! 194: mov ah,al ! 195: and ah,02h ! 196: shl ah,3 ! 197: or dl,ah ! 198: mov ah,al ! 199: and ah,40h ! 200: shr ah,3 ! 201: or dl,ah ! 202: mov ah,al ! 203: and ah,04h ! 204: or dl,ah ! 205: mov ah,al ! 206: and ah,80h ! 207: shr ah,6 ! 208: or dl,ah ! 209: mov ah,al ! 210: and ah,08h ! 211: shr ah,3 ! 212: or dl,ah ! 213: mov [ebx],dl ! 214: inc al ! 215: inc ebx ! 216: dec ecx ! 217: jnz plane0_conv_table_loop ! 218: ! 219: ; Generate the table used to multiplex bits from form accumulated from DIB4 ! 220: ; to VGA planar byte format for plane 1. Translation is from 46025713 source ! 221: ; DIB format (where 0 is leftmost, 7 is rightmost) to 76543210 VGA ! 222: ; format (where 7 is leftmost, 0 is rightmost). ! 223: ! 224: mov ecx,256 ! 225: sub al,al ! 226: plane1_conv_table_loop: ! 227: sub dl,dl ! 228: mov ah,al ! 229: and ah,20h ! 230: shl ah,2 ! 231: or dl,ah ! 232: mov ah,al ! 233: and ah,02h ! 234: shl ah,5 ! 235: or dl,ah ! 236: mov ah,al ! 237: and ah,10h ! 238: shl ah,1 ! 239: or dl,ah ! 240: mov ah,al ! 241: and ah,01h ! 242: shl ah,4 ! 243: or dl,ah ! 244: mov ah,al ! 245: and ah,80h ! 246: shr ah,4 ! 247: or dl,ah ! 248: mov ah,al ! 249: and ah,08h ! 250: shr ah,1 ! 251: or dl,ah ! 252: mov ah,al ! 253: and ah,40h ! 254: shr ah,5 ! 255: or dl,ah ! 256: mov ah,al ! 257: and ah,04h ! 258: shr ah,2 ! 259: or dl,ah ! 260: mov [ebx],dl ! 261: inc al ! 262: inc ebx ! 263: dec ecx ! 264: jnz plane1_conv_table_loop ! 265: ! 266: ; Generate the table used to multiplex bits from form accumulated from DIB4 ! 267: ; to VGA planar byte format for plane 2. Translation is from 20643175 source ! 268: ; DIB format (where 0 is leftmost, 7 is rightmost) to 76543210 VGA ! 269: ; format (where 7 is leftmost, 0 is rightmost). ! 270: ! 271: mov ecx,256 ! 272: sub al,al ! 273: plane2_conv_table_loop: ! 274: sub dl,dl ! 275: mov ah,al ! 276: and ah,40h ! 277: shl ah,1 ! 278: or dl,ah ! 279: mov ah,al ! 280: and ah,04h ! 281: shl ah,4 ! 282: or dl,ah ! 283: mov ah,al ! 284: and ah,80h ! 285: shr ah,2 ! 286: or dl,ah ! 287: mov ah,al ! 288: and ah,08h ! 289: shl ah,1 ! 290: or dl,ah ! 291: mov ah,al ! 292: and ah,10h ! 293: shr ah,1 ! 294: or dl,ah ! 295: mov ah,al ! 296: and ah,01h ! 297: shl ah,2 ! 298: or dl,ah ! 299: mov ah,al ! 300: and ah,20h ! 301: shr ah,4 ! 302: or dl,ah ! 303: mov ah,al ! 304: and ah,02h ! 305: shr ah,1 ! 306: or dl,ah ! 307: mov [ebx],dl ! 308: inc al ! 309: inc ebx ! 310: dec ecx ! 311: jnz plane2_conv_table_loop ! 312: ! 313: ; Generate the table used to multiplex bits from form accumulated from DIB4 ! 314: ; to VGA planar byte format for plane 1. Translation is from 02461357 source ! 315: ; DIB format (where 0 is leftmost, 7 is rightmost) to 76543210 VGA ! 316: ; format (where 7 is leftmost, 0 is rightmost). ! 317: ! 318: mov ecx,256 ! 319: sub al,al ! 320: plane3_conv_table_loop: ! 321: sub dl,dl ! 322: mov ah,al ! 323: and ah,80h ! 324: or dl,ah ! 325: mov ah,al ! 326: and ah,08h ! 327: shl ah,3 ! 328: or dl,ah ! 329: mov ah,al ! 330: and ah,40h ! 331: shr ah,1 ! 332: or dl,ah ! 333: mov ah,al ! 334: and ah,04h ! 335: shl ah,2 ! 336: or dl,ah ! 337: mov ah,al ! 338: and ah,20h ! 339: shr ah,2 ! 340: or dl,ah ! 341: mov ah,al ! 342: and ah,02h ! 343: shl ah,1 ! 344: or dl,ah ! 345: mov ah,al ! 346: and ah,10h ! 347: shr ah,3 ! 348: or dl,ah ! 349: mov ah,al ! 350: and ah,01h ! 351: or dl,ah ! 352: mov [ebx],dl ! 353: inc al ! 354: inc ebx ! 355: dec ecx ! 356: jnz plane3_conv_table_loop ! 357: ! 358: cRet vSetDIB4ToVGATables ;done ! 359: ! 360: endProc vSetDIB4ToVGATables ! 361: ! 362: ;-----------------------------------------------------------------------; ! 363: ! 364: cProc vDIB2VGA,20,< \ ! 365: uses esi edi ebx, \ ! 366: pdsurfDst: ptr DEVSURF, \ ! 367: pdsurfSrc: ptr DEVSURF, \ ! 368: prclDst: ptr RECTL, \ ! 369: pptlSrc : ptr POINTL, \ ! 370: pConv : dword > ! 371: ! 372: local ulWholeDwordCount:dword ;# of whole VGA dwords to copy to ! 373: local ulSourceDwordWidth:dword ;# of DIB dwords from which to copy ! 374: ; (rounded up to the nearest dword) ! 375: local ulLeftMask:dword ;low byte = mask for new pixels at ! 376: ; left edge; ! 377: ;high byte = mask for dest at left ! 378: ; edge; ! 379: ;high word = 0ffffh ! 380: local ulRightMask:dword ;low byte = mask for new pixels at ! 381: ; partial left edge; ! 382: ;high byte = mask for destination at ! 383: ; partial right edge; ! 384: ;high word = 0ffffh ! 385: local ulPlane0Scans:dword ;# of scans to copy in plane 0 in burst ! 386: local ulPlane1Scans:dword ;# of scans to copy in plane 1 in burst ! 387: local ulPlane2Scans:dword ;# of scans to copy in plane 2 in burst ! 388: local ulPlane3Scans:dword ;# of scans to copy in plane 3 in burst ! 389: local ulSrcDelta:dword ;offset from end of one source scan to ! 390: ; copy to start of next in working ! 391: ; source (either DIB or temp buffer) ! 392: local ulTrueSrcDelta:dword ;offset from end of one source scan to ! 393: ; copy to start of next in DIB if temp ! 394: ; buffer is being used ! 395: local ulDstDelta:dword ;offset from end of one destination ! 396: ; scan to copy to start of next ! 397: local pSrc:dword ;pointer to working drawing src start ! 398: ; address (either DIB or temp buffer) ! 399: local pTrueSrc:dword ;pointer to drawing src start address ! 400: ; in DIB if temp buffer is being used ! 401: local pDst:dword ;pointer to drawing dst start address ! 402: local pTempBuffer:dword ;pointer to buffer used for alignment ! 403: local ulCurrentTopScan:dword ;top scan to copy to in current bank ! 404: local ulBottomScan:dword ;bottom scan line of copy rectangle ! 405: local ulAlignShift:dword ;# of bits to shift left (+) or right ! 406: ; (-) to dword align source to dest ! 407: local ulBurstMax:dword ;max # of scans to be done in a single ! 408: ; plane before switching to the next ! 409: ; plane (to avoid flicker) ! 410: local pAlignmentRoutine:dword ;pointer to routine to be used to ! 411: ; copy & align the source with the dest ! 412: local DIB4_to_VGA_plane0_table:dword ;pointers to conversion tables ! 413: local DIB4_to_VGA_plane1_table:dword ; for the four planes ! 414: local DIB4_to_VGA_plane2_table:dword ! 415: local DIB4_to_VGA_plane3_table:dword ! 416: local ulCopyControlFlags:dword ;upper bits indicate which portions of ! 417: ; copy are to be performed, as follows: ! 418: ODD_WHOLE_WORD equ 80000000h ;there are an odd # of VGA words to ! 419: ; copy to ! 420: .errnz ODD_WHOLE_WORD-80000000h ; (note that this *must* be bit 31, ! 421: ; because the sign status is used to ! 422: ; detect this case) ! 423: WHOLE_WORDS equ 40000000h ;whole words to be copied ! 424: LEADING_BYTE equ 20000000h ;leading byte should be copied ! 425: TRAILING_BYTE equ 10000000h ;trailing byte should be copied ! 426: LEADING_PARTIAL equ 08000000h ;partial leading byte should be copied ! 427: TRAILING_PARTIAL equ 04000000h ;partial trailing byte should be copied ! 428: ! 429: ;-----------------------------------------------------------------------; ! 430: ! 431: cld ! 432: ! 433: ;-----------------------------------------------------------------------; ! 434: ; Point to the source start address (nearest dword equal or less). ! 435: ;-----------------------------------------------------------------------; ! 436: ! 437: mov ebx,pptlSrc ;point to coords of source upper left ! 438: mov esi,pdsurfSrc ;point to surface to copy from (DIB4) ! 439: mov edi,pdsurfDst ;point to surface to copy to (VGA) ! 440: mov eax,[ebx].ptl_y ! 441: mul [esi].dsurf_lNextScan ;offset in bitmap of top src rect scan ! 442: mov edx,[ebx].ptl_x ! 443: shr edx,1 ;source byte X address ! 444: and edx,not 11b ;round down to nearest dword ! 445: add eax,edx ;offset in bitmap of first source dword ! 446: add eax,[esi].dsurf_pvBitmapStart ;pointer to first source dword ! 447: mov pSrc,eax ! 448: ! 449: ;-----------------------------------------------------------------------; ! 450: ; Set the pointers to the DIB->VGA conversion tables for the four ! 451: ; planes; those tables are created at start-up, and found via the PDEV. ! 452: ;-----------------------------------------------------------------------; ! 453: ! 454: mov eax,pConv ;first conversion table ! 455: mov DIB4_to_VGA_plane0_table,eax ! 456: inc ah ;add 256 to point to next table ! 457: mov DIB4_to_VGA_plane1_table,eax ! 458: inc ah ;add 256 to point to next table ! 459: mov DIB4_to_VGA_plane2_table,eax ! 460: inc ah ;add 256 to point to next table ! 461: mov DIB4_to_VGA_plane3_table,eax ! 462: ! 463: ;-----------------------------------------------------------------------; ! 464: ; Set up various variables for the copy. ! 465: ; ! 466: ; At this point, EBX = pptlSrc, EDI = pdsurfDst. ! 467: ;-----------------------------------------------------------------------; ! 468: ! 469: mov esi,prclDst ;point to rectangle to which to copy ! 470: sub ecx,ecx ;accumulate copy control flags, which ! 471: ; describe the various portions of the ! 472: ; copy we want to perform ! 473: ! 474: ;first, check for partial-byte edges ! 475: mov eax,[esi].xLeft ! 476: and eax,111b ;left edge pixel alignment ! 477: jz short @F ;whole byte, don't need leading mask ! 478: or ecx,LEADING_PARTIAL ;do need leading mask ! 479: @@: ! 480: mov edx,-1 ;set high word, so copy control bits ! 481: ; aren't wiped out by AND ! 482: mov dl,jLeftMasks[eax] ;mask to apply to source to clip ! 483: mov dh,dl ! 484: not dh ;mask to apply to dest to preserve ! 485: mov ulLeftMask,edx ;remember mask ! 486: ! 487: mov eax,[esi].xRight ! 488: and eax,111b ;right edge pixel alignment ! 489: jz short @F ;whole byte, don't need trailing mask ! 490: or ecx,TRAILING_PARTIAL ;do need trailing mask ! 491: @@: ! 492: mov edx,-1 ;set high word, so copy control bits ! 493: ; aren't wiped out by AND ! 494: mov dl,jRightMasks[eax] ;mask to apply to source to clip ! 495: mov dh,dl ! 496: not dh ;mask to apply to dest to preserve ! 497: mov ulRightMask,edx ;remember mask ! 498: ! 499: ;now, see if there are only partial ! 500: ; bytes, or maybe even only one byte ! 501: mov eax,[esi].xLeft ! 502: add eax,111b ! 503: and eax,not 111b ;round left up to nearest byte ! 504: mov edx,[esi].xRight ! 505: and edx,not 111b ;round right down to nearest byte ! 506: sub edx,eax ;# of pixels, rounded to nearest byte ! 507: ; boundaries (not counting partials) ! 508: ja short check_whole_bytes ;there's at least one whole byte ! 509: ;there are no whole bytes; there may be ! 510: ; only one partial byte, or there may ! 511: ; be two ! 512: jb short one_partial_only ;there is only one, partial byte ! 513: ;if the dest is left- or right- ! 514: ; justified, then there's only one, ! 515: ; partial byte, otherwise there are two ! 516: ; partial bytes ! 517: cmp byte ptr ulLeftMask,0ffh ;left-justified in byte? ! 518: jz short one_partial_only ;yes, so only one, partial byte ! 519: cmp byte ptr ulRightMask,0ffh ;right-justified in byte? ! 520: jnz short set_copy_control_flags ;no, so there are two partial ! 521: ; bytes, which is exactly what ! 522: ; we're already set up to do ! 523: one_partial_only: ;only one, partial byte, so construct a ! 524: ; single mask and set up to do just ! 525: ; one, partial byte ! 526: mov eax,ulLeftMask ! 527: and eax,ulRightMask ;intersect the masks ! 528: mov ah,al ! 529: not ah ;construct the destination mask ! 530: mov ulLeftMask,eax ! 531: mov ecx,LEADING_PARTIAL ;only one partial byte, which we'll ! 532: ; treat as leading ! 533: jmp short set_copy_control_flags ;the copy control flags are set ! 534: ! 535: align 4 ! 536: check_whole_bytes: ! 537: ;check for leading and trailing odd ! 538: ; (non-word-aligned) whole bytes ! 539: mov eax,[esi].xLeft ;check for leading whole byte ! 540: and eax,1111b ;intra-word address ! 541: jz short @F ;whole leading word, so no whole byte ! 542: cmp eax,8 ;is start at or before second byte ! 543: ; start? ! 544: ja short @F ;no, so no whole byte ! 545: or ecx,LEADING_BYTE ;yes, there's a leading byte ! 546: @@: ! 547: ! 548: mov eax,[esi].xRight ;check for trailing whole byte ! 549: and eax,1111b ;intra-word address ! 550: jz short @F ;whole trailing word, so no whole byte ! 551: cmp eax,8 ;is start before second byte start? ! 552: jb short @F ;no, so no whole byte ! 553: or ecx,TRAILING_BYTE ;yes, there's a trailing byte ! 554: @@: ! 555: ! 556: ;finally, calculate the number of whole ! 557: ; aligned words and pairs thereof we'll ! 558: ; process ! 559: mov eax,[esi].xLeft ! 560: add eax,1111b ! 561: shr eax,4 ;round left up to nearest word ! 562: mov edx,[esi].xRight ! 563: shr edx,4 ;round down to nearest word ! 564: sub edx,eax ;# of whole aligned words ! 565: jz short set_copy_control_flags ;no whole aligned words ! 566: or ecx,WHOLE_WORDS ;mark that we have whole aligned words ! 567: inc edx ! 568: shr edx,1 ;# of whole dwords, or fractions ! 569: mov ulWholeDwordCount,edx ; thereof ! 570: jc short set_copy_control_flags ;no odd word ! 571: or ecx,ODD_WHOLE_WORD ;mark that we have an odd word to copy ! 572: ! 573: set_copy_control_flags: ! 574: mov ulCopyControlFlags,ecx ! 575: ! 576: ;-----------------------------------------------------------------------; ! 577: ; If we're going to have to read from display memory, set up the Graphics ! 578: ; Controller to point to the Read Map, so we can save some OUTs later. ! 579: ; ! 580: ; At this point, EBX = pptlSrc, ECX = ulCopyControlFlags, ESI = prclDst, ! 581: ; EDI = pdsurfDst. ! 582: ;-----------------------------------------------------------------------; ! 583: ! 584: test ecx,LEADING_PARTIAL or TRAILING_PARTIAL ! 585: jz short @F ! 586: mov edx,VGA_BASE + GRAF_ADDR ! 587: mov al,GRAF_READ_MAP ! 588: out dx,al ;leave GRAF_ADDR pointing to Read Map ! 589: @@: ! 590: ! 591: ;-----------------------------------------------------------------------; ! 592: ; Set up the offsets to the next source and destination scans. ! 593: ; ! 594: ; At this point, EBX = pptlSrc, ESI = prclDst, EDI = pdsurfDst. ! 595: ;-----------------------------------------------------------------------; ! 596: ! 597: mov eax,[esi].xLeft ! 598: shr eax,3 ;left edge byte ! 599: mov edx,[esi].xRight ! 600: add edx,111b ;byte after right edge ! 601: shr edx,3 ! 602: sub edx,eax ;# of bytes across dest ! 603: mov eax,[edi].dsurf_lNextScan ! 604: sub eax,edx ;offset from last byte dest copied to on one ! 605: mov ulDstDelta,eax ; scan to first dest byte copied to on next ! 606: ! 607: mov ecx,pdsurfSrc ! 608: mov eax,[esi].xLeft ! 609: mov edx,[esi].xRight ! 610: sub edx,eax ;width in pixels ! 611: push edx ;remember width in pixels ! 612: mov eax,[ebx].ptl_x ;source left edge ! 613: add edx,eax ;source right edge ! 614: shr eax,1 ;source left start byte ! 615: and eax,not 11b ;source left start rounded to nearest dword ! 616: inc edx ! 617: shr edx,1 ;source right byte after last byte copied ! 618: add edx,11b ! 619: and edx,not 11b ;round up to source right dword after last byte ! 620: ; copied ! 621: sub edx,eax ;source width in bytes, rounded to dwords ! 622: ; (because we always work with source dwords) ! 623: mov eax,[ecx].dsurf_lNextScan ! 624: sub eax,edx ;offset from last source byte copied from on ! 625: mov ulSrcDelta,eax ; one scan to first source byte copied to on ! 626: ; next ! 627: ! 628: ;-----------------------------------------------------------------------; ! 629: ; Set up the maximum burst size (# of scans to do before switching ! 630: ; planes). ! 631: ; ! 632: ; At this point, EBX = pptlSrc, ESI = prclDst, EDI = pdsurfDst. ! 633: ;-----------------------------------------------------------------------; ! 634: ! 635: pop edx ;retrieve width in pixels ! 636: mov eax,2 ;assume we'll only do two scans per burst ! 637: ; (the minimum number) ! 638: test edx,not 0feh ;>511 pixels? ! 639: jnz short @F ;yes, so do two scans at a time, to avoid ! 640: ; flicker as separate planes are done ! 641: ;***note: this is a tentative value, and ! 642: ; experience may indicate that it should be ! 643: ; increased or reduced to 1*** ! 644: ;<512 pixels, so we can do more scans per ! 645: ; plane, thereby saving lots of OUTs. The exact ! 646: ; # of scans depends on how wide the copy is; ! 647: ; the wider it is, the fewer scans ! 648: mov al,4 ;assume we'll do four scans per plane ! 649: test dh,1 ;256 or more wide? ! 650: jnz short @F ;512>width>=256, four scans will do the job ! 651: mov al,8 ;assume we'll do eight scans per plane ! 652: add dl,dl ;128 or more wide? ! 653: jc short @F ;256>width>=128, eight scans is fine ! 654: mov al,16 ;assume we'll do sixteen scans per plane ! 655: js short @F ;128>width>=64, sixteen will do fine ! 656: mov al,32 ;<64 wide, so we'll do 32 scans per plane ! 657: @@: ! 658: mov ulBurstMax,eax ;this is the longest burst we'll do in a single ! 659: ; plane ! 660: ! 661: ;-----------------------------------------------------------------------; ! 662: ; Determine whether any shift is needed to align the source with the ! 663: ; destination. ! 664: ; ! 665: ; At this point, EBX = pptlSrc, ESI = prclDst, EDI = pdsurfDst. ! 666: ;-----------------------------------------------------------------------; ! 667: ! 668: mov eax,[ebx].ptl_x ! 669: and eax,111b ;source X modulo 8 ! 670: mov edx,[esi].xLeft ! 671: and edx,111b ;dest X modulo 8 ! 672: sub eax,edx ;(source X modulo 8) - (dest X modulo 8) ! 673: mov ulAlignShift,eax ;remember the shift ! 674: jz short set_initial_banking ;if it's 0, we have no alignment to ! 675: ; do, and are ready to roll ! 676: ! 677: ;-----------------------------------------------------------------------; ! 678: ; Alignment is needed, so set up the alignment variables. ! 679: ; ! 680: ; At this point, EBX = pptlSrc, ESI = prclDst, EDI = pdsurfDst, ! 681: ; EAX = shift, in range -7 to 7. ! 682: ;-----------------------------------------------------------------------; ! 683: ! 684: mov edx,ulSrcDelta ;remember the real source width; we'll fake ! 685: mov ulTrueSrcDelta,edx ; ulSrcDelta for the drawing routines ! 686: ! 687: ;set ulSrcDelta to either 0 or 4, ! 688: ; depending on whether the last dword ! 689: ; we rotate is needed (because we ! 690: ; always generate as many dest dwords as ! 691: ; there are source dwords on left shifts, ! 692: ; and we always generate dest dwords = # source ! 693: ; dwords + 1 on right shifts, whether we need ! 694: ; the last dword or not; we only need it when ! 695: ; the right edge shifts left) ! 696: mov ecx,[esi].xRight ! 697: sub ecx,[esi].xLeft ! 698: add ecx,[ebx].ptl_x ;CL = lsb of source right edge ! 699: dec ecx ;adjust to actual right X, rather than X+1 ! 700: mov ch,byte ptr [esi].xRight ;CH = lsb of dest right edge ! 701: dec ch ;adjust to actual right X, rather than X+1 ! 702: and ecx,0707h ;right source and dest intrabyte addresses ! 703: sub edx,edx ;assume we need the last byte, in which case ! 704: ; the source in the temp buffer (from which we ! 705: ; always copy after rotation) is contiguous ! 706: cmp ch,cl ;right or left shift at right edge? ! 707: jb short @F ;left shift at right edge, so every byte in the ! 708: ; temp buffer will be used ! 709: add edx,4 ;right shift at right edge, so the last byte in ! 710: ; the temp buffer won't be used, thus skip it ! 711: @@: ! 712: mov ulSrcDelta,edx ;delta to next scan in temp buffer ! 713: ! 714: mov ecx,[edi].dsurf_ppdev ;point to pdev for 386 flag ! 715: and eax,eax ;shift left or right? ! 716: js short @F ;shift right ! 717: ;shift left ! 718: ! 719: mov edx,offset align_burst_lshift_486 ;shifting left, assume 486 ! 720: cmp [ecx].PDEV_is386,0 ;486? ! 721: jz short set_shift_vec ;yes ! 722: mov edx,offset align_burst_lshift_386 ;386 ! 723: jmp short set_shift_vec ! 724: ! 725: align 4 ! 726: @@: ;shifting right ! 727: ! 728: and eax,7 ;for left shift, shift value is already ! 729: ; correct; for right shift, this is equivalent ! 730: ; to 8 - right shift, since we always shift ! 731: ; left (remember, EAX is currently negative for ! 732: ; right shifts) ! 733: mov edx,offset align_burst_rshift_386 ;shifting right, assume 386 ! 734: cmp [ecx].PDEV_is386,0 ;386? ! 735: jnz short set_shift_vec ;yes ! 736: mov edx,offset align_burst_rshift_486 ;486 ! 737: set_shift_vec: ! 738: mov pAlignmentRoutine,edx ;routine to be used to shift into ! 739: ; alignment with destination ! 740: shl eax,2 ;multiply by 4 because we're dealing with ! 741: ; 4-bit pixels ! 742: mov ulAlignShift,eax ;remember the shift amount ! 743: mov eax,[esi].xRight ! 744: sub eax,[esi].xLeft ;pixel width of rectangle to copy ! 745: mov edx,[ebx].ptl_x ;left pixel of source ! 746: and edx,111b ;distance in pixels from left pixel to pixel at ! 747: ; start of left dword ! 748: add eax,edx ;pixel width from start of left dword to right ! 749: ; edge of copy in source ! 750: add eax,7 ;round up to nearest dword (8 pixel set) ! 751: shr eax,3 ;# of dwords spanned by source ! 752: mov ulSourceDwordWidth,eax ;always pick up this number of dwords ! 753: ; when aligning ! 754: ! 755: mov eax,[edi].dsurf_pvBankBufferPlane0 ;this is the general-purpose ! 756: mov pTempBuffer,eax ; temporary-use buffer ! 757: ! 758: mov eax,pSrc ;remember the real source pointer; we'll fake ! 759: mov pTrueSrc,eax ; pSrc for the drawing routines ! 760: ! 761: ;-----------------------------------------------------------------------; ! 762: ; Copy all banks in the destination rectangle, one at a time. ! 763: ; ! 764: ; At this point, ESI = prclDst, EDI = pdsurfDst ! 765: ;-----------------------------------------------------------------------; ! 766: ! 767: set_initial_banking: ! 768: ! 769: ;-----------------------------------------------------------------------; ! 770: ; Map in the bank containing the top scan to copy to, if it's not mapped ! 771: ; in already. ! 772: ;-----------------------------------------------------------------------; ! 773: ! 774: mov eax,[esi].yBottom ! 775: mov ulBottomScan,eax ;bottom scan to which to copy ! 776: mov eax,[esi].yTop ;top scan line of copy ! 777: mov ulCurrentTopScan,eax ;this will be the copy top in 1st bank ! 778: ! 779: cmp eax,[edi].dsurf_rcl1WindowClip.yTop ;is copy top less than ! 780: ; current bank? ! 781: jl short map_init_bank ;yes, map in proper bank ! 782: cmp eax,[edi].dsurf_rcl1WindowClip.yBottom ;copy top greater than ! 783: ; current bank? ! 784: jl short init_bank_mapped ;no, proper bank already mapped ! 785: map_init_bank: ! 786: ! 787: ; Map in the bank containing the top scan line of the copy dest. ! 788: ! 789: ptrCall <dword ptr [edi].dsurf_pfnBankControl>,<edi,eax,JustifyTop> ! 790: ! 791: init_bank_mapped: ! 792: ! 793: ;-----------------------------------------------------------------------; ! 794: ; Compute the starting address for the initial dest bank. ! 795: ;-----------------------------------------------------------------------; ! 796: ! 797: mov eax,ulCurrentTopScan ;top scan line to which to copy in ! 798: ; current bank ! 799: imul [edi].dsurf_lNextScan ;offset of starting scan line ! 800: mov edx,[esi].xLeft ;left dest X coordinate ! 801: shr edx,3 ;left dest byte offset in row ! 802: add eax,edx ;initial offset in dest bitmap ! 803: ! 804: ; Note that the start of the bitmap will change each time through the ! 805: ; bank loop, because the start of the bitmap is varied to map the ! 806: ; desired scan line to the banking window. ! 807: ! 808: add eax,[edi].dsurf_pvBitmapStart ;initial dest bitmap address ! 809: mov pDst,eax ;remember where to start drawing ! 810: ! 811: ;-----------------------------------------------------------------------; ! 812: ; Main loop for processing copying to each bank. ! 813: ; ! 814: ; At this point, EDI->pdsurfDst ! 815: ;-----------------------------------------------------------------------; ! 816: ! 817: bank_loop: ! 818: ! 819: ; Calculate the # of scans to do in this bank. ! 820: ! 821: mov ebx,ulBottomScan ;bottom of destination rectangle ! 822: cmp ebx,[edi].dsurf_rcl1WindowClip.yBottom ! 823: ;which comes first, the bottom of the ! 824: ; dest rect or the bottom of the ! 825: ; current bank? ! 826: jl short @F ;copy bottom comes first, so draw to ! 827: ; that; this is the last bank in copy ! 828: mov ebx,[edi].dsurf_rcl1WindowClip.yBottom ! 829: ;bank bottom comes first; draw to ! 830: ; bottom of bank ! 831: @@: ! 832: sub ebx,ulCurrentTopScan ;# of scans to copy in bank ! 833: ! 834: ;-----------------------------------------------------------------------; ! 835: ; Copy to the screen in bursts of either ulBurstMax size or remaining ! 836: ; number of scans in bank, whichever is less. ! 837: ; ! 838: ; At this point, EBX = # of scans remaining in bank. ! 839: ;-----------------------------------------------------------------------; ! 840: ! 841: copy_burst_loop: ! 842: mov eax,ulBurstMax ;most scans we can copy per plane ! 843: sub ebx,eax ;# of scans left in bank after copying that many ! 844: jnle short @F ;there are enough scans left to copy max # ! 845: add eax,ebx ;not enough scans left; copy all remaining scans ! 846: sub ebx,ebx ;after this, no scans remain in bank ! 847: @@: ! 848: push ebx ;# of scan lines remaining in bank after burst ! 849: ;EAX = # of scans in burst ! 850: mov ulPlane0Scans,eax ;set the scan count for each of the plane ! 851: mov ulPlane1Scans,eax ; loops ! 852: mov ulPlane2Scans,eax ! 853: mov ulPlane3Scans,eax ! 854: ! 855: ;-----------------------------------------------------------------------; ! 856: ; If necessary, align the dwords in this burst so that the left edge is ! 857: ; on a dword boundary. ! 858: ; ! 859: ; At this point, AL = # of scans in burst. ! 860: ;-----------------------------------------------------------------------; ! 861: ! 862: mov ecx,ulAlignShift ! 863: and ecx,ecx ;is alignment needed? ! 864: jz proceed_with_copy ;no, so we're ready to copy ! 865: ! 866: mov ch,al ;# of scans to copy ! 867: mov esi,pTrueSrc ;copy from current source location ! 868: mov edi,pTempBuffer ;copy to the temp buffer ! 869: ! 870: jmp pAlignmentRoutine ;perform the copy ! 871: ! 872: ;-----------------------------------------------------------------------; ! 873: ; Loops to align this burst's scans for 386/486, left or right shift. ! 874: ; ! 875: ; Input: CH = # of scans to copy in this burst (max burst = 256) ! 876: ; CL = # of bits to shift left to dword align ! 877: ; ESI = first dword of first DIB scan to convert ! 878: ; EDI = first dword of buffer into which to shift ! 879: ; ulSourceDwordWidth = # of dwords across source ! 880: ; ulTrueSrcDelta = distance from end of one source scan (rounded up to ! 881: ; nearest dword) to start of next ! 882: ; ! 883: ; All loops alway flush (write) the last dword, so one more dword ! 884: ; is written to the dest than is read from the source. This requires the ! 885: ; dest buffer to have room for an extra dword. ! 886: ;-----------------------------------------------------------------------; ! 887: ! 888: ;-----------------------------------------------------------------------; ! 889: ; Macro to copy and align the current burst for left shift. ! 890: ;-----------------------------------------------------------------------; ! 891: ! 892: ALIGN_BURST_LSHIFT macro Is486 ! 893: local align_burst_lshift_loop,align_last_lshift,align_odd_lshift ! 894: local align_lshift_loop ! 895: align_burst_lshift_loop: ! 896: mov ebx,ulSourceDwordWidth ;# of dwords across source ! 897: mov edx,[esi] ;load the initial source dword ! 898: add esi,4 ;point to next source dword ! 899: if Is486 ! 900: M_BSWAP edx ;make it big endian ! 901: else ! 902: M_BSWAP_386 edx ! 903: endif ! 904: dec ebx ;any more dwords to shift? ! 905: jz short align_last_lshift ;no, do just this one ! 906: inc ebx ! 907: shr ebx,1 ;double dword count ! 908: jnc short align_odd_lshift ;do odd dword ! 909: align 4 ! 910: align_lshift_loop: ! 911: mov eax,[esi] ;get next dword to align ! 912: add esi,4 ;point to next source dword ! 913: if Is486 ! 914: M_BSWAP eax ;make it big endian ! 915: else ! 916: M_BSWAP_386 eax ! 917: endif ! 918: shld edx,eax,cl ;shift to generate a 32-bit shifted value ! 919: if Is486 ! 920: M_BSWAP edx ;make it big endian ! 921: else ! 922: M_BSWAP_386 edx ! 923: endif ! 924: mov [edi],edx ;store it ! 925: add edi,4 ;point to next dest dword ! 926: mov edx,eax ;set up for the next shift ! 927: align_odd_lshift: ! 928: mov eax,[esi] ;get next dword to align ! 929: add esi,4 ;point to next source dword ! 930: if Is486 ! 931: M_BSWAP eax ;make it big endian ! 932: else ! 933: M_BSWAP_386 eax ! 934: endif ! 935: shld edx,eax,cl ;shift to generate a 32-bit shifted value ! 936: if Is486 ! 937: M_BSWAP edx ;make it big endian ! 938: else ! 939: M_BSWAP_386 edx ! 940: endif ! 941: mov [edi],edx ;store it ! 942: add edi,4 ;point to next dest dword ! 943: mov edx,eax ;set up for the next shift ! 944: dec ebx ;count down dwords to shift ! 945: jnz align_lshift_loop ;do next dword, if any ! 946: align_last_lshift: ;do the last dword, which doesn't require a ! 947: ; new source byte ! 948: shl edx,cl ;shift it into position ! 949: if Is486 ! 950: M_BSWAP edx ;make it big endian ! 951: else ! 952: M_BSWAP_386 edx ! 953: endif ! 954: mov [edi],edx ;store it ! 955: add edi,4 ;point to next dest dword ! 956: ! 957: add esi,ulTrueSrcDelta ;point to next source scan ! 958: dec ch ;count down scans in burst ! 959: jnz align_burst_lshift_loop ! 960: ENDM ;ALIGN_BURST_LSHIFT ! 961: ! 962: ;-----------------------------------------------------------------------; ! 963: ; Macro to copy and align the current burst for right shift. ! 964: ;-----------------------------------------------------------------------; ! 965: ! 966: ALIGN_BURST_RSHIFT macro Is486 ! 967: local align_burst_rshift_loop,align_odd_rshift,align_rshift_loop ! 968: align_burst_rshift_loop: ! 969: mov ebx,ulSourceDwordWidth ;# of dwords across source ! 970: inc ebx ! 971: shr ebx,1 ;double dword count ! 972: jnc short align_odd_rshift ;do odd dword ! 973: align 4 ! 974: align_rshift_loop: ! 975: mov eax,[esi] ;get next dword to align ! 976: add esi,4 ;point to next source dword ! 977: if Is486 ! 978: M_BSWAP eax ;make it big endian ! 979: else ! 980: M_BSWAP_386 eax ! 981: endif ! 982: shld edx,eax,cl ;shift to generate a 32-bit shifted value ! 983: if Is486 ! 984: M_BSWAP edx ;make it little endian ! 985: else ! 986: M_BSWAP_386 edx ! 987: endif ! 988: mov [edi],edx ;store it ! 989: add edi,4 ;point to next dest dword ! 990: mov edx,eax ;set up for the next shift ! 991: align_odd_rshift: ! 992: mov eax,[esi] ;get next dword to align ! 993: add esi,4 ;point to next source dword ! 994: if Is486 ! 995: M_BSWAP eax ;make it big endian ! 996: else ! 997: M_BSWAP_386 eax ! 998: endif ! 999: shld edx,eax,cl ;shift to generate a 32-bit shifted value ! 1000: if Is486 ! 1001: M_BSWAP edx ;make it little endian ! 1002: else ! 1003: M_BSWAP_386 edx ! 1004: endif ! 1005: mov [edi],edx ;store it ! 1006: add edi,4 ;point to next dest dword ! 1007: mov edx,eax ;set up for the next shift ! 1008: dec ebx ;count down dwords to shift ! 1009: jnz align_rshift_loop ;do next dword, if any ! 1010: ! 1011: ;do the trailing destination dword ! 1012: shl edx,cl ;shift into position ! 1013: if Is486 ! 1014: M_BSWAP edx ;make it little endian ! 1015: else ! 1016: M_BSWAP_386 edx ! 1017: endif ! 1018: mov [edi],edx ;store it ! 1019: add edi,4 ;point to next dest dword ! 1020: ! 1021: add esi,ulTrueSrcDelta ;point to next source scan ! 1022: dec ch ;count down scans in burst ! 1023: jnz align_burst_rshift_loop ! 1024: ENDM ;ALIGN_BURST_RSHIFT ! 1025: ;-----------------------------------------------------------------------; ! 1026: ! 1027: align 4 ! 1028: align_burst_rshift_386: ! 1029: ALIGN_BURST_RSHIFT 0 ! 1030: jmp set_alignment_source ! 1031: ! 1032: align 4 ! 1033: align_burst_lshift_386: ! 1034: ALIGN_BURST_LSHIFT 0 ! 1035: jmp set_alignment_source ! 1036: ! 1037: align 4 ! 1038: align_burst_rshift_486: ! 1039: ALIGN_BURST_RSHIFT 1 ! 1040: jmp short set_alignment_source ! 1041: ! 1042: align 4 ! 1043: align_burst_lshift_486: ! 1044: ALIGN_BURST_LSHIFT 1 ! 1045: ! 1046: ;-----------------------------------------------------------------------; ! 1047: ; Set up the pointers for a copy from the temp buffer, and advance the ! 1048: ; real pointer. ! 1049: ;-----------------------------------------------------------------------; ! 1050: set_alignment_source: ! 1051: mov pTrueSrc,esi ;remember where to start next time in source ! 1052: mov esi,pTempBuffer ;copy from the temp buffer ! 1053: mov pSrc,esi ;remember where the copy source is (DIB or ! 1054: ; temp buffer) ! 1055: ! 1056: proceed_with_copy: ! 1057: ! 1058: ; Load ECX with the copy control flags; this stays set throughout the ! 1059: ; copying of this burst. ! 1060: ! 1061: mov ecx,ulCopyControlFlags ! 1062: ! 1063: ; Copy the DIB scan to VGA plane 0. ! 1064: ! 1065: mov esi,pSrc ! 1066: mov edi,pDst ! 1067: ! 1068: ; Map in plane 0 for writes. ! 1069: ! 1070: mov edx,VGA_BASE + SEQ_DATA ! 1071: mov al,MM_C0 ! 1072: out dx,al ;map in plane 0 for writes (SEQ_ADDR points to the Map ! 1073: ; Mask by default) ! 1074: ! 1075: ; Map in plane 0 for reads if and only if we need to handle partial edge ! 1076: ; bytes, which require read/modify/write cycles. ! 1077: ! 1078: test ecx,LEADING_PARTIAL or TRAILING_PARTIAL ! 1079: jz short @F ! 1080: mov edx,VGA_BASE + GRAF_DATA ! 1081: mov al,RM_C0 ! 1082: out dx,al ;map in plane 0 for reads (GRAF_ADDR already points to ! 1083: ; Read Map) ! 1084: @@: ! 1085: jmp DIB4_to_VGA_plane0_copy ! 1086: ! 1087: align 4 ! 1088: copy_burst_plane0_done: ! 1089: ! 1090: ; Copy the DIB scan to VGA plane 1. ! 1091: ! 1092: mov esi,pSrc ! 1093: mov edi,pDst ! 1094: ! 1095: ; Map in plane 1 for writes. ! 1096: ! 1097: mov edx,VGA_BASE + SEQ_DATA ! 1098: mov al,MM_C1 ! 1099: out dx,al ;map in plane 1 for writes (SEQ_ADDR points to the Map ! 1100: ; Mask by default) ! 1101: ! 1102: ; Map in plane 1 for reads if and only if we need to handle partial edge ! 1103: ; bytes, which require read/modify/write cycles. ! 1104: ! 1105: test ecx,LEADING_PARTIAL or TRAILING_PARTIAL ! 1106: jz short @F ! 1107: mov edx,VGA_BASE + GRAF_DATA ! 1108: mov al,RM_C1 ! 1109: out dx,al ;map in plane 1 for reads (GRAF_ADDR already points to ! 1110: ; Read Map) ! 1111: @@: ! 1112: jmp DIB4_to_VGA_plane1_copy ! 1113: ! 1114: align 4 ! 1115: copy_burst_plane1_done: ! 1116: ! 1117: ; Copy the DIB scan to VGA plane 2. ! 1118: ! 1119: mov esi,pSrc ! 1120: mov edi,pDst ! 1121: ! 1122: ; Map in plane 2 for writes. ! 1123: ! 1124: mov edx,VGA_BASE + SEQ_DATA ! 1125: mov al,MM_C2 ! 1126: out dx,al ;map in plane 2 for writes (SEQ_ADDR points to the Map ! 1127: ; Mask by default) ! 1128: ! 1129: ; Map in plane 2 for reads if and only if we need to handle partial edge ! 1130: ; bytes, which require read/modify/write cycles. ! 1131: ! 1132: test ecx,LEADING_PARTIAL or TRAILING_PARTIAL ! 1133: jz short @F ! 1134: mov edx,VGA_BASE + GRAF_DATA ! 1135: mov al,RM_C2 ! 1136: out dx,al ;map in plane 2 for reads (GRAF_ADDR already points to ! 1137: ; Read Map) ! 1138: @@: ! 1139: jmp DIB4_to_VGA_plane2_copy ! 1140: ! 1141: align 4 ! 1142: copy_burst_plane2_done: ! 1143: ! 1144: ; Copy the DIB scan to VGA plane 3. ! 1145: ! 1146: mov esi,pSrc ! 1147: mov edi,pDst ! 1148: ! 1149: ; Map in plane 3 for writes. ! 1150: ! 1151: mov edx,VGA_BASE + SEQ_DATA ! 1152: mov al,MM_C3 ! 1153: out dx,al ;map in plane 3 for writes (SEQ_ADDR points to the Map ! 1154: ; Mask by default) ! 1155: ! 1156: ; Map in plane 3 for reads if and only if we need to handle partial edge ! 1157: ; bytes, which require read/modify/write cycles. ! 1158: ! 1159: test ecx,LEADING_PARTIAL or TRAILING_PARTIAL ! 1160: jz short @F ! 1161: mov edx,VGA_BASE + GRAF_DATA ! 1162: mov al,RM_C3 ! 1163: out dx,al ;map in plane 3 for reads (GRAF_ADDR already points to ! 1164: ; Read Map) ! 1165: @@: ! 1166: jmp DIB4_to_VGA_plane3_copy ! 1167: ! 1168: align 4 ! 1169: copy_burst_plane3_done: ! 1170: mov pSrc,esi ;remember where we are, for next burst ! 1171: mov pDst,edi ! 1172: ! 1173: pop ebx ;get back remaining length in bank ! 1174: and ebx,ebx ;anything left in this bank? ! 1175: jnz copy_burst_loop ;continue if so ! 1176: ! 1177: ; Done with bank; are there more banks to do? ! 1178: ! 1179: mov edi,pdsurfDst ! 1180: mov eax,[edi].dsurf_rcl1WindowClip.yBottom ;is the copy bottom in ! 1181: cmp ulBottomScan,eax ; the current bank? ! 1182: jnle short next_bank ;no, map in the next bank and copy to ! 1183: ; it ! 1184: ;yes, we're done ! 1185: ;-----------------------------------------------------------------------; ! 1186: ; Restore default Map Mask and done. ! 1187: ;-----------------------------------------------------------------------; ! 1188: mov edx,VGA_BASE + SEQ_DATA ! 1189: mov al,MM_ALL ! 1190: out dx,al ;map in all planes ! 1191: ! 1192: cRet vDIB2VGA ;done! ! 1193: ! 1194: ;-----------------------------------------------------------------------; ! 1195: ; Advance to the next bank and copy to it. ! 1196: ;-----------------------------------------------------------------------; ! 1197: align 4 ! 1198: next_bank: ! 1199: mov ulCurrentTopScan,eax ;remember where the top of the bank ! 1200: ; we're about to map in is (same as ! 1201: ; bottom of bank we just did) ! 1202: mov ecx,[edi].dsurf_pvBitmapStart ! 1203: sub pDst,ecx ;offset of current position in screen ! 1204: ! 1205: ptrCall <dword ptr [edi].dsurf_pfnBankControl>,<edi,eax,JustifyTop> ! 1206: ;map in the bank ! 1207: ! 1208: mov ecx,[edi].dsurf_pvBitmapStart ! 1209: add pDst,ecx ;pointer to current position in screen ! 1210: ! 1211: jmp bank_loop ;copy the next bank ! 1212: ! 1213: ;-----------------------------------------------------------------------; ! 1214: ; Loops for converting 1 or more scans in each of planes 0, 1, 2, and 3. ! 1215: ;-----------------------------------------------------------------------; ! 1216: ! 1217: ;-----------------------------------------------------------------------; ! 1218: ; Plane 0 DIB->VGA conversion code for a single scan line. ! 1219: ;-----------------------------------------------------------------------; ! 1220: align 4 ! 1221: DIB4_to_VGA_plane0_copy: ! 1222: ! 1223: ;-----------------------------------------------------------------------; ! 1224: ; Set EBX to point to multiplexed DIB byte->planar byte conversion table ! 1225: ; for plane 0. ! 1226: ; ! 1227: ; Input: ECX with bits sets as described for ulCopyControlFlags, above ! 1228: ; ESI = DIB pointer to first two pixels ! 1229: ; EDI = VGA pointer to planar byte ! 1230: ; ulPlane0Scans = # of scan lines to copy to ! 1231: ; ulSrcDelta = offset from end of one source scan copied to start of next ! 1232: ; ulDstDelta = offset from end of one dest scan copied to start of next ! 1233: ; ulWholeDwordCount = # of whole, aligned dwords to copy ! 1234: ; ulLeftMask = mask for partial left edge, if any ! 1235: ; ulRightMask = mask for partial right edge, if any ! 1236: ; Plane 0 must be mapped in for writes ! 1237: ;-----------------------------------------------------------------------; ! 1238: ! 1239: mov ebx,DIB4_to_VGA_plane0_table ;stays set for all bytes/words ! 1240: ! 1241: DIB4_to_VGA_plane0_copy_loop: ! 1242: ! 1243: ;-----------------------------------------------------------------------; ! 1244: ; Code to convert 1-7 DIB4 pixels to a partial VGA plane 0 byte (8 ! 1245: ; pixels in plane 0). Assumes that a full dword of DIB4 pixels (8 ! 1246: ; pixels) is available, starting at ESI, although some of the pixels ! 1247: ; will be masked off. Assumes the DIB4 pixels (including masked-off ! 1248: ; pixels) start in the upper nibble of [ESI], and that the first ! 1249: ; (possibly masked-off) DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 1250: ; ! 1251: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1252: ; (must start on a 256-byte boundary) ! 1253: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1254: ; ESI = DIB pointer to first two pixels (possibly masked off) ! 1255: ; EDI = VGA pointer to planar byte ! 1256: ; Plane 0 must be mapped in for writes ! 1257: ;-----------------------------------------------------------------------; ! 1258: ! 1259: test ecx,LEADING_PARTIAL ;handle a leading partial byte? ! 1260: jz short DIB4_to_VGA_plane0_copy_lbyte ;no, go straight to whole ! 1261: ; byte ! 1262: ;yes, handle leading partial byte ! 1263: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1264: and edx,11111111h ;keep only the plane 0 bits of DIB dword ! 1265: ; EDX = xxx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1 ! 1266: shld eax,edx,16+2 ;put bits 7-4 of DIB dword in AX, ! 1267: ; shifted left 2 (x = zero bit) ! 1268: ; DX = xxx2xxx3xxx0xxx1 ! 1269: ; AX = x6xxx7xxx4xxx5xx ! 1270: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1271: ; x6x2x7x3x4x0x5x1 ! 1272: mov bl,al ;BL = x4x0x5x1 of DIB dword 0 ! 1273: add ah,ah ;make AH 6x2x7x3x of DIB dword 0 (shl 1) ! 1274: or bl,ah ;BL = 64207531 of DIB dword 0 ! 1275: add esi,4 ;point to next DIB dword ! 1276: inc edi ;point to next VGA byte (placed here ! 1277: ; for 486 pipelining reasons) ! 1278: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1279: mov ch,[edi-1] ;get the VGA destination byte ! 1280: and ecx,ulLeftMask ;mask off source and dest ! 1281: or cl,ch ;combine masked source and dest ! 1282: mov [edi-1],cl ;write the new pixels to the VGA ! 1283: ! 1284: ;-----------------------------------------------------------------------; ! 1285: ; Code to convert 8 DIB4 pixels to a single VGA plane 0 byte (8 pixels ! 1286: ; in plane 0). Assumes the DIB4 pixels start in the upper nibble of ! 1287: ; [ESI], and that the first DIB4 pixel maps to bit 7 of the VGA at ! 1288: ; [EDI]. ! 1289: ; ! 1290: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1291: ; (must start on a 256-byte boundary) ! 1292: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1293: ; ESI = DIB pointer to first two pixels ! 1294: ; EDI = VGA pointer to planar byte ! 1295: ; Plane 0 must be mapped in for writes ! 1296: ;-----------------------------------------------------------------------; ! 1297: ! 1298: DIB4_to_VGA_plane0_copy_lbyte: ! 1299: test ecx,LEADING_BYTE ;should we handle a leading byte? ! 1300: jz short DIB4_to_VGA_plane0_copy_words ;no, go straight to words ! 1301: ;yes, handle leading byte ! 1302: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1303: and edx,11111111h ;keep only the plane 0 bits of DIB dword ! 1304: ; EDX = xxx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1 ! 1305: shld eax,edx,16+2 ;put bits 7-4 of DIB dword in AX, ! 1306: ; shifted left 2 (x = zero bit) ! 1307: ; DX = xxx2xxx3xxx0xxx1 ! 1308: ; AX = x6xxx7xxx4xxx5xx ! 1309: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1310: ; x6x2x7x3x4x0x5x1 ! 1311: mov bl,al ;BL = x4x0x5x1 of DIB dword 0 ! 1312: add ah,ah ;make AH 6x2x7x3x of DIB dword 0 (shl 1) ! 1313: or bl,ah ;BL = 64207531 of DIB dword 0 ! 1314: add esi,4 ;point to next DIB dword ! 1315: inc edi ;point to next VGA byte (placed here ! 1316: ; for 486 pipelining reasons) ! 1317: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1318: mov [edi-1],cl ;write 8 bits from DIB dword to VGA ! 1319: ! 1320: ;-----------------------------------------------------------------------; ! 1321: ; Code to convert sets of 32 DIB4 pixels to 4 VGA plane 0 bytes (32 ! 1322: ; pixels in plane 0). Assumes the VGA destination is word aligned. ! 1323: ; Assumes the DIB4 pixels start in the upper nibble of [ESI], and that ! 1324: ; the first DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 1325: ; ! 1326: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1327: ; (must start on a 256-byte boundary) ! 1328: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1329: ; ESI = DIB pointer to first two pixels ! 1330: ; EDI = VGA pointer to two planar bytes (must be word aligned) ! 1331: ; ulWholeDwordCount = # of VGA dwords to convert ! 1332: ; Plane 0 must be mapped in for writes ! 1333: ; ! 1334: ; Note: on entry at DIB4_to_VGA_plane0_word_odd, ESI must point to the ! 1335: ; desired source start minus 8, and EAX must be loaded as if the following ! 1336: ; instructions had been performed: ! 1337: ; mov edx,[esi+8] ! 1338: ; and edx,11111111h ! 1339: ; shld eax,edx,16+2 ! 1340: ; or eax,edx ! 1341: ; ! 1342: ; Note: the code is so odd because of 486 pipeline optimization. ! 1343: ; DO NOT CHANGE THIS CODE UNLESS YOU KNOW EXACTLY WHAT YOU'RE DOING!!! ! 1344: ; ! 1345: ; Note: all 486 pipeline penalties are eliminated except for SHLD, which ! 1346: ; is losing 4 cycles total, and writing CX to memory (2 cycles), so far ! 1347: ; as I know. ! 1348: ;-----------------------------------------------------------------------; ! 1349: ! 1350: DIB4_to_VGA_plane0_copy_words: ! 1351: test ecx,ODD_WHOLE_WORD or WHOLE_WORDS ;any whole words to copy? ! 1352: jz DIB4_to_VGA_plane0_copy_tbyte ;no, check for trailing whole ! 1353: ; bytes ! 1354: ;yes, copy the whole words ! 1355: push ebp ;preserve stack frame pointer ! 1356: mov ebp,ulWholeDwordCount ;# of VGA dwords to copy to ! 1357: ;even # of DIB dwords to copy? (flags still ! 1358: ; set from TEST) ! 1359: .errnz ODD_WHOLE_WORD - 80000000h ! 1360: jns short DIB4_to_VGA_plane0_word_loop ;yes, start copying ! 1361: ;no, there's an odd word; prepare to enter loop ! 1362: ; in middle ! 1363: mov edx,[esi] ;get 8 pixels to convert of first DIB dword ! 1364: and edx,11111111h ;keep only the plane 0 bits of DIB dword ! 1365: ; EDX = xxx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1 ! 1366: shld eax,edx,16+2 ;put bits 7-4 of DIB dword in AX, ! 1367: ; shifted left 2 ! 1368: ; DX = xxx2xxx3xxx0xxx1 ! 1369: ; AX = x6xxx7xxx4xxx5xx ! 1370: or eax,edx ;put bits 7-0 of DIB dword in AX: ! 1371: sub esi,8 ;compensate source back for entering in middle ! 1372: sub edi,2 ;compensate dest back for entering in middle ! 1373: ! 1374: jmp short DIB4_to_VGA_plane0_word_odd ! 1375: ! 1376: ;-----------------------------------------------------------------------; ! 1377: ; Loop to copy a word at a time to VGA plane 0 (actually, unrolled once ! 1378: ; so copies dwords). ! 1379: ;-----------------------------------------------------------------------; ! 1380: ! 1381: align 16 ! 1382: DIB4_to_VGA_plane0_word_loop: ! 1383: mov edx,[esi] ;get 8 pixels to convert of DIB dword 0 ! 1384: and edx,11111111h ;keep only the plane 0 bits of DIB ! 1385: ; dword 0 ! 1386: ; EDX = xxx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1 ! 1387: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 0 in AX, ! 1388: ; shifted left 2 (x = zero bit) ! 1389: ; DX = xxx2xxx3xxx0xxx1 ! 1390: ; AX = x6xxx7xxx4xxx5xx ! 1391: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1392: ; x6x2x7x3x4x0x5x1 ! 1393: mov edx,[esi+4] ;get 8 pixels to convert of DIB dword 1 ! 1394: mov bl,al ;BL = x4x0x5x1 of DIB dword 0 ! 1395: add ah,ah ;make AH 6x2x7x3x of DIB dword 0 (shl 1) ! 1396: or bl,ah ;BL = 64207531 of DIB dword 0 ! 1397: and edx,11111111h ;keep only the plane 0 bits of DIB ! 1398: ; dword 1 ! 1399: ; EDX = xxx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1 ! 1400: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 1 in AX, ! 1401: ; shifted left 2 ! 1402: ; DX = xxx2xxx3xxx0xxx1 ! 1403: ; AX = x6xxx7xxx4xxx5xx ! 1404: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1405: or eax,edx ;put bits 7-0 of DIB dword 1 in AX: ! 1406: ; x6x2x7x3x4x0x5x1 ! 1407: mov bl,al ;BL = x4x0x5x1 of DIB dword 1 ! 1408: mov edx,[esi+8] ;get 8 pixels to convert of DIB dword 2 ! 1409: add ah,ah ;make AH 6x2x7x3x of DIB dword 1 (shl 1) ! 1410: or bl,ah ;BL = 64207531 of DIB dword 1 ! 1411: and edx,11111111h ;keep only the plane 0 bits of DIB ! 1412: ; dword 2 ! 1413: ; EDX = xxx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1 ! 1414: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 2 in AX, ! 1415: ; shifted left 2 ! 1416: ; DX = xxx2xxx3xxx0xxx1 ! 1417: ; AX = x6xxx7xxx4xxx5xx ! 1418: mov ch,[ebx] ;CH = 76543210 of DIB dword 1 ! 1419: or eax,edx ;put bits 7-0 of DIB dword 2 in AX: ! 1420: ; x6x2x7x3x4x0x5x1 ! 1421: mov [edi],cx ;write 16 bits from DIB dwords 0 and 1 ! 1422: ; to VGA ! 1423: DIB4_to_VGA_plane0_word_odd: ! 1424: mov edx,[esi+12] ;get 8 pixels to convert of DIB dword 3 ! 1425: mov bl,al ;BL = x4x0x5x1 of DIB dword 2 ! 1426: add ah,ah ;make AH 6x2x7x3x of DIB dword 2 (shl 1) ! 1427: or bl,ah ;BL = 64207531 of DIB dword 2 ! 1428: and edx,11111111h ;keep only the plane 0 bits of DIB ! 1429: ; dword 3 ! 1430: ; EDX = xxx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1 ! 1431: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 3 in AX, ! 1432: ; shifted left 2 ! 1433: ; DX = xxx2xxx3xxx0xxx1 ! 1434: ; AX = x6xxx7xxx4xxx5xx ! 1435: mov cl,[ebx] ;CL = 76543210 of DIB dword 2 ! 1436: or eax,edx ;put bits 7-0 of DIB dword 3 in AX: ! 1437: ; x6x2x7x3x4x0x5x1 ! 1438: mov bl,al ;BL = x4x0x5x1 of DIB dword 3 ! 1439: add ah,ah ;make AH 6x2x7x3x of DIB dword 3 (shl 1) ! 1440: or bl,ah ;BL = 64207531 of DIB dword 3 ! 1441: add esi,16 ;point to next set of 4 DIB dwords ! 1442: add edi,4 ;point to next VGA dword ! 1443: mov ch,[ebx] ;CH = 76543210 of dword 0 ! 1444: dec ebp ;count down VGA dwords ! 1445: mov [edi-2],cx ;write 16 bits from DIB dwords 2 and 3 ! 1446: ; to VGA ! 1447: jnz DIB4_to_VGA_plane0_word_loop ;do next VGA dword, if any ! 1448: ! 1449: pop ebp ;restore stack frame pointer ! 1450: ! 1451: ! 1452: ;-----------------------------------------------------------------------; ! 1453: ; Code to convert 8 DIB4 pixels to a single VGA plane 0 byte (8 pixels ! 1454: ; in plane 0). Assumes the DIB4 pixels start in the upper nibble of ! 1455: ; [ESI], and that the first DIB4 pixel maps to bit 7 of the VGA at ! 1456: ; [EDI]. ! 1457: ; ! 1458: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1459: ; (must start on a 256-byte boundary) ! 1460: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1461: ; ESI = DIB pointer to first two pixels ! 1462: ; EDI = VGA pointer to planar byte ! 1463: ; Plane 0 must be mapped in for writes ! 1464: ; ! 1465: ;-----------------------------------------------------------------------; ! 1466: ! 1467: DIB4_to_VGA_plane0_copy_tbyte: ! 1468: test ecx,TRAILING_BYTE ;should we handle a trailing byte? ! 1469: jz short DIB4_to_VGA_plane0_copy_tpart ;no, check for trailing ! 1470: ; partial ! 1471: ;yes, handle trailing byte ! 1472: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1473: and edx,11111111h ;keep only the plane 0 bits of DIB dword ! 1474: ; EDX = xxx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1 ! 1475: shld eax,edx,16+2 ;put bits 7-4 of DIB dword in AX, ! 1476: ; shifted left 2 (x = zero bit) ! 1477: ; DX = xxx2xxx3xxx0xxx1 ! 1478: ; AX = x6xxx7xxx4xxx5xx ! 1479: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1480: ; x6x2x7x3x4x0x5x1 ! 1481: mov bl,al ;BL = x4x0x5x1 of DIB dword 0 ! 1482: add ah,ah ;make AH 6x2x7x3x of DIB dword 0 (shl 1) ! 1483: or bl,ah ;BL = 64207531 of DIB dword 0 ! 1484: add esi,4 ;point to next DIB dword ! 1485: inc edi ;point to next VGA byte (placed here ! 1486: ; for 486 pipelining reasons) ! 1487: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1488: mov [edi-1],cl ;write 8 bits from DIB dword to VGA ! 1489: ! 1490: ;-----------------------------------------------------------------------; ! 1491: ; Code to convert 1-7 DIB4 pixels to a partial VGA plane 0 byte (8 ! 1492: ; pixels in plane 0). Assumes that a full dword of DIB4 pixels (8 ! 1493: ; pixels) is available, starting at ESI, although some of the pixels ! 1494: ; will be masked off. Assumes the DIB4 pixels (including masked-off ! 1495: ; pixels) start in the upper nibble of [ESI], and that the first ! 1496: ; (possibly masked-off) DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 1497: ; ! 1498: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1499: ; (must start on a 256-byte boundary) ! 1500: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1501: ; ESI = DIB pointer to first two pixels (possibly masked off) ! 1502: ; EDI = VGA pointer to planar byte ! 1503: ; Plane 0 must be mapped in for writes ! 1504: ;-----------------------------------------------------------------------; ! 1505: ! 1506: DIB4_to_VGA_plane0_copy_tpart: ! 1507: test ecx,TRAILING_PARTIAL ;handle a trailing partial byte? ! 1508: jz short DIB4_to_VGA_plane0_copy_done ;no, done ! 1509: ;yes, handle trailing partial byte ! 1510: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1511: and edx,11111111h ;keep only the plane 0 bits of DIB dword ! 1512: ; EDX = xxx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1 ! 1513: shld eax,edx,16+2 ;put bits 7-4 of DIB dword in AX, ! 1514: ; shifted left 2 (x = zero bit) ! 1515: ; DX = xxx2xxx3xxx0xxx1 ! 1516: ; AX = x6xxx7xxx4xxx5xx ! 1517: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1518: ; x6x2x7x3x4x0x5x1 ! 1519: mov bl,al ;BL = x4x0x5x1 of DIB dword 0 ! 1520: add ah,ah ;make AH 6x2x7x3x of DIB dword 0 (shl 1) ! 1521: or bl,ah ;BL = 64207531 of DIB dword 0 ! 1522: add esi,4 ;point to next DIB dword ! 1523: inc edi ;point to next VGA byte (placed here ! 1524: ; for 486 pipelining reasons) ! 1525: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1526: mov ch,[edi-1] ;get the VGA destination byte ! 1527: and ecx,ulRightMask ;mask off source and dest ! 1528: or cl,ch ;combine masked source and dest ! 1529: mov [edi-1],cl ;write the new pixels to the VGA ! 1530: ! 1531: DIB4_to_VGA_plane0_copy_done: ! 1532: add esi,ulSrcDelta ;point to start of next DIB scan ! 1533: add edi,ulDstDelta ;point to start of next VGA scan ! 1534: dec ulPlane0Scans ;count down scans in this plane ! 1535: jnz DIB4_to_VGA_plane0_copy_loop ;do next scan in this plane, if any ! 1536: ! 1537: jmp copy_burst_plane0_done ;return to the top of the plane-copy ! 1538: ; loop ! 1539: ! 1540: ;-----------------------------------------------------------------------; ! 1541: ; Plane 1 DIB->VGA conversion code for a single scan line. ! 1542: ; ! 1543: ; Input: ECX with bits sets as described for ulCopyControlFlags, above ! 1544: ; bit 30 = 1 if there are whole words to be copied, = 0 if not ! 1545: ; bit 29 = 1 if leading byte should be copied, = 0 if not ! 1546: ; bit 28 = 1 if trailing byte should be copied, = 0 if not ! 1547: ; bit 27 = 1 if partial leading byte should be copied, = 0 if not ! 1548: ; bit 26 = 1 if partial trailing byte should be copied, = 0 if not ! 1549: ; ESI = DIB pointer to first two pixels ! 1550: ; EDI = VGA pointer to planar byte ! 1551: ; ulPlane1Scans = # of scan lines to copy to ! 1552: ; ulSrcDelta = offset from end of one source scan copied to start of next ! 1553: ; ulDstDelta = offset from end of one dest scan copied to start of next ! 1554: ; ulWholeDwordCount = # of whole, aligned dwords to copy ! 1555: ; ulLeftMask = mask for partial left edge, if any ! 1556: ; ulRightMask = mask for partial right edge, if any ! 1557: ; Plane 1 must be mapped in for writes ! 1558: ;-----------------------------------------------------------------------; ! 1559: align 4 ! 1560: DIB4_to_VGA_plane1_copy: ! 1561: ! 1562: ;-----------------------------------------------------------------------; ! 1563: ; Set EBX to point to multiplexed DIB byte->planar byte conversion table ! 1564: ; for plane 1. ! 1565: ;-----------------------------------------------------------------------; ! 1566: ! 1567: mov ebx,DIB4_to_VGA_plane1_table ;stays set for all bytes/words ! 1568: ! 1569: DIB4_to_VGA_plane1_copy_loop: ! 1570: ! 1571: ;-----------------------------------------------------------------------; ! 1572: ; Code to convert 1-7 DIB4 pixels to a partial VGA plane 1 byte (8 ! 1573: ; pixels in plane 1). Assumes that a full dword of DIB4 pixels (8 ! 1574: ; pixels) is available, starting at ESI, although some of the pixels ! 1575: ; will be masked off. Assumes the DIB4 pixels (including masked-off ! 1576: ; pixels) start in the upper nibble of [ESI], and that the first ! 1577: ; (possibly masked-off) DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 1578: ; ! 1579: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1580: ; (must start on a 256-byte boundary) ! 1581: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1582: ; ESI = DIB pointer to first two pixels (possibly masked off) ! 1583: ; EDI = VGA pointer to planar byte ! 1584: ; plane 1 must be mapped in for writes ! 1585: ;-----------------------------------------------------------------------; ! 1586: ! 1587: test ecx,LEADING_PARTIAL ;handle a leading partial byte? ! 1588: jz short DIB4_to_VGA_plane1_copy_lbyte ;no, go straight to whole ! 1589: ; byte ! 1590: ;yes, handle leading partial byte ! 1591: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1592: and edx,22222222h ;keep only the plane 1 bits of DIB ! 1593: ; dword 0 ! 1594: ; EDX = xx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1x ! 1595: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 0 in AX, ! 1596: ; shifted left 2 (x = zero bit) ! 1597: ; DX = xx2xxx3xxx0xxx1x ! 1598: ; AX = 6xxx7xxx4xxx5xxx ! 1599: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1600: ; 6x2x7x3x4x0x5x1x ! 1601: mov bl,al ;BL = 4x0x5x1x of DIB dword 0 ! 1602: rol ah,7 ;make AH x6x2x7x3 of DIB dword 0 (shr 1) ! 1603: or bl,ah ;BL = 46025713 of DIB dword 0 ! 1604: add esi,4 ;point to next DIB dword ! 1605: inc edi ;point to next VGA byte (placed here ! 1606: ; for 486 pipelining reasons) ! 1607: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1608: mov ch,[edi-1] ;get the VGA destination byte ! 1609: and ecx,ulLeftMask ;mask off source and dest ! 1610: or cl,ch ;combine masked source and dest ! 1611: mov [edi-1],cl ;write the new pixels to the VGA ! 1612: ! 1613: ;-----------------------------------------------------------------------; ! 1614: ; Code to convert 8 DIB4 pixels to a single VGA plane 1 byte (8 pixels ! 1615: ; in plane 1). Assumes the DIB4 pixels start in the upper nibble of ! 1616: ; [ESI], and that the first DIB4 pixel maps to bit 7 of the VGA at ! 1617: ; [EDI]. ! 1618: ; ! 1619: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1620: ; (must start on a 256-byte boundary) ! 1621: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1622: ; ESI = DIB pointer to first two pixels ! 1623: ; EDI = VGA pointer to planar byte ! 1624: ; plane 1 must be mapped in for writes ! 1625: ;-----------------------------------------------------------------------; ! 1626: ! 1627: DIB4_to_VGA_plane1_copy_lbyte: ! 1628: test ecx,LEADING_BYTE ;should we handle a leading byte? ! 1629: jz short DIB4_to_VGA_plane1_copy_words ;no, go straight to words ! 1630: ;yes, handle leading byte ! 1631: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1632: and edx,22222222h ;keep only the plane 1 bits of DIB ! 1633: ; dword 0 ! 1634: ; EDX = xx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1x ! 1635: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 0 in AX, ! 1636: ; shifted left 2 (x = zero bit) ! 1637: ; DX = xx2xxx3xxx0xxx1x ! 1638: ; AX = 6xxx7xxx4xxx5xxx ! 1639: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1640: ; 6x2x7x3x4x0x5x1x ! 1641: mov bl,al ;BL = 4x0x5x1x of DIB dword 0 ! 1642: rol ah,7 ;make AH x6x2x7x3 of DIB dword 0 (shr 1) ! 1643: or bl,ah ;BL = 46025713 of DIB dword 0 ! 1644: add esi,4 ;point to next DIB dword ! 1645: inc edi ;point to next VGA byte (placed here ! 1646: ; for 486 pipelining reasons) ! 1647: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1648: mov [edi-1],cl ;write 8 bits from DIB dword to VGA ! 1649: ! 1650: ;-----------------------------------------------------------------------; ! 1651: ; Code for converting sets of 32 DIB4 pixels to 4 VGA plane 1 bytes (32 ! 1652: ; pixels in plane 1). Assumes the VGA destination is word aligned. ! 1653: ; Assumes the DIB4 pixels start in the upper nibble of [ESI], and that ! 1654: ; the first DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 1655: ; ! 1656: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1657: ; (must start on a 256-byte boundary) ! 1658: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1659: ; ESI = DIB pointer to first two pixels ! 1660: ; EDI = VGA pointer to two planar bytes (must be word aligned) ! 1661: ; EBP = # of VGA dwords to convert ! 1662: ; ulWholeDwordCount = # of VGA dwords to convert ! 1663: ; Plane 1 must be mapped in for writes ! 1664: ; ! 1665: ; Note: on entry at DIB4_to_VGA_plane1_word_odd, ESI must point to the ! 1666: ; desired source start minus 8, and EAX must be loaded as if the following ! 1667: ; instructions had been performed: ! 1668: ; mov edx,[esi+8] ! 1669: ; and edx,22222222h ! 1670: ; shld eax,edx,16+2 ! 1671: ; or eax,edx ! 1672: ; ! 1673: ; Note: ROL AH,7 is used instead of SHR AH,1 because the shift-by-1 ! 1674: ; form is 1 cycle slower on a 486, and in this case the two forms are ! 1675: ; functionally identical. ! 1676: ; ! 1677: ; Note: the code is so odd because of 486 pipeline optimization. ! 1678: ; DO NOT CHANGE THIS CODE UNLESS YOU KNOW EXACTLY WHAT YOU'RE DOING!!! ! 1679: ; ! 1680: ; Note: all 486 pipeline penalties are eliminated except for SHLD, which ! 1681: ; is losing 4 cycles total, and writing CX to memory (2 cycles), so far ! 1682: ; as I know. ! 1683: ;-----------------------------------------------------------------------; ! 1684: ! 1685: DIB4_to_VGA_plane1_copy_words: ! 1686: test ecx,ODD_WHOLE_WORD or WHOLE_WORDS ;any whole words to copy? ! 1687: jz DIB4_to_VGA_plane1_copy_tbyte ;no, check for trailing whole ! 1688: ; bytes ! 1689: ;yes, copy the whole words ! 1690: push ebp ;preserve stack frame pointer ! 1691: mov ebp,ulWholeDwordCount ;# of VGA dwords to copy to ! 1692: ;even # of DIB dwords to copy? (flags still ! 1693: ; set from TEST) ! 1694: .errnz ODD_WHOLE_WORD - 80000000h ! 1695: jns short DIB4_to_VGA_plane1_word_loop ;yes, start copying ! 1696: ;no, there's an odd word; prepare to enter loop ! 1697: ; in middle ! 1698: mov edx,[esi] ;get 8 pixels to convert of first DIB dword ! 1699: and edx,22222222h ;keep only the plane 1 bits of DIB dword ! 1700: ; EDX = xx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1x ! 1701: shld eax,edx,16+2 ;put bits 7-4 of DIB dword in AX, ! 1702: ; shifted left 2 ! 1703: ; DX = xx2xxx3xxx0xxx1x ! 1704: ; AX = 6xxx7xxx4xxx5xxx ! 1705: or eax,edx ;put bits 7-0 of DIB dword in AX: ! 1706: ; 6x2x7x3x4x0x5x1x ! 1707: sub esi,8 ;compensate source back for entering in middle ! 1708: sub edi,2 ;compensate dest back for entering in middle ! 1709: ! 1710: jmp short DIB4_to_VGA_plane1_word_odd ! 1711: ! 1712: ;-----------------------------------------------------------------------; ! 1713: ; Loop to copy a word at a time to VGA plane 1 (actually, unrolled once ! 1714: ; so copies dwords). ! 1715: ;-----------------------------------------------------------------------; ! 1716: ! 1717: align 16 ! 1718: DIB4_to_VGA_plane1_word_loop: ! 1719: mov edx,[esi] ;get 8 pixels to convert of DIB dword 0 ! 1720: and edx,22222222h ;keep only the plane 1 bits of DIB ! 1721: ; dword 0 ! 1722: ; EDX = xx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1x ! 1723: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 0 in AX, ! 1724: ; shifted left 2 (x = zero bit) ! 1725: ; DX = xx2xxx3xxx0xxx1x ! 1726: ; AX = 6xxx7xxx4xxx5xxx ! 1727: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1728: ; 6x2x7x3x4x0x5x1x ! 1729: mov edx,[esi+4] ;get 8 pixels to convert of DIB dword 1 ! 1730: mov bl,al ;BL = 4x0x5x1x of DIB dword 0 ! 1731: rol ah,7 ;make AH x6x2x7x3 of DIB dword 0 (shr 1) ! 1732: or bl,ah ;BL = 46025713 of DIB dword 0 ! 1733: and edx,22222222h ;keep only the plane 1 bits of DIB ! 1734: ; dword 1 ! 1735: ; EDX = xx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1x ! 1736: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 1 in AX, ! 1737: ; shifted left 2 ! 1738: ; DX = xx2xxx3xxx0xxx1x ! 1739: ; AX = 6xxx7xxx4xxx5xxx ! 1740: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1741: or eax,edx ;put bits 7-0 of DIB dword 1 in AX: ! 1742: ; 6x2x7x3x4x0x5x1x ! 1743: mov bl,al ;BL = 4x0x5x1x of DIB dword 1 ! 1744: mov edx,[esi+8] ;get 8 pixels to convert of DIB dword 2 ! 1745: rol ah,7 ;make AH x6x2x7x3 of DIB dword 1 (shr 1) ! 1746: or bl,ah ;BL = 46025713 of DIB dword 1 ! 1747: and edx,22222222h ;keep only the plane 1 bits of DIB ! 1748: ; dword 2 ! 1749: ; EDX = xx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1x ! 1750: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 2 in AX, ! 1751: ; shifted left 2 ! 1752: ; DX = xx2xxx3xxx0xxx1x ! 1753: ; AX = 6xxx7xxx4xxx5xxx ! 1754: mov ch,[ebx] ;CH = 76543210 of DIB dword 1 ! 1755: or eax,edx ;put bits 7-0 of DIB dword 2 in AX: ! 1756: ; 6x2x7x3x4x0x5x1x ! 1757: mov [edi],cx ;write 16 bits from DIB dwords 0 and 1 ! 1758: ; to VGA ! 1759: DIB4_to_VGA_plane1_word_odd: ! 1760: mov edx,[esi+12] ;get 8 pixels to convert of DIB dword 3 ! 1761: mov bl,al ;BL = 4x0x5x1x of DIB dword 2 ! 1762: rol ah,7 ;make AH x6x2x7x3 of DIB dword 2 (shr 1) ! 1763: or bl,ah ;BL = 46025713 of DIB dword 2 ! 1764: and edx,22222222h ;keep only the plane 1 bits of DIB ! 1765: ; dword 3 ! 1766: ; EDX = xx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1x ! 1767: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 3 in AX, ! 1768: ; shifted left 2 ! 1769: ; DX = xx2xxx3xxx0xxx1x ! 1770: ; AX = 6xxx7xxx4xxx5xxx ! 1771: mov cl,[ebx] ;CL = 76543210 of DIB dword 2 ! 1772: or eax,edx ;put bits 7-0 of DIB dword 3 in AX: ! 1773: ; 6x2x7x3x4x0x5x1x ! 1774: mov bl,al ;BL = 4x0x5x1x of DIB dword 3 ! 1775: rol ah,7 ;make AH x6x2x7x3 of DIB dword 3 (shr 1) ! 1776: or bl,ah ;BL = 46025713 of DIB dword 3 ! 1777: add esi,16 ;point to next set of 4 DIB dwords ! 1778: add edi,4 ;point to next VGA dword ! 1779: mov ch,[ebx] ;CH = 76543210 of dword 0 ! 1780: dec ebp ;count down VGA dwords ! 1781: mov [edi-2],cx ;write 16 bits from DIB dwords 2 and 3 ! 1782: ; to VGA ! 1783: jnz DIB4_to_VGA_plane1_word_loop ;do next VGA dword, if any ! 1784: ! 1785: pop ebp ;restore stack frame pointer ! 1786: ! 1787: ;-----------------------------------------------------------------------; ! 1788: ; Code to convert 8 DIB4 pixels to a single VGA plane 1 byte (8 pixels ! 1789: ; in plane 1). Assumes the DIB4 pixels start in the upper nibble of ! 1790: ; [ESI], and that the first DIB4 pixel maps to bit 7 of the VGA at ! 1791: ; [EDI]. ! 1792: ; ! 1793: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1794: ; (must start on a 256-byte boundary) ! 1795: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1796: ; ESI = DIB pointer to first two pixels ! 1797: ; EDI = VGA pointer to planar byte ! 1798: ; Plane 1 must be mapped in for writes ! 1799: ; ! 1800: ;-----------------------------------------------------------------------; ! 1801: ! 1802: DIB4_to_VGA_plane1_copy_tbyte: ! 1803: test ecx,TRAILING_BYTE ;should we handle a trailing byte? ! 1804: jz short DIB4_to_VGA_plane1_copy_tpart ;no, check for trailing ! 1805: ; partial ! 1806: ;yes, handle trailing byte ! 1807: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1808: and edx,22222222h ;keep only the plane 1 bits of DIB ! 1809: ; dword 0 ! 1810: ; EDX = xx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1x ! 1811: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 0 in AX, ! 1812: ; shifted left 2 (x = zero bit) ! 1813: ; DX = xx2xxx3xxx0xxx1x ! 1814: ; AX = 6xxx7xxx4xxx5xxx ! 1815: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1816: ; 6x2x7x3x4x0x5x1x ! 1817: mov bl,al ;BL = 4x0x5x1x of DIB dword 0 ! 1818: rol ah,7 ;make AH x6x2x7x3 of DIB dword 0 (shr 1) ! 1819: or bl,ah ;BL = 46025713 of DIB dword 0 ! 1820: add esi,4 ;point to next DIB dword ! 1821: inc edi ;point to next VGA byte (placed here ! 1822: ; for 486 pipelining reasons) ! 1823: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1824: mov [edi-1],cl ;write 8 bits from DIB dword to VGA ! 1825: ! 1826: ;-----------------------------------------------------------------------; ! 1827: ; Code to convert 1-7 DIB4 pixels to a partial VGA plane 1 byte (8 ! 1828: ; pixels in plane 1). Assumes that a full dword of DIB4 pixels (8 ! 1829: ; pixels) is available, starting at ESI, although some of the pixels ! 1830: ; will be masked off. Assumes the DIB4 pixels (including masked-off ! 1831: ; pixels) start in the upper nibble of [ESI], and that the first ! 1832: ; (possibly masked-off) DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 1833: ; ! 1834: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1835: ; (must start on a 256-byte boundary) ! 1836: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1837: ; ESI = DIB pointer to first two pixels (possibly masked off) ! 1838: ; EDI = VGA pointer to planar byte ! 1839: ; plane 1 must be mapped in for writes ! 1840: ;-----------------------------------------------------------------------; ! 1841: ! 1842: DIB4_to_VGA_plane1_copy_tpart: ! 1843: test ecx,TRAILING_PARTIAL ;handle a trailing partial byte? ! 1844: jz short DIB4_to_VGA_plane1_copy_done ;no, done ! 1845: ;yes, handle trailing partial byte ! 1846: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1847: and edx,22222222h ;keep only the plane 1 bits of DIB ! 1848: ; dword 0 ! 1849: ; EDX = xx6xxx7xxx4xxx5xxx2xxx3xxx0xxx1x ! 1850: shld eax,edx,16+2 ;put bits 7-4 of DIB dword 0 in AX, ! 1851: ; shifted left 2 (x = zero bit) ! 1852: ; DX = xx2xxx3xxx0xxx1x ! 1853: ; AX = 6xxx7xxx4xxx5xxx ! 1854: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1855: ; 6x2x7x3x4x0x5x1x ! 1856: mov bl,al ;BL = 4x0x5x1x of DIB dword 0 ! 1857: rol ah,7 ;make AH x6x2x7x3 of DIB dword 0 (shr 1) ! 1858: or bl,ah ;BL = 46025713 of DIB dword 0 ! 1859: add esi,4 ;point to next DIB dword ! 1860: inc edi ;point to next VGA byte (placed here ! 1861: ; for 486 pipelining reasons) ! 1862: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1863: mov ch,[edi-1] ;get the VGA destination byte ! 1864: and ecx,ulRightMask ;mask off source and dest ! 1865: or cl,ch ;combine masked source and dest ! 1866: mov [edi-1],cl ;write the new pixels to the VGA ! 1867: ! 1868: DIB4_to_VGA_plane1_copy_done: ! 1869: add esi,ulSrcDelta ;point to start of next DIB scan ! 1870: add edi,ulDstDelta ;point to start of next VGA scan ! 1871: dec ulPlane1Scans ;count down scans in this plane ! 1872: jnz DIB4_to_VGA_plane1_copy_loop ;do next scan in this plane, if any ! 1873: ! 1874: jmp copy_burst_plane1_done ;return to the top of the plane-copy ! 1875: ; loop ! 1876: ! 1877: ;-----------------------------------------------------------------------; ! 1878: ; Plane 2 DIB->VGA conversion code for a single scan line. ! 1879: ; ! 1880: ; Input: ECX with bits sets as described for ulCopyControlFlags, above ! 1881: ; bit 30 = 1 if there are whole words to be copied, = 0 if not ! 1882: ; bit 29 = 1 if leading byte should be copied, = 0 if not ! 1883: ; bit 28 = 1 if trailing byte should be copied, = 0 if not ! 1884: ; bit 27 = 1 if partial leading byte should be copied, = 0 if not ! 1885: ; bit 26 = 1 if partial trailing byte should be copied, = 0 if not ! 1886: ; ESI = DIB pointer to first two pixels ! 1887: ; EDI = VGA pointer to planar byte ! 1888: ; ulPlane2Scans = # of scan lines to copy to ! 1889: ; ulSrcDelta = offset from end of one source scan copied to start of next ! 1890: ; ulDstDelta = offset from end of one dest scan copied to start of next ! 1891: ; ulWholeDwordCount = # of whole, aligned dwords to copy ! 1892: ; ulLeftMask = mask for partial left edge, if any ! 1893: ; ulRightMask = mask for partial right edge, if any ! 1894: ; Plane 2 must be mapped in for writes ! 1895: ;-----------------------------------------------------------------------; ! 1896: align 4 ! 1897: DIB4_to_VGA_plane2_copy: ! 1898: ! 1899: ;-----------------------------------------------------------------------; ! 1900: ; Set EBX to point to multiplexed DIB byte->planar byte conversion table ! 1901: ; for plane 2. ! 1902: ;-----------------------------------------------------------------------; ! 1903: ! 1904: mov ebx,DIB4_to_VGA_plane2_table ;stays set for all bytes/words ! 1905: ! 1906: DIB4_to_VGA_plane2_copy_loop: ! 1907: ! 1908: ;-----------------------------------------------------------------------; ! 1909: ; Code to convert 1-7 DIB4 pixels to a partial VGA plane 2 byte (8 ! 1910: ; pixels in plane 2). Assumes that a full dword of DIB4 pixels (8 ! 1911: ; pixels) is available, starting at ESI, although some of the pixels ! 1912: ; will be masked off. Assumes the DIB4 pixels (including masked-off ! 1913: ; pixels) start in the upper nibble of [ESI], and that the first ! 1914: ; (possibly masked-off) DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 1915: ; ! 1916: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1917: ; (must start on a 256-byte boundary) ! 1918: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1919: ; ESI = DIB pointer to first two pixels (possibly masked off) ! 1920: ; EDI = VGA pointer to planar byte ! 1921: ; plane 2 must be mapped in for writes ! 1922: ;-----------------------------------------------------------------------; ! 1923: ! 1924: test ecx,LEADING_PARTIAL ;handle a leading partial byte? ! 1925: jz short DIB4_to_VGA_plane2_copy_lbyte ;no, go straight to whole ! 1926: ; byte ! 1927: ;yes, handle leading partial byte ! 1928: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1929: and edx,44444444h ;keep only the plane 2 bits of DIB ! 1930: ; dword 0 ! 1931: ; EDX = x6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xx ! 1932: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 1933: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 1934: ; DX = x2xxx3xxx0xxx1xx ! 1935: ; AX = xxx6xxx7xxx4xxx5 ! 1936: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1937: ; x2x6x3x7x0x4x1x5 ! 1938: mov bl,al ;BL = x0x4x1x5 of DIB dword 0 ! 1939: add ah,ah ;make AH 2x6x3x7x of DIB dword 0 (shl 1) ! 1940: or bl,ah ;BL = 20643175 of DIB dword 0 ! 1941: add esi,4 ;point to next DIB dword ! 1942: inc edi ;point to next VGA byte (placed here ! 1943: ; for 486 pipelining reasons) ! 1944: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1945: mov ch,[edi-1] ;get the VGA destination byte ! 1946: and ecx,ulLeftMask ;mask off source and dest ! 1947: or cl,ch ;combine masked source and dest ! 1948: mov [edi-1],cl ;write the new pixels to the VGA ! 1949: ! 1950: ;-----------------------------------------------------------------------; ! 1951: ; Code to convert 8 DIB4 pixels to a single VGA plane 2 byte (8 pixels ! 1952: ; in plane 2). Assumes the DIB4 pixels start in the upper nibble of ! 1953: ; [ESI], and that the first DIB4 pixel maps to bit 7 of the VGA at ! 1954: ; [EDI]. ! 1955: ; ! 1956: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1957: ; (must start on a 256-byte boundary) ! 1958: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1959: ; ESI = DIB pointer to first two pixels ! 1960: ; EDI = VGA pointer to planar byte ! 1961: ; plane 2 must be mapped in for writes ! 1962: ;-----------------------------------------------------------------------; ! 1963: ! 1964: DIB4_to_VGA_plane2_copy_lbyte: ! 1965: test ecx,LEADING_BYTE ;should we handle a leading byte? ! 1966: jz short DIB4_to_VGA_plane2_copy_words ;no, go straight to words ! 1967: ;yes, handle leading byte ! 1968: mov edx,[esi] ;get 8 pixels to convert of DIB ! 1969: and edx,44444444h ;keep only the plane 2 bits of DIB ! 1970: ; dword 0 ! 1971: ; EDX = x6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xx ! 1972: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 1973: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 1974: ; DX = x2xxx3xxx0xxx1xx ! 1975: ; AX = xxx6xxx7xxx4xxx5 ! 1976: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 1977: ; x2x6x3x7x0x4x1x5 ! 1978: mov bl,al ;BL = x0x4x1x5 of DIB dword 0 ! 1979: add ah,ah ;make AH 2x6x3x7x of DIB dword 0 (shl 1) ! 1980: or bl,ah ;BL = 20643175 of DIB dword 0 ! 1981: add esi,4 ;point to next DIB dword ! 1982: inc edi ;point to next VGA byte (placed here ! 1983: ; for 486 pipelining reasons) ! 1984: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 1985: mov [edi-1],cl ;write 8 bits from DIB dword to VGA ! 1986: ! 1987: ;-----------------------------------------------------------------------; ! 1988: ; Code for converting sets of 32 DIB4 pixels to 4 VGA plane 2 bytes (32 ! 1989: ; pixels in plane 2). Assumes the VGA destination is word aligned. ! 1990: ; Assumes the DIB4 pixels start in the upper nibble of [ESI], and that ! 1991: ; the first DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 1992: ; ! 1993: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 1994: ; (must start on a 256-byte boundary) ! 1995: ; ECX with bits sets as described for ulCopyControlFlags, above ! 1996: ; ESI = DIB pointer to first two pixels ! 1997: ; EDI = VGA pointer to two planar bytes (must be word aligned) ! 1998: ; EBP = # of VGA dwords to convert ! 1999: ; ulWholeDwordCount = # of VGA dwords to convert ! 2000: ; Plane 2 must be mapped in for writes ! 2001: ; ! 2002: ; Note: on entry at DIB4_to_VGA_plane2_word_odd, ESI must point to the ! 2003: ; desired source start minus 8, and EAX must be loaded as if the following ! 2004: ; instructions had been performed: ! 2005: ; mov edx,[esi+8] ! 2006: ; and edx,44444444h ! 2007: ; mov eax,edx ! 2008: ; shr eax,16+2 ! 2009: ; or eax,edx ! 2010: ; ! 2011: ; Note: the code is so odd because of 486 pipeline optimization. ! 2012: ; DO NOT CHANGE THIS CODE UNLESS YOU KNOW EXACTLY WHAT YOU'RE DOING!!! ! 2013: ; ! 2014: ; Note: all 486 pipeline penalties are eliminated except for writing CX ! 2015: ; to memory (2 cycles), so far as I know. ! 2016: ;-----------------------------------------------------------------------; ! 2017: ! 2018: DIB4_to_VGA_plane2_copy_words: ! 2019: test ecx,ODD_WHOLE_WORD or WHOLE_WORDS ;any whole words to copy? ! 2020: jz DIB4_to_VGA_plane2_copy_tbyte ;no, check for trailing whole ! 2021: ; bytes ! 2022: ;yes, copy the whole words ! 2023: push ebp ;preserve stack frame pointer ! 2024: mov ebp,ulWholeDwordCount ;# of VGA dwords to copy to ! 2025: ;even # of DIB dwords to copy? (flags still ! 2026: ; set from TEST) ! 2027: .errnz ODD_WHOLE_WORD - 80000000h ! 2028: jns short DIB4_to_VGA_plane2_word_loop ;yes, start copying ! 2029: ;no, there's an odd word; prepare to enter loop ! 2030: ; in middle ! 2031: mov edx,[esi] ;get 8 pixels to convert of first DIB dword ! 2032: and edx,44444444h ;keep only the plane 2 bits of DIB dword ! 2033: ; EDX = x6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xx ! 2034: mov eax,edx ;put bits 7-4 of DIB dword in AX, ! 2035: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2036: ; DX = x2xxx3xxx0xxx1xx ! 2037: ; AX = xxx6xxx7xxx4xxx5 ! 2038: or eax,edx ;put bits 7-0 of DIB dword in AX: ! 2039: ; 62xx73xx40xx51xx ! 2040: sub esi,8 ;compensate source back for entering in middle ! 2041: sub edi,2 ;compensate dest back for entering in middle ! 2042: ! 2043: jmp short DIB4_to_VGA_plane2_word_odd ! 2044: ! 2045: ;-----------------------------------------------------------------------; ! 2046: ; Loop to copy a word at a time to VGA plane 2 (actually, unrolled once ! 2047: ; so copies dwords). ! 2048: ;-----------------------------------------------------------------------; ! 2049: ! 2050: align 16 ! 2051: DIB4_to_VGA_plane2_word_loop: ! 2052: mov edx,[esi] ;get 8 pixels to convert of DIB dword 0 ! 2053: and edx,44444444h ;keep only the plane 2 bits of DIB ! 2054: ; dword 0 ! 2055: ; EDX = x6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xx ! 2056: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 2057: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2058: ; DX = x2xxx3xxx0xxx1xx ! 2059: ; AX = xxx6xxx7xxx4xxx5 ! 2060: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 2061: ; x2x6x3x7x0x4x1x5 ! 2062: mov edx,[esi+4] ;get 8 pixels to convert of DIB dword 1 ! 2063: mov bl,al ;BL = x0x4x1x5 of DIB dword 0 ! 2064: add ah,ah ;make AH 2x6x3x7x of DIB dword 0 (shl 1) ! 2065: or bl,ah ;BL = 20643175 of DIB dword 0 ! 2066: and edx,44444444h ;keep only the plane 2 bits of DIB ! 2067: ; dword 1 ! 2068: ; EDX = x6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xx ! 2069: mov eax,edx ;put bits 7-4 of DIB dword 1 in AX, ! 2070: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2071: ; DX = x2xxx3xxx0xxx1xx ! 2072: ; AX = xxx6xxx7xxx4xxx5 ! 2073: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 2074: or eax,edx ;put bits 7-0 of DIB dword 1 in AX: ! 2075: ; 62xx73xx40xx51xx ! 2076: mov bl,al ;BL = x0x4x1x5 of DIB dword 1 ! 2077: mov edx,[esi+8] ;get 8 pixels to convert of DIB dword 2 ! 2078: add ah,ah ;make AH 2x6x3x7x of DIB dword 1 (shl 1) ! 2079: or bl,ah ;BL = 20643175 of DIB dword 1 ! 2080: and edx,44444444h ;keep only the plane 2 bits of DIB ! 2081: ; dword 2 ! 2082: ; EDX = x6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xx ! 2083: mov eax,edx ;put bits 7-4 of DIB dword 2 in AX, ! 2084: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2085: ; DX = x2xxx3xxx0xxx1xx ! 2086: ; AX = xxx6xxx7xxx4xxx5 ! 2087: mov ch,[ebx] ;CH = 76543210 of DIB dword 1 ! 2088: or eax,edx ;put bits 7-0 of DIB dword 2 in AX: ! 2089: ; 62xx73xx40xx51xx ! 2090: mov [edi],cx ;write 16 bits from DIB dwords 0 and 1 ! 2091: ; to VGA ! 2092: DIB4_to_VGA_plane2_word_odd: ! 2093: mov edx,[esi+12] ;get 8 pixels to convert of DIB dword 3 ! 2094: mov bl,al ;BL = x0x4x1x5 of DIB dword 2 ! 2095: add ah,ah ;make AH 2x6x3x7x of DIB dword 2 (shl 1) ! 2096: or bl,ah ;BL = 20643175 of DIB dword 2 ! 2097: and edx,44444444h ;keep only the plane 2 bits of DIB ! 2098: ; dword 3 ! 2099: ; EDX = x6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xx ! 2100: mov eax,edx ;put bits 7-4 of DIB dword 3 in AX, ! 2101: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2102: ; DX = x2xxx3xxx0xxx1xx ! 2103: ; AX = xxx6xxx7xxx4xxx5 ! 2104: mov cl,[ebx] ;CL = 76543210 of DIB dword 2 ! 2105: or eax,edx ;put bits 7-0 of DIB dword 3 in AX: ! 2106: ; 62xx73xx40xx51xx ! 2107: mov bl,al ;BL = x0x4x1x5 of DIB dword 3 ! 2108: add ah,ah ;make AH 2x6x3x7x of DIB dword 3 (shl 1) ! 2109: or bl,ah ;BL = 20643175 of DIB dword 3 ! 2110: add esi,16 ;point to next set of 4 DIB dwords ! 2111: add edi,4 ;point to next VGA dword ! 2112: mov ch,[ebx] ;CH = 76543210 of dword 0 ! 2113: dec ebp ;count down VGA dwords ! 2114: mov [edi-2],cx ;write 16 bits from DIB dwords 2 and 3 ! 2115: ; to VGA ! 2116: jnz DIB4_to_VGA_plane2_word_loop ;do next VGA dword, if any ! 2117: ! 2118: pop ebp ;restore stack frame pointer ! 2119: ! 2120: ;-----------------------------------------------------------------------; ! 2121: ; Code to convert 8 DIB4 pixels to a single VGA plane 2 byte (8 pixels ! 2122: ; in plane 2). Assumes the DIB4 pixels start in the upper nibble of ! 2123: ; [ESI], and that the first DIB4 pixel maps to bit 7 of the VGA at ! 2124: ; [EDI]. ! 2125: ; ! 2126: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 2127: ; (must start on a 256-byte boundary) ! 2128: ; ECX with bits sets as described for ulCopyControlFlags, above ! 2129: ; ESI = DIB pointer to first two pixels ! 2130: ; EDI = VGA pointer to planar byte ! 2131: ; plane 2 must be mapped in for writes ! 2132: ; ! 2133: ;-----------------------------------------------------------------------; ! 2134: ! 2135: DIB4_to_VGA_plane2_copy_tbyte: ! 2136: test ecx,TRAILING_BYTE ;should we handle a trailing byte? ! 2137: jz short DIB4_to_VGA_plane2_copy_tpart ;no, check for trailing ! 2138: ; partial ! 2139: ;yes, handle trailing byte ! 2140: mov edx,[esi] ;get 8 pixels to convert of DIB ! 2141: and edx,44444444h ;keep only the plane 2 bits of DIB ! 2142: ; dword 0 ! 2143: ; EDX = x6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xx ! 2144: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 2145: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2146: ; DX = x2xxx3xxx0xxx1xx ! 2147: ; AX = xxx6xxx7xxx4xxx5 ! 2148: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 2149: ; x2x6x3x7x0x4x1x5 ! 2150: mov bl,al ;BL = x0x4x1x5 of DIB dword 0 ! 2151: add ah,ah ;make AH 2x6x3x7x of DIB dword 0 (shl 1) ! 2152: or bl,ah ;BL = 20643175 of DIB dword 0 ! 2153: add esi,4 ;point to next DIB dword ! 2154: inc edi ;point to next VGA byte (placed here ! 2155: ; for 486 pipelining reasons) ! 2156: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 2157: mov [edi-1],cl ;write 8 bits from DIB dword to VGA ! 2158: ! 2159: ;-----------------------------------------------------------------------; ! 2160: ; Code to convert 1-7 DIB4 pixels to a partial VGA plane 2 byte (8 ! 2161: ; pixels in plane 2). Assumes that a full dword of DIB4 pixels (8 ! 2162: ; pixels) is available, starting at ESI, although some of the pixels ! 2163: ; will be masked off. Assumes the DIB4 pixels (including masked-off ! 2164: ; pixels) start in the upper nibble of [ESI], and that the first ! 2165: ; (possibly masked-off) DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 2166: ; ! 2167: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 2168: ; (must start on a 256-byte boundary) ! 2169: ; ECX with bits sets as described for ulCopyControlFlags, above ! 2170: ; ESI = DIB pointer to first two pixels (possibly masked off) ! 2171: ; EDI = VGA pointer to planar byte ! 2172: ; plane 2 must be mapped in for writes ! 2173: ;-----------------------------------------------------------------------; ! 2174: ! 2175: DIB4_to_VGA_plane2_copy_tpart: ! 2176: test ecx,TRAILING_PARTIAL ;handle a trailing partial byte? ! 2177: jz short DIB4_to_VGA_plane2_copy_done ;no, done ! 2178: ;yes, handle trailing partial byte ! 2179: mov edx,[esi] ;get 8 pixels to convert of DIB ! 2180: and edx,44444444h ;keep only the plane 2 bits of DIB ! 2181: ; dword 0 ! 2182: ; EDX = x6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xx ! 2183: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 2184: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2185: ; DX = x2xxx3xxx0xxx1xx ! 2186: ; AX = xxx6xxx7xxx4xxx5 ! 2187: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 2188: ; x2x6x3x7x0x4x1x5 ! 2189: mov bl,al ;BL = x0x4x1x5 of DIB dword 0 ! 2190: add ah,ah ;make AH 2x6x3x7x of DIB dword 0 (shl 1) ! 2191: or bl,ah ;BL = 20643175 of DIB dword 0 ! 2192: add esi,4 ;point to next DIB dword ! 2193: inc edi ;point to next VGA byte (placed here ! 2194: ; for 486 pipelining reasons) ! 2195: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 2196: mov ch,[edi-1] ;get the VGA destination byte ! 2197: and ecx,ulRightMask ;mask off source and dest ! 2198: or cl,ch ;combine masked source and dest ! 2199: mov [edi-1],cl ;write the new pixels to the VGA ! 2200: ! 2201: DIB4_to_VGA_plane2_copy_done: ! 2202: add esi,ulSrcDelta ;point to start of next DIB scan ! 2203: add edi,ulDstDelta ;point to start of next VGA scan ! 2204: dec ulPlane2Scans ;count down scans in this plane ! 2205: jnz DIB4_to_VGA_plane2_copy_loop ;do next scan in this plane, if any ! 2206: ! 2207: jmp copy_burst_plane2_done ;return to the top of the plane-copy ! 2208: ; loop ! 2209: ! 2210: ;-----------------------------------------------------------------------; ! 2211: ; Plane 3 DIB->VGA conversion code for a single scan line. ! 2212: ; ! 2213: ; Input: ECX with bits sets as described for ulCopyControlFlags, above ! 2214: ; ESI = DIB pointer to first two pixels ! 2215: ; EDI = VGA pointer to planar byte ! 2216: ; ulPlane3Scans = # of scan lines to copy to ! 2217: ; ulSrcDelta = offset from end of one source scan copied to start of next ! 2218: ; ulDstDelta = offset from end of one dest scan copied to start of next ! 2219: ; ulWholeDwordCount = # of whole, aligned dwords to copy ! 2220: ; ulLeftMask = mask for partial left edge, if any ! 2221: ; ulRightMask = mask for partial right edge, if any ! 2222: ; Plane 3 must be mapped in for writes ! 2223: ;-----------------------------------------------------------------------; ! 2224: align 4 ! 2225: DIB4_to_VGA_plane3_copy: ! 2226: ! 2227: ;-----------------------------------------------------------------------; ! 2228: ; Set EBX to point to multiplexed DIB byte->planar byte conversion table ! 2229: ; for plane 3. ! 2230: ;-----------------------------------------------------------------------; ! 2231: ! 2232: mov ebx,DIB4_to_VGA_plane3_table ;stays set for all bytes/words ! 2233: ! 2234: DIB4_to_VGA_plane3_copy_loop: ! 2235: ! 2236: ;-----------------------------------------------------------------------; ! 2237: ; Code to convert 1-7 DIB4 pixels to a partial VGA plane 3 byte (8 ! 2238: ; pixels in plane 3). Assumes that a full dword of DIB4 pixels (8 ! 2239: ; pixels) is available, starting at ESI, although some of the pixels ! 2240: ; will be masked off. Assumes the DIB4 pixels (including masked-off ! 2241: ; pixels) start in the upper nibble of [ESI], and that the first ! 2242: ; (possibly masked-off) DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 2243: ; ! 2244: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 2245: ; (must start on a 256-byte boundary) ! 2246: ; ECX with bits sets as described for ulCopyControlFlags, above ! 2247: ; ESI = DIB pointer to first two pixels (possibly masked off) ! 2248: ; EDI = VGA pointer to planar byte ! 2249: ; plane 3 must be mapped in for writes ! 2250: ;-----------------------------------------------------------------------; ! 2251: ! 2252: test ecx,LEADING_PARTIAL ;handle a leading partial byte? ! 2253: jz short DIB4_to_VGA_plane3_copy_lbyte ;no, go straight to whole ! 2254: ; byte ! 2255: ;yes, handle leading partial byte ! 2256: mov edx,[esi] ;get 8 pixels to convert of DIB dword 0 ! 2257: and edx,88888888h ;keep only the plane 3 bits of DIB ! 2258: ; dword 0 ! 2259: ; EDX = 6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xxx ! 2260: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 2261: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2262: ; DX = 2xxx3xxx0xxx1xxx ! 2263: ; AX = xx6xxx7xxx4xxx5x ! 2264: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 2265: ; 2x6x3x7x0x4x1x5x ! 2266: mov bl,al ;BL = 0x4x1x5x of DIB dword 0 ! 2267: rol ah,7 ;make AH x2x6x3x7 of DIB dword 0 (shr 1) ! 2268: or bl,ah ;BL = 02461357 of DIB dword 0 ! 2269: add esi,4 ;point to next DIB dword ! 2270: inc edi ;point to next VGA byte (placed here ! 2271: ; for 486 pipelining reasons) ! 2272: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 2273: mov ch,[edi-1] ;get the VGA destination byte ! 2274: and ecx,ulLeftMask ;mask off source and dest ! 2275: or cl,ch ;combine masked source and dest ! 2276: mov [edi-1],cl ;write the new pixels to the VGA ! 2277: ! 2278: ;-----------------------------------------------------------------------; ! 2279: ; Code to convert 8 DIB4 pixels to a single VGA plane 3 byte (8 pixels ! 2280: ; in plane 3). Assumes the DIB4 pixels start in the upper nibble of ! 2281: ; [ESI], and that the first DIB4 pixel maps to bit 7 of the VGA at ! 2282: ; [EDI]. ! 2283: ; ! 2284: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 2285: ; (must start on a 256-byte boundary) ! 2286: ; ECX with bits sets as described for ulCopyControlFlags, above ! 2287: ; ESI = DIB pointer to first two pixels ! 2288: ; EDI = VGA pointer to planar byte ! 2289: ; plane 3 must be mapped in for writes ! 2290: ;-----------------------------------------------------------------------; ! 2291: ! 2292: DIB4_to_VGA_plane3_copy_lbyte: ! 2293: test ecx,LEADING_BYTE ;should we handle a leading byte? ! 2294: jz short DIB4_to_VGA_plane3_copy_words ;no, go straight to words ! 2295: ;yes, handle leading byte ! 2296: mov edx,[esi] ;get 8 pixels to convert of DIB dword 0 ! 2297: and edx,88888888h ;keep only the plane 3 bits of DIB ! 2298: ; dword 0 ! 2299: ; EDX = 6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xxx ! 2300: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 2301: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2302: ; DX = 2xxx3xxx0xxx1xxx ! 2303: ; AX = xx6xxx7xxx4xxx5x ! 2304: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 2305: ; 2x6x3x7x0x4x1x5x ! 2306: mov bl,al ;BL = 0x4x1x5x of DIB dword 0 ! 2307: rol ah,7 ;make AH x2x6x3x7 of DIB dword 0 (shr 1) ! 2308: or bl,ah ;BL = 02461357 of DIB dword 0 ! 2309: add esi,4 ;point to next DIB dword ! 2310: inc edi ;point to next VGA byte (placed here ! 2311: ; for 486 pipelining reasons) ! 2312: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 2313: mov [edi-1],cl ;write 8 bits from DIB dword to VGA ! 2314: ! 2315: ;-----------------------------------------------------------------------; ! 2316: ; Code for converting sets of 32 DIB4 pixels to 4 VGA plane 3 bytes (32 ! 2317: ; pixels in plane 3). Assumes the VGA destination is word aligned. ! 2318: ; Assumes the DIB4 pixels start in the upper nibble of [ESI], and that ! 2319: ; the first DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 2320: ; ! 2321: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 2322: ; (must start on a 256-byte boundary) ! 2323: ; ECX with bits sets as described for ulCopyControlFlags, above ! 2324: ; ESI = DIB pointer to first two pixels ! 2325: ; EDI = VGA pointer to two planar bytes (must be word aligned) ! 2326: ; EBP = # of VGA dwords to convert ! 2327: ; ulWholeDwordCount = # of VGA dwords to convert ! 2328: ; plane 3 must be mapped in for writes ! 2329: ; ! 2330: ; Note: on entry at DIB4_to_VGA_plane3_word_odd, ESI must point to the ! 2331: ; desired source start minus 8, and EAX must be loaded as if the following ! 2332: ; instructions had been performed: ! 2333: ; mov edx,[esi+8] ! 2334: ; and edx,88888888h ! 2335: ; mov eax,edx ! 2336: ; shr eax,16+2 ! 2337: ; or eax,edx ! 2338: ; ! 2339: ; Note: ROL AH,7 is used instead of SHR AH,1 because the shift-by-1 ! 2340: ; form is 1 cycle slower on a 486, and in this case the two forms are ! 2341: ; functionally identical. ! 2342: ; ! 2343: ; Note: the code is so odd because of 486 pipeline optimization. ! 2344: ; DO NOT CHANGE THIS CODE UNLESS YOU KNOW EXACTLY WHAT YOU'RE DOING!!! ! 2345: ; ! 2346: ; Note: all 486 pipeline penalties are eliminated except for writing CX ! 2347: ; to memory (2 cycles), so far as I know. ! 2348: ;-----------------------------------------------------------------------; ! 2349: ! 2350: DIB4_to_VGA_plane3_copy_words: ! 2351: test ecx,ODD_WHOLE_WORD or WHOLE_WORDS ;any whole words to copy? ! 2352: jz DIB4_to_VGA_plane3_copy_tbyte ;no, check for trailing whole ! 2353: ; bytes ! 2354: ;yes, copy the whole words ! 2355: push ebp ;preserve stack frame pointer ! 2356: mov ebp,ulWholeDwordCount ;# of VGA dwords to copy to ! 2357: ;even # of DIB dwords to copy? (flags still ! 2358: ; set from TEST) ! 2359: .errnz ODD_WHOLE_WORD - 80000000h ! 2360: jns short DIB4_to_VGA_plane3_word_loop ;yes, start copying ! 2361: ;no, there's an odd word; prepare to enter loop ! 2362: ; in middle ! 2363: mov edx,[esi] ;get 8 pixels to convert of first DIB dword ! 2364: and edx,88888888h ;keep only the plane 3 bits of DIB dword ! 2365: ; EDX = 6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xxx ! 2366: mov eax,edx ;put bits 7-4 of DIB dword in AX, ! 2367: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2368: ; DX = 2xxx3xxx0xxx1xxx ! 2369: ; AX = xx6xxx7xxx4xxx5x ! 2370: or eax,edx ;put bits 7-0 of DIB dword in AX: ! 2371: ; 2x6x3x7x0x4x1x5x ! 2372: sub esi,8 ;compensate source back for entering in middle ! 2373: sub edi,2 ;compensate dest back for entering in middle ! 2374: ! 2375: jmp short DIB4_to_VGA_plane3_word_odd ! 2376: ! 2377: ;-----------------------------------------------------------------------; ! 2378: ; Loop to copy a word at a time to VGA plane 3 (actually, unrolled once ! 2379: ; so copies dwords). ! 2380: ;-----------------------------------------------------------------------; ! 2381: ! 2382: align 16 ! 2383: DIB4_to_VGA_plane3_word_loop: ! 2384: mov edx,[esi] ;get 8 pixels to convert of DIB dword 0 ! 2385: and edx,88888888h ;keep only the plane 3 bits of DIB ! 2386: ; dword 0 ! 2387: ; EDX = 6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xxx ! 2388: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 2389: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2390: ; DX = 2xxx3xxx0xxx1xxx ! 2391: ; AX = xx6xxx7xxx4xxx5x ! 2392: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 2393: ; 2x6x3x7x0x4x1x5x ! 2394: mov edx,[esi+4] ;get 8 pixels to convert of DIB dword 1 ! 2395: mov bl,al ;BL = 0x4x1x5x of DIB dword 0 ! 2396: rol ah,7 ;make AH x2x6x3x7 of DIB dword 0 (shr 1) ! 2397: or bl,ah ;BL = 02461357 of DIB dword 0 ! 2398: and edx,88888888h ;keep only the plane 3 bits of DIB ! 2399: ; dword 1 ! 2400: ; EDX = 6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xxx ! 2401: mov eax,edx ;put bits 7-4 of DIB dword 1 in AX, ! 2402: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2403: ; DX = 2xxx3xxx0xxx1xxx ! 2404: ; AX = xx6xxx7xxx4xxx5x ! 2405: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 2406: or eax,edx ;put bits 7-0 of DIB dword 1 in AX: ! 2407: ; 2x6x3x7x0x4x1x5x ! 2408: mov bl,al ;BL = 0x4x1x5x of DIB dword 1 ! 2409: mov edx,[esi+8] ;get 8 pixels to convert of DIB dword 2 ! 2410: rol ah,7 ;make AH x2x6x3x7 of DIB dword 1 (shr 1) ! 2411: or bl,ah ;BL = 02461357 of DIB dword 1 ! 2412: and edx,88888888h ;keep only the plane 3 bits of DIB ! 2413: ; dword 2 ! 2414: ; EDX = 6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xxx ! 2415: mov eax,edx ;put bits 7-4 of DIB dword 2 in AX, ! 2416: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2417: ; DX = 2xxx3xxx0xxx1xxx ! 2418: ; AX = xx6xxx7xxx4xxx5x ! 2419: mov ch,[ebx] ;CH = 76543210 of DIB dword 1 ! 2420: or eax,edx ;put bits 7-0 of DIB dword 2 in AX: ! 2421: ; 2x6x3x7x0x4x1x5x ! 2422: mov [edi],cx ;write 16 bits from DIB dwords 0 and 1 ! 2423: ; to VGA ! 2424: DIB4_to_VGA_plane3_word_odd: ! 2425: mov edx,[esi+12] ;get 8 pixels to convert of DIB dword 3 ! 2426: mov bl,al ;BL = 0x4x1x5x of DIB dword 2 ! 2427: rol ah,7 ;make AH x2x6x3x7 of DIB dword 2 (shr 1) ! 2428: or bl,ah ;BL = 02461357 of DIB dword 2 ! 2429: and edx,88888888h ;keep only the plane 3 bits of DIB ! 2430: ; dword 3 ! 2431: ; EDX = 6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xxx ! 2432: mov eax,edx ;put bits 7-4 of DIB dword 3 in AX, ! 2433: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2434: ; DX = 2xxx3xxx0xxx1xxx ! 2435: ; AX = xx6xxx7xxx4xxx5x ! 2436: mov cl,[ebx] ;CL = 76543210 of DIB dword 2 ! 2437: or eax,edx ;put bits 7-0 of DIB dword 3 in AX: ! 2438: ; 2x6x3x7x0x4x1x5x ! 2439: mov bl,al ;BL = 0x4x1x5x of DIB dword 3 ! 2440: rol ah,7 ;make AH x2x6x3x7 of DIB dword 3 (shr 1) ! 2441: or bl,ah ;BL = 02461357 of DIB dword 3 ! 2442: add esi,16 ;point to next set of 4 DIB dwords ! 2443: add edi,4 ;point to next VGA dword ! 2444: mov ch,[ebx] ;CH = 76543210 of dword 0 ! 2445: dec ebp ;count down VGA dwords ! 2446: mov [edi-2],cx ;write 16 bits from DIB dwords 2 and 3 ! 2447: ; to VGA ! 2448: jnz DIB4_to_VGA_plane3_word_loop ;do next VGA dword, if any ! 2449: ! 2450: pop ebp ;restore stack frame pointer ! 2451: ! 2452: ;-----------------------------------------------------------------------; ! 2453: ; Code to convert 8 DIB4 pixels to a single VGA plane 3 byte (8 pixels ! 2454: ; in plane 3). Assumes the DIB4 pixels start in the upper nibble of ! 2455: ; [ESI], and that the first DIB4 pixel maps to bit 7 of the VGA at ! 2456: ; [EDI]. ! 2457: ; ! 2458: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 2459: ; (must start on a 256-byte boundary) ! 2460: ; ECX with bits sets as described for ulCopyControlFlags, above ! 2461: ; ESI = DIB pointer to first two pixels ! 2462: ; EDI = VGA pointer to planar byte ! 2463: ; plane 3 must be mapped in for writes ! 2464: ; ! 2465: ;-----------------------------------------------------------------------; ! 2466: ! 2467: DIB4_to_VGA_plane3_copy_tbyte: ! 2468: test ecx,TRAILING_BYTE ;should we handle a trailing byte? ! 2469: jz short DIB4_to_VGA_plane3_copy_tpart ;no, check for trailing ! 2470: ; partial ! 2471: ;yes, handle trailing byte ! 2472: mov edx,[esi] ;get 8 pixels to convert of DIB dword 0 ! 2473: and edx,88888888h ;keep only the plane 3 bits of DIB ! 2474: ; dword 0 ! 2475: ; EDX = 6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xxx ! 2476: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 2477: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2478: ; DX = 2xxx3xxx0xxx1xxx ! 2479: ; AX = xx6xxx7xxx4xxx5x ! 2480: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 2481: ; 2x6x3x7x0x4x1x5x ! 2482: mov bl,al ;BL = 0x4x1x5x of DIB dword 0 ! 2483: rol ah,7 ;make AH x2x6x3x7 of DIB dword 0 (shr 1) ! 2484: or bl,ah ;BL = 02461357 of DIB dword 0 ! 2485: add esi,4 ;point to next DIB dword ! 2486: inc edi ;point to next VGA byte (placed here ! 2487: ; for 486 pipelining reasons) ! 2488: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 2489: mov [edi-1],cl ;write 8 bits from DIB dword to VGA ! 2490: ! 2491: ;-----------------------------------------------------------------------; ! 2492: ; Code to convert 1-7 DIB4 pixels to a partial VGA plane 3 byte (8 ! 2493: ; pixels in plane 3). Assumes that a full dword of DIB4 pixels (8 ! 2494: ; pixels) is available, starting at ESI, although some of the pixels ! 2495: ; will be masked off. Assumes the DIB4 pixels (including masked-off ! 2496: ; pixels) start in the upper nibble of [ESI], and that the first ! 2497: ; (possibly masked-off) DIB4 pixel maps to bit 7 of the VGA at [EDI]. ! 2498: ; ! 2499: ; Input: EBX = pointer to multiplexed DIB byte->planar byte conversion table ! 2500: ; (must start on a 256-byte boundary) ! 2501: ; ECX with bits sets as described for ulCopyControlFlags, above ! 2502: ; ESI = DIB pointer to first two pixels (possibly masked off) ! 2503: ; EDI = VGA pointer to planar byte ! 2504: ; plane 3 must be mapped in for writes ! 2505: ;-----------------------------------------------------------------------; ! 2506: ! 2507: DIB4_to_VGA_plane3_copy_tpart: ! 2508: test ecx,TRAILING_PARTIAL ;handle a trailing partial byte? ! 2509: jz short DIB4_to_VGA_plane3_copy_done ;no, done ! 2510: ;yes, handle trailing partial byte ! 2511: mov edx,[esi] ;get 8 pixels to convert of DIB dword 0 ! 2512: and edx,88888888h ;keep only the plane 3 bits of DIB ! 2513: ; dword 0 ! 2514: ; EDX = 6xxx7xxx4xxx5xxx2xxx3xxx0xxx1xxx ! 2515: mov eax,edx ;put bits 7-4 of DIB dword 0 in AX, ! 2516: shr eax,16+2 ; shifted right 2 (x = zero bit) ! 2517: ; DX = 2xxx3xxx0xxx1xxx ! 2518: ; AX = xx6xxx7xxx4xxx5x ! 2519: or eax,edx ;put bits 7-0 of DIB dword 0 in AX: ! 2520: ; 2x6x3x7x0x4x1x5x ! 2521: mov bl,al ;BL = 0x4x1x5x of DIB dword 0 ! 2522: rol ah,7 ;make AH x2x6x3x7 of DIB dword 0 (shr 1) ! 2523: or bl,ah ;BL = 02461357 of DIB dword 0 ! 2524: add esi,4 ;point to next DIB dword ! 2525: inc edi ;point to next VGA byte (placed here ! 2526: ; for 486 pipelining reasons) ! 2527: mov cl,[ebx] ;CL = 76543210 of DIB dword 0 ! 2528: mov ch,[edi-1] ;get the VGA destination byte ! 2529: and ecx,ulRightMask ;mask off source and dest ! 2530: or cl,ch ;combine masked source and dest ! 2531: mov [edi-1],cl ;write the new pixels to the VGA ! 2532: ! 2533: DIB4_to_VGA_plane3_copy_done: ! 2534: add esi,ulSrcDelta ;point to start of next DIB scan ! 2535: add edi,ulDstDelta ;point to start of next VGA scan ! 2536: dec ulPlane3Scans ;count down scans in this plane ! 2537: jnz DIB4_to_VGA_plane3_copy_loop ;do next scan in this plane, if any ! 2538: ! 2539: jmp copy_burst_plane3_done ;return to the top of the plane-copy ! 2540: ; loop ! 2541: ! 2542: endProc vDIB2VGA ! 2543: ! 2544: public jLeftMasks ! 2545: public jRightMasks ! 2546: public one_partial_only ! 2547: public check_whole_bytes ! 2548: public set_copy_control_flags ! 2549: public set_shift_vec ! 2550: public set_initial_banking ! 2551: public map_init_bank ! 2552: public init_bank_mapped ! 2553: public bank_loop ! 2554: public copy_burst_loop ! 2555: public align_burst_rshift_386 ! 2556: public align_burst_lshift_386 ! 2557: public align_burst_rshift_486 ! 2558: public align_burst_lshift_486 ! 2559: public set_alignment_source ! 2560: public proceed_with_copy ! 2561: public copy_burst_plane0_done ! 2562: public copy_burst_plane1_done ! 2563: public copy_burst_plane2_done ! 2564: public copy_burst_plane3_done ! 2565: public next_bank ! 2566: public DIB4_to_VGA_plane0_copy ! 2567: public DIB4_to_VGA_plane0_copy_loop ! 2568: public DIB4_to_VGA_plane0_copy_lbyte ! 2569: public DIB4_to_VGA_plane0_copy_words ! 2570: public DIB4_to_VGA_plane0_word_loop ! 2571: public DIB4_to_VGA_plane0_word_odd ! 2572: public DIB4_to_VGA_plane0_copy_tbyte ! 2573: public DIB4_to_VGA_plane0_copy_tpart ! 2574: public DIB4_to_VGA_plane0_copy_done ! 2575: public DIB4_to_VGA_plane1_copy ! 2576: public DIB4_to_VGA_plane1_copy_loop ! 2577: public DIB4_to_VGA_plane1_copy_lbyte ! 2578: public DIB4_to_VGA_plane1_copy_words ! 2579: public DIB4_to_VGA_plane1_word_loop ! 2580: public DIB4_to_VGA_plane1_word_odd ! 2581: public DIB4_to_VGA_plane1_copy_tbyte ! 2582: public DIB4_to_VGA_plane1_copy_tpart ! 2583: public DIB4_to_VGA_plane1_copy_done ! 2584: public DIB4_to_VGA_plane2_copy ! 2585: public DIB4_to_VGA_plane2_copy_loop ! 2586: public DIB4_to_VGA_plane2_copy_lbyte ! 2587: public DIB4_to_VGA_plane2_copy_words ! 2588: public DIB4_to_VGA_plane2_word_loop ! 2589: public DIB4_to_VGA_plane2_word_odd ! 2590: public DIB4_to_VGA_plane2_copy_tbyte ! 2591: public DIB4_to_VGA_plane2_copy_tpart ! 2592: public DIB4_to_VGA_plane2_copy_done ! 2593: public DIB4_to_VGA_plane3_copy ! 2594: public DIB4_to_VGA_plane3_copy_loop ! 2595: public DIB4_to_VGA_plane3_copy_lbyte ! 2596: public DIB4_to_VGA_plane3_copy_words ! 2597: public DIB4_to_VGA_plane3_word_loop ! 2598: public DIB4_to_VGA_plane3_word_odd ! 2599: public DIB4_to_VGA_plane3_copy_tbyte ! 2600: public DIB4_to_VGA_plane3_copy_tpart ! 2601: public DIB4_to_VGA_plane3_copy_done ! 2602: ! 2603: _TEXT$01 ends ! 2604: ! 2605: end ! 2606:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.