![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to alignblt.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 alignblt.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 ! root 1: ;---------------------------Module-Header------------------------------; ! 2: ; Module Name: alignblt.asm ! 3: ; ! 4: ; Copyright (c) 1992 Microsoft Corporation ! 5: ;-----------------------------------------------------------------------; ! 6: ! 7: ;-----------------------------------------------------------------------; ! 8: ; VOID vAlignedSrcCopy(PDEVSURF pdsurf, RECTL * prcldst, PPOINTL * pptlsrc, ! 9: ; INT icopydir); ! 10: ; Input: ! 11: ; pdsurf - surface on which to copy ! 12: ; prcldest - pointer to destination rectangle ! 13: ; pptlsrc - pointer to source upper left corner ! 14: ; icopydir - direction in which copy must proceed to avoid overlap problems ! 15: ; and synchronize with the clip enumeration visually, according to ! 16: ; constants CD_RIGHTDOWN, CD_LEFTDOWN, CD_RIGHTUP, and CD_LEFTUP in ! 17: ; WINDDI.H ! 18: ; ! 19: ; Performs accelarated aligned SRCCOPY VGA-to-VGA blts. ! 20: ; ! 21: ;-----------------------------------------------------------------------; ! 22: ; ! 23: ; Note: Assumes all rectangles have positive heights and widths. Will not ! 24: ; work properly if this is not the case. ! 25: ; ! 26: ;-----------------------------------------------------------------------; ! 27: ! 28: comment $ ! 29: ! 30: The overall approach of this module for each rectangle to copy is: ! 31: ! 32: 1) Precalculate the masks and whole byte widths, and determine which of ! 33: partial left edge, partial right edge, and whole middle bytes are required ! 34: for this copy. ! 35: ! 36: 2) Set up the starting pointers for each of the areas (left, whole middle, ! 37: right), the start and stop scan lines, the copying direction (left-to-right ! 38: or right-to-left, and top-to-bottom or bottom-to-top), the threading ! 39: (sequence of calls required to do the left/whole/right components in the ! 40: proper sequence), based on the passed-in copy direction, which in turn is ! 41: dictated by the nature of the overlap between the source and destination. ! 42: ! 43: 3) Execute a loop, based on adapter type (2 R/W windows, 1R/1W window, ! 44: 1 R/W window, unbanked), that sequences through the intersection of each ! 45: bank with the source and destination rectangles in the proper direction ! 46: (top-to-bottom or bottom-to-top, based on the passed-in copy direction), ! 47: and performs the copy in each such rectangle. The threading vector is used ! 48: to call the required routines (copy left/whole/right bytes). For 1 R/W and ! 49: 1R/1W adapters, there is a second threading vector that is called when the ! 50: source and the destination are both adequately (for the copy purposes) ! 51: addressable simultaneously (because they're in the same bank), so there's ! 52: no need to copy through a temp buffer. Obviously, we want to avoid the temp ! 53: buffer whenever we can, because it's much slower and doesn't let us take ! 54: advantage of the VGA's hardware. ! 55: ! 56: Note: 1 R/W and 1R/1W edges are copied through a temporary buffer. However, ! 57: each plane's bytes are not stored in the corresponding plane's temp buffer, but ! 58: rather consecutively in the plane 0 temp buffer. This is to reduce page ! 59: faulting, and also so that 1R/1W adapters only need a temp buffer large enough ! 60: to hold 4*tallest bank bytes (2K will do here, but nalgnblt.asm needs 4K). ! 61: 1 R/W adapters still copy whole bytes through the full temp buffer, using all ! 62: four planes' temp buffers, so they require a temp buffer big enough to hold a ! 63: full bank (256K will do). ! 64: ! 65: commend $ ! 66: ! 67: ;-----------------------------------------------------------------------; ! 68: ; Set LOOP_UNROLL_SHIFT to the log2 of the number of times you want loops in ! 69: ; this module unrolled. For example, LOOP_UNROLL_SHIFT of 3 yields 2**3 = 8 ! 70: ; times unrolling. This is the only thing you need to change to control ! 71: ; unrolling. Note: does not affect loops that process in chunks, like edge ! 72: ; loops. ! 73: ! 74: LOOP_UNROLL_SHIFT equ 2 ! 75: ! 76: ;-----------------------------------------------------------------------; ! 77: ; Maximum # of edge bytes to process before switching to next plane. Larger ! 78: ; means faster, but there's more potential for flicker, since the raster scan ! 79: ; has a better chance of catching bytes that have changed in some planes but ! 80: ; not all planes. ! 81: ! 82: EDGE_CHUNK_SIZE equ 16 ! 83: ! 84: ;-----------------------------------------------------------------------; ! 85: ; Macro to push the current threading sequence (string of routine calls) on the ! 86: ; stack, then jump to the first threading entry. The threading pointer can be ! 87: ; specified, or defaults to pCurrentThread. The return address can be ! 88: ; immediately after the JMP, or can be specified. ! 89: ! 90: THREAD_AND_START macro THREADING,RETURN_ADDR ! 91: local push_base, return_address ! 92: ! 93: ifb <&RETURN_ADDR&> ! 94: push offset return_address ;after all the threaded routines, we ! 95: ; return here ! 96: else ! 97: push offset &RETURN_ADDR& ;return here ! 98: endif ! 99: ! 100: ifb <&THREADING&> ! 101: mov eax,pCurrentThread ! 102: else ! 103: mov eax,&THREADING& ! 104: endif ! 105: ! 106: mov ecx,[eax] ;# of routines to thread (at least 1) ! 107: lea ecx,[ecx*2+ecx] ;pushes below are 3 bytes each ! 108: mov edx,offset push_base+3 ! 109: sub edx,ecx ! 110: jmp edx ;branch to push or jmp below ! 111: ! 112: ; Push the threading addresses on to the stack, so routines perform the ! 113: ; threading as they return. ! 114: ! 115: push dword ptr [eax+12] ;3 byte instruction ! 116: push dword ptr [eax+8] ! 117: push_base: ! 118: jmp dword ptr [eax+4] ;jump to the first threaded routine ! 119: ! 120: align 4 ! 121: return_address: ! 122: endm ! 123: ! 124: ;-----------------------------------------------------------------------; ! 125: ! 126: .386 ! 127: ! 128: ifndef DOS_PLATFORM ! 129: .model small,c ! 130: else ! 131: ifdef STD_CALL ! 132: .model small,c ! 133: else ! 134: .model small,pascal ! 135: endif; STD_CALL ! 136: endif; DOS_PLATFORM ! 137: ! 138: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT ! 139: assume fs:nothing,gs:nothing ! 140: ! 141: .xlist ! 142: include stdcall.inc ;calling convention cmacros ! 143: include i386\egavga.inc ! 144: include i386\strucs.inc ! 145: include i386\unroll.inc ! 146: include i386\ropdefs.inc ! 147: ! 148: .list ! 149: ! 150: ;-----------------------------------------------------------------------; ! 151: ! 152: .data ! 153: ! 154: ; Threads for stringing together left, whole byte, and right operations ! 155: ; in various orders, both using a temp buffer and not. Data format is: ! 156: ; ! 157: ; DWORD +0 = # of calls in thread (1, 2, or 3) ! 158: ; +4 = first call (required) ! 159: ; +8 = second call (optional) ! 160: ; +12 = third call (optional) ! 161: ! 162: align 4 ! 163: ! 164: ; Copies not involving the temp buffer. ! 165: ! 166: Thread_L dd 1 ! 167: dd copy_left_edge ! 168: ! 169: Thread_W dd 1 ! 170: dd copy_whole_bytes ! 171: ! 172: Thread_R dd 1 ! 173: dd copy_right_edge ! 174: ! 175: Thread_LR dd 2 ! 176: dd copy_left_edge ! 177: dd copy_right_edge ! 178: ! 179: Thread_RL dd 2 ! 180: dd copy_right_edge ! 181: dd copy_left_edge ! 182: ! 183: Thread_LW dd 2 ! 184: dd copy_left_edge ! 185: dd copy_whole_bytes ! 186: ! 187: Thread_WL dd 2 ! 188: dd copy_whole_bytes ! 189: dd copy_left_edge ! 190: ! 191: Thread_WR dd 2 ! 192: dd copy_whole_bytes ! 193: dd copy_right_edge ! 194: ! 195: Thread_RW dd 2 ! 196: dd copy_right_edge ! 197: dd copy_whole_bytes ! 198: ! 199: Thread_LWR dd 3 ! 200: dd copy_left_edge ! 201: dd copy_whole_bytes ! 202: dd copy_right_edge ! 203: ! 204: Thread_RWL dd 3 ! 205: dd copy_right_edge ! 206: dd copy_whole_bytes ! 207: dd copy_left_edge ! 208: ! 209: ; Copies involving the temp buffer. ! 210: ! 211: Thread_Lb dd 1 ! 212: dd copy_left_edge_via_buffer ! 213: ! 214: Thread_Wb dd 1 ! 215: dd copy_whole_bytes_via_buffer ! 216: ! 217: Thread_Rb dd 1 ! 218: dd copy_right_edge_via_buffer ! 219: ! 220: Thread_LbRb dd 2 ! 221: dd copy_left_edge_via_buffer ! 222: dd copy_right_edge_via_buffer ! 223: ! 224: Thread_RbLb dd 2 ! 225: dd copy_right_edge_via_buffer ! 226: dd copy_left_edge_via_buffer ! 227: ! 228: Thread_LbW dd 2 ! 229: dd copy_left_edge_via_buffer ! 230: dd copy_whole_bytes ! 231: ! 232: Thread_LbWb dd 2 ! 233: dd copy_left_edge_via_buffer ! 234: dd copy_whole_bytes_via_buffer ! 235: ! 236: Thread_WLb dd 2 ! 237: dd copy_whole_bytes ! 238: dd copy_left_edge_via_buffer ! 239: ! 240: Thread_WbLb dd 2 ! 241: dd copy_whole_bytes_via_buffer ! 242: dd copy_left_edge_via_buffer ! 243: ! 244: Thread_WRb dd 2 ! 245: dd copy_whole_bytes ! 246: dd copy_right_edge_via_buffer ! 247: ! 248: Thread_WbRb dd 2 ! 249: dd copy_whole_bytes_via_buffer ! 250: dd copy_right_edge_via_buffer ! 251: ! 252: Thread_RbW dd 2 ! 253: dd copy_right_edge_via_buffer ! 254: dd copy_whole_bytes ! 255: ! 256: Thread_RbWb dd 2 ! 257: dd copy_right_edge_via_buffer ! 258: dd copy_whole_bytes_via_buffer ! 259: ! 260: Thread_LbWRb dd 3 ! 261: dd copy_left_edge_via_buffer ! 262: dd copy_whole_bytes ! 263: dd copy_right_edge_via_buffer ! 264: ! 265: Thread_LbWbRb dd 3 ! 266: dd copy_left_edge_via_buffer ! 267: dd copy_whole_bytes_via_buffer ! 268: dd copy_right_edge_via_buffer ! 269: ! 270: Thread_RbWLb dd 3 ! 271: dd copy_right_edge_via_buffer ! 272: dd copy_whole_bytes ! 273: dd copy_left_edge_via_buffer ! 274: ! 275: Thread_RbWbLb dd 3 ! 276: dd copy_right_edge_via_buffer ! 277: dd copy_whole_bytes_via_buffer ! 278: dd copy_left_edge_via_buffer ! 279: ! 280: ;-----------------------------------------------------------------------; ! 281: ; Table of thread selection for various horizontal copy directions, with ! 282: ; the look-up index a 4-bit field as follows: ! 283: ; ! 284: ; Bit 3 = 1 if left-to-right copy, 0 if right-to-left ! 285: ; Bit 2 = 1 if left edge must be copied ! 286: ; Bit 1 = 1 if whole bytes must be copied ! 287: ; Bit 0 = 1 if right edge must be copied ! 288: ; ! 289: ; This is used for all cases where both the source and destination are ! 290: ; simultaneously addressable for our purposes, so there's no need to go ! 291: ; through the temp buffer (unbanked, 2 R/W, and sometimes for 1 R/W and 1R/1W). ! 292: ! 293: MasterThreadTable label dword ! 294: ;right-to-left ! 295: dd 0 ;<not used> ! 296: dd Thread_R ;R->L, R ! 297: dd Thread_W ;R->L, W ! 298: dd Thread_RW ;R->L, RW ! 299: dd Thread_L ;R->L, L ! 300: dd Thread_RL ;R->L, RL ! 301: dd Thread_WL ;R->L, WL ! 302: dd Thread_RWL ;R->L, RWL ! 303: ;left-to-right ! 304: dd 0 ;<not used> ! 305: dd Thread_R ;L->R, R ! 306: dd Thread_W ;L->R, W ! 307: dd Thread_WR ;L->R, WR ! 308: dd Thread_L ;L->R, L ! 309: dd Thread_LR ;L->R, LR ! 310: dd Thread_LW ;L->R, LW ! 311: dd Thread_LWR ;L->R, LWR ! 312: ! 313: ! 314: ; Table of thread selection for various adapter types and horizontal ! 315: ; copy directions, with the look-up index a 6-bit field as follows: ! 316: ; ! 317: ; Bit 5 = adapter type high bit ! 318: ; Bit 4 = adapter type low bit ! 319: ; Bit 3 = 1 if left-to-right copy, 0 if right-to-left ! 320: ; Bit 2 = 1 if left edge must be copied ! 321: ; Bit 1 = 1 if whole bytes must be copied ! 322: ; Bit 0 = 1 if right edge must be copied ! 323: ; ! 324: ; This is used for all cases where the source and destination are not both ! 325: ; simultaneously addressable for our purposes, so we need to go through the ! 326: ; temp buffer (only for 1 R/W and 1R/1W, and only sometimes). ! 327: ! 328: MasterThreadTableViaBuffer label dword ! 329: ;unbanked (no need for buffer) ! 330: ;right-to-left ! 331: dd 0 ;<not used> ! 332: dd Thread_R ;R->L, R ! 333: dd Thread_W ;R->L, W ! 334: dd Thread_RW ;R->L, RW ! 335: dd Thread_L ;R->L, L ! 336: dd Thread_RL ;R->L, RL ! 337: dd Thread_WL ;R->L, WL ! 338: dd Thread_RWL ;R->L, RWL ! 339: ;left-to-right ! 340: dd 0 ;<not used> ! 341: dd Thread_R ;L->R, R ! 342: dd Thread_W ;L->R, W ! 343: dd Thread_WR ;L->R, WR ! 344: dd Thread_L ;L->R, L ! 345: dd Thread_LR ;L->R, LR ! 346: dd Thread_LW ;L->R, LW ! 347: dd Thread_LWR ;L->R, LWR ! 348: ! 349: ;1 R/W banking window (everything goes through ! 350: ; buffer) ! 351: ;right-to-left ! 352: dd 0 ;<not used> ! 353: dd Thread_Rb ;R->L, R ! 354: dd Thread_Wb ;R->L, W ! 355: dd Thread_RbWb ;R->L, RW ! 356: dd Thread_Lb ;R->L, L ! 357: dd Thread_RbLb ;R->L, RL ! 358: dd Thread_WbLb ;R->L, WL ! 359: dd Thread_RbWbLb ;R->L, RWL ! 360: ;left-to-right ! 361: dd 0 ;<not used> ! 362: dd Thread_Rb ;L->R, R ! 363: dd Thread_Wb ;L->R, W ! 364: dd Thread_WbRb ;L->R, WR ! 365: dd Thread_Lb ;L->R, L ! 366: dd Thread_LbRb ;L->R, LR ! 367: dd Thread_LbWb ;L->R, LW ! 368: dd Thread_LbWbRb ;L->R, LWR ! 369: ! 370: ;1R/1W banking window (edge go through buffer) ! 371: ;right-to-left ! 372: dd 0 ;<not used> ! 373: dd Thread_Rb ;R->L, R ! 374: dd Thread_W ;R->L, W ! 375: dd Thread_RbW ;R->L, RW ! 376: dd Thread_Lb ;R->L, L ! 377: dd Thread_RbLb ;R->L, RL ! 378: dd Thread_WLb ;R->L, WL ! 379: dd Thread_RbWLb ;R->L, RWL ! 380: ;left-to-right ! 381: dd 0 ;<not used> ! 382: dd Thread_Rb ;L->R, R ! 383: dd Thread_W ;L->R, W ! 384: dd Thread_WRb ;L->R, WR ! 385: dd Thread_Lb ;L->R, L ! 386: dd Thread_LbRb ;L->R, LR ! 387: dd Thread_LbW ;L->R, LW ! 388: dd Thread_LbWRb ;L->R, LWR ! 389: ! 390: ;2 R/W banking window (no need for buffer) ! 391: ;right-to-left ! 392: dd 0 ;<not used> ! 393: dd Thread_R ;R->L, R ! 394: dd Thread_W ;R->L, W ! 395: dd Thread_RW ;R->L, RW ! 396: dd Thread_L ;R->L, L ! 397: dd Thread_RL ;R->L, RL ! 398: dd Thread_WL ;R->L, WL ! 399: dd Thread_RWL ;R->L, RWL ! 400: ;left-to-right ! 401: dd 0 ;<not used> ! 402: dd Thread_R ;L->R, R ! 403: dd Thread_W ;L->R, W ! 404: dd Thread_WR ;L->R, WR ! 405: dd Thread_L ;L->R, L ! 406: dd Thread_LR ;L->R, LR ! 407: dd Thread_LW ;L->R, LW ! 408: dd Thread_LWR ;L->R, LWR ! 409: ! 410: ! 411: ; Amount to shift adapter type field left for use in MasterThreadTableViaBuffer. ! 412: ! 413: ADAPTER_FIELD_SHIFT equ 4 ! 414: ! 415: ; Mask for setting left-to-right bit to "left-to-right true" for use in both ! 416: ; MasterThread tables. ! 417: ! 418: LEFT_TO_RIGHT_FIELD_SET equ 1000b ! 419: ! 420: ! 421: ; Table of top-to-bottom loops for adapter types. ! 422: ! 423: align 4 ! 424: TopToBottomLoopTable label dword ! 425: dd top_to_bottom_2RW ;unbanked is same as 2RW ! 426: dd top_to_bottom_1RW ! 427: dd top_to_bottom_1R1W ! 428: dd top_to_bottom_2RW ! 429: ! 430: ! 431: ; Table of bottom-to-top loops for adapter types. ! 432: ! 433: align 4 ! 434: BottomToTopLoopTable label dword ! 435: dd bottom_to_top_2RW ;unbanked is same as 2RW ! 436: dd bottom_to_top_1RW ! 437: dd bottom_to_top_1R1W ! 438: dd bottom_to_top_2RW ! 439: ! 440: ! 441: ; Table of routines for setting up to copy in various directions. ! 442: ! 443: align 4 ! 444: SetUpForCopyDirection label dword ! 445: dd left_to_right_top_to_bottom ;CD_RIGHTDOWN ! 446: dd right_to_left_top_to_bottom ;CD_LEFTDOWN ! 447: dd left_to_right_bottom_to_top ;CD_RIGHTUP ! 448: dd right_to_left_bottom_to_top ;CD_LEFTUP ! 449: ! 450: ;-----------------------------------------------------------------------; ! 451: ; Left edge clip masks for intrabyte start addresses 0 through 7. ! 452: ; Whole byte cases are flagged as 0ffh. ! 453: ! 454: jLeftMaskTable label byte ! 455: db 0ffh,07fh,03fh,01fh,00fh,007h,003h,001h ! 456: ! 457: ;-----------------------------------------------------------------------; ! 458: ; Right edge clip masks for intrabyte end addresses (non-inclusive) ! 459: ; 0 through 7. Whole byte cases are flagged as 0ffh. ! 460: ! 461: jRightMaskTable label byte ! 462: db 0ffh,080h,0c0h,0e0h,0f0h,0f8h,0fch,0feh ! 463: ! 464: ;-----------------------------------------------------------------------; ! 465: ! 466: .code ! 467: ! 468: _TEXT$03 SEGMENT DWORD USE32 PUBLIC 'CODE' ! 469: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING ! 470: ! 471: ;-----------------------------------------------------------------------; ! 472: ! 473: cProc vAlignedSrcCopy,16,< \ ! 474: uses esi edi ebx, \ ! 475: pdsurf: ptr DEVSURF, \ ! 476: prcldest : ptr RECTL, \ ! 477: pptlsrc : ptr POINTL, \ ! 478: icopydir : dword ! 479: ! 480: local culWholeBytesWidth : dword ;# of bytes to copy across each scan ! 481: local ulBlockHeight : dword ;# of scans to copy per bank block ! 482: local ulWholeScanDelta : dword;offset from end of one whole bytes ! 483: ; scan to start of next ! 484: local ulWholeBytesSrc : dword ;offset in bitmap of first source whole ! 485: ; byte to copy from ! 486: local ulWholeBytesDest : dword;offset in bitmap of first source whole ! 487: ; byte to copy to ! 488: local ulLeftEdgeSrc : dword ;offset in bitmap of first source left ! 489: ; edge byte to copy from ! 490: local ulLeftEdgeDest : dword ;offset in bitmap of first dest left ! 491: ; edge byte to copy to ! 492: local ulRightEdgeSrc : dword ;offset in bitmap of first source right ! 493: ; edge byte to copy from ! 494: local ulRightEdgeDest : dword ;offset in bitmap of first dest right ! 495: ; edge byte to copy to ! 496: local ulNextScan : dword ;width of scan, in bytes ! 497: local jLeftMask : dword ;left edge clip mask ! 498: local jRightMask : dword ;right edge clip mask ! 499: local culTempCount : dword ;handy temporary counter ! 500: local pTempEntry : dword ;temporary storage for vector into ! 501: ; unrolled loop ! 502: local pTempPlane : dword ;pointer to storage in temp buffer for ! 503: ; edge bytes (which are stored ! 504: ; consecutively, not in each plane's ! 505: ; temp buffer, to reduce possible page ! 506: ; faulting ! 507: local ppTempPlane0 : dword ;pointer to pointer to storage in temp ! 508: ; buffer for plane 0, immediately ! 509: ; preceded by storage for planes 1, 2, ! 510: ; and 3 ! 511: local ppTempPlane3 : dword ;like above, but for plane 3 ! 512: local ulOffsetInBank : dword ;offset relative to bank start ! 513: local pSrcAddr : dword ;working pointer to first source ! 514: ; byte to copy from ! 515: local pDestAddr : dword ;working pointer to first dest ! 516: ; byte to copy to ! 517: local ulCurrentJustification:dword ;justification used to map in ! 518: ; banks; top for top to bottom ! 519: ; copies, bottom for bottom to top ! 520: local ulCurrentSrcScan :dword ;scan line used to map in current ! 521: ; source bank ! 522: local ulCurrentDestScan:dword ;scan line used to map in current dest ! 523: ; bank ! 524: local ulLastDestScan :dword ;scan in target rect at which we stop ! 525: ; advancing through banks ! 526: local pCurrentThread : dword ;pointer to data describing the ! 527: ; threaded calls to be performed to ! 528: ; perform the current copy ! 529: local pCurrentThreadViaBuffer:dword ! 530: ;pointer to data describing the ! 531: ; threaded calls to be performed to ! 532: ; perform the current copy in the case ! 533: ; where the source and destination are ! 534: ; not simultaneously adequately ! 535: ; accessible, so the copy has to go ! 536: ; through a temp buffer (used only for ! 537: ; 1 R/W and 1R/1W banking) ! 538: local ulAdapterType : dword ;adapter type code, per VIDEO_BANK_TYPE ! 539: local ulLWRType : dword ;whether left edge, whole bytes, and ! 540: ; right edge are involved in the ! 541: ; current operation; ! 542: ; bit 2 = 1 if left edge involved ! 543: ; bit 1 = 1 if whole bytes involved ! 544: ; bit 0 = 1 if right edge involved ! 545: local ulLeftEdgeAdjust :dword ;used to bump the whole bytes start ! 546: ; address past the left edge when the ! 547: ; left edge is partial ! 548: ! 549: ;-----------------------------------------------------------------------; ! 550: ! 551: ; Set pointers to temp buffer plane pointers (used only by 1 R/W and 1R/1W ! 552: ; adapters), and other rectangle-independent variables. ! 553: ! 554: mov esi,pdsurf ! 555: mov eax,[esi].dsurf_pvBankBufferPlane0 ! 556: mov pTempPlane,eax ! 557: lea eax,[esi].dsurf_pvBankBufferPlane0 ! 558: mov ppTempPlane0,eax ! 559: lea eax,[esi].dsurf_pvBankBufferPlane3 ! 560: mov ppTempPlane3,eax ! 561: ! 562: mov eax,[esi].dsurf_vbtBankingType ! 563: mov ulAdapterType,eax ! 564: ! 565: ; Copy the rectangle. ! 566: ! 567: call copy_rect ! 568: ! 569: ;-----------------------------------------------------------------------; ! 570: ; Set the VGA registers back to their default state. ! 571: ;-----------------------------------------------------------------------; ! 572: ! 573: mov edx,VGA_BASE + GRAF_ADDR ! 574: mov eax,(0ffh shl 8) + GRAF_BIT_MASK ! 575: out dx,ax ;enable bit mask for all bits ! 576: ! 577: mov dl,SEQ_DATA ! 578: mov al,MM_ALL ! 579: out dx,al ;enable writes to all planes ! 580: ! 581: cld ;restore default direction flag ! 582: ! 583: cRet vAlignedSrcCopy ;done ! 584: ! 585: ! 586: ;***********************************************************************; ! 587: ; ! 588: ; Copies the specified rectangle. ! 589: ; ! 590: ;***********************************************************************; ! 591: ! 592: align 4 ! 593: copy_rect: ! 594: ! 595: ; Set up masks and whole bytes count, and build left/whole/right index ! 596: ; indicating which of those parts are involved in the copy. ! 597: ! 598: mov edi,prcldest ;point to rectangle to copy ! 599: ! 600: mov ebx,[edi].xRight ;right edge of fill (non-inclusive) ! 601: mov ecx,ebx ! 602: and ecx,0111b ;intrabyte address of right edge ! 603: mov ah,jRightMaskTable[ecx] ;right edge mask ! 604: ! 605: mov esi,[edi].xLeft ;left edge of fill (inclusive) ! 606: mov ecx,esi ! 607: shr ecx,3 ;/8 for start offset from left edge ! 608: ; of scan line ! 609: sub ebx,esi ;width in pixels of fill ! 610: ! 611: and esi,0111b ;intrabyte address of left edge ! 612: mov al,jLeftMaskTable[esi] ;left edge mask ! 613: ! 614: dec ebx ;make inclusive on right ! 615: add ebx,esi ;inclusive width, starting counting at ! 616: ; the beginning of the left edge byte ! 617: shr ebx,3 ;width of fill in bytes touched - 1 ! 618: jnz short more_than_1_byte ;more than 1 byte is involved ! 619: ! 620: ; Only one byte will be affected. Combine first/last masks. ! 621: ! 622: and al,ah ;we'll use first byte mask only ! 623: xor ah,ah ;want last byte mask to be 0 to ! 624: ; indicate right edge not involved ! 625: inc ebx ;so there's one count to subtract below ! 626: ; if this isn't a whole edge byte ! 627: more_than_1_byte: ! 628: ! 629: ; If all pixels in the left edge are altered, combine the first byte into the ! 630: ; whole byte count, because we can handle solid edge bytes faster as part of ! 631: ; the whole bytes. Ditto for the right edge. ! 632: ! 633: sub ecx,ecx ;edge whole-status accumulator ! 634: cmp al,-1 ;is left edge a whole byte or partial? ! 635: adc ecx,ecx ;ECX=1 if left edge partial, 0 if whole ! 636: sub ebx,ecx ;if left edge partial, deduct it from ! 637: ; the whole bytes count ! 638: mov ulLeftEdgeAdjust,ecx ;for skipping over the left edge if ! 639: ; it's partial when pointing to the ! 640: ; whole bytes ! 641: and ah,ah ;is right edge mask 0, meaning this ! 642: ; fill is only 1 byte wide? ! 643: jz short save_masks ;yes, no need to do anything ! 644: or ecx,40h ;assume there's a partial right edge ! 645: cmp ah,-1 ;is right edge a whole byte or partial? ! 646: jnz short save_masks ;partial ! 647: ;bit 1=0 if left edge partial, 1 whole ! 648: inc ebx ;if right edge whole, include it in the ! 649: ; whole bytes count ! 650: and ecx,not 40h ;there's no partial right edge ! 651: save_masks: ! 652: cmp ebx,1 ;do we have any whole bytes? ! 653: cmc ;CF set if whole byte count > 0 ! 654: adc ecx,ecx ;if any whole bytes, set whole bytes ! 655: ; bit in left/whole/right accumulator ! 656: rol cl,1 ;align the left/whole/right bits ! 657: mov ulLWRType,ecx ;save left/whole/right status ! 658: ! 659: mov byte ptr jLeftMask,al ;save left and right clip masks ! 660: mov byte ptr jRightMask,ah ! 661: mov culWholeBytesWidth,ebx ;save # of whole bytes ! 662: ! 663: ; Copy the rectangle in the specified direction. ! 664: ! 665: mov eax,icopydir ! 666: jmp SetUpForCopyDirection[eax*4] ! 667: ! 668: ! 669: ;***********************************************************************; ! 670: ; ! 671: ; The following routines set up to handle the four possible copy ! 672: ; directions. ! 673: ; ! 674: ;***********************************************************************; ! 675: ! 676: ! 677: ;-----------------------------------------------------------------------; ! 678: ; Set-up code for left-to-right, top-to-bottom copies. ! 679: ;-----------------------------------------------------------------------; ! 680: ! 681: align 4 ! 682: left_to_right_top_to_bottom: ! 683: ! 684: cld ;we'll copy left to right ! 685: ! 686: mov esi,pdsurf ! 687: mov eax,[esi].dsurf_lNextScan ! 688: mov ulNextScan,eax ;copy top to bottom ! 689: sub eax,culWholeBytesWidth ;offset from end of one whole byte scan ! 690: mov ulWholeScanDelta,eax ; to start of next ! 691: ! 692: mov esi,ulLWRType ;3-bit flag field for left, whole, and ! 693: ; right involvement in operation ! 694: or esi,LEFT_TO_RIGHT_FIELD_SET ;add left-to-right into the index ! 695: mov eax,MasterThreadTable[esi*4] ! 696: mov pCurrentThread,eax ;threading when no buffering is needed ! 697: mov edx,ulAdapterType ! 698: shl edx,ADAPTER_FIELD_SHIFT ! 699: or esi,edx ;factor adapter type into the index ! 700: mov eax,MasterThreadTableViaBuffer[esi*4] ! 701: mov pCurrentThreadViaBuffer,eax ;threading when buffering is needed ! 702: ! 703: mov ulCurrentJustification,JustifyTop ;copy top to bottom ! 704: ! 705: mov esi,prcldest ! 706: mov eax,[esi].yBottom ! 707: mov ulLastDestScan,eax ;end at bottom of dest copy rect ! 708: mov eax,[esi].yTop ! 709: mov ulCurrentDestScan,eax ;start at top of dest copy rect ! 710: mul ulNextScan ;offset in bitmap of top dest rect scan ! 711: mov edx,[esi].xLeft ! 712: shr edx,3 ;byte X address ! 713: add eax,edx ;offset in bitmap of first dest byte ! 714: mov ulLeftEdgeDest,eax ;that's where the left dest edge is ! 715: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next ! 716: ; byte, unless the left edge is a whole ! 717: ; byte and is thus part of the whole ! 718: ; bytes already ! 719: mov ulWholeBytesDest,eax ;where the whole dest bytes start ! 720: add eax,culWholeBytesWidth ;point to the right edge ! 721: mov ulRightEdgeDest,eax ;where the right dest edge starts ! 722: ! 723: mov esi,pptlsrc ! 724: mov eax,[esi].ptl_y ! 725: mov ulCurrentSrcScan,eax ;start at top of source copy rect ! 726: mul ulNextScan ;offset in bitmap of top dest rect scan ! 727: mov edx,[esi].ptl_x ! 728: shr edx,3 ;byte X address ! 729: add eax,edx ;offset in bitmap of first source byte ! 730: mov ulLeftEdgeSrc,eax ;that's where the left src edge is ! 731: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next ! 732: ; byte, unless the left edge is a whole ! 733: ; byte and is thus part of the whole ! 734: ; bytes already ! 735: mov ulWholeBytesSrc,eax ;where the src whole bytes start ! 736: add eax,culWholeBytesWidth ;point to the right edge ! 737: mov ulRightEdgeSrc,eax ;where the right src edge starts ! 738: ! 739: ; Branch to the appropriate top-to-bottom bank enumeration loop. ! 740: ! 741: mov eax,ulAdapterType ! 742: jmp TopToBottomLoopTable[eax*4] ! 743: ! 744: ! 745: ;-----------------------------------------------------------------------; ! 746: ; Set-up code for right-to-left, top-to-bottom copies. ! 747: ;-----------------------------------------------------------------------; ! 748: ! 749: align 4 ! 750: right_to_left_top_to_bottom: ! 751: ! 752: std ;we'll copy right to left ! 753: ! 754: mov esi,pdsurf ! 755: mov eax,[esi].dsurf_lNextScan ! 756: mov ulNextScan,eax ;copy top to bottom ! 757: add eax,culWholeBytesWidth ;offset from end of one whole byte scan ! 758: mov ulWholeScanDelta,eax ; to start of next, given that we're ! 759: ; copying one way and going scan-to- ! 760: ; scan the other way ! 761: mov esi,ulLWRType ;3-bit flag field for left, whole, and ! 762: ; right involvement in operation ! 763: ;leave left-to-right field cleared, so ! 764: ; we look up right-to-left entries ! 765: mov eax,MasterThreadTable[esi*4] ! 766: mov pCurrentThread,eax ;threading when no buffering is needed ! 767: mov edx,ulAdapterType ! 768: shl edx,ADAPTER_FIELD_SHIFT ! 769: or esi,edx ;factor adapter type into the index ! 770: mov eax,MasterThreadTableViaBuffer[esi*4] ! 771: mov pCurrentThreadViaBuffer,eax ;threading when buffering is needed ! 772: ! 773: mov ulCurrentJustification,JustifyTop ;copy top to bottom ! 774: ! 775: mov esi,prcldest ! 776: mov eax,[esi].yBottom ! 777: mov ulLastDestScan,eax ;end at bottom of dest copy rect ! 778: mov eax,[esi].yTop ! 779: mov ulCurrentDestScan,eax ;start at top of dest copy rect ! 780: mul ulNextScan ;offset in bitmap of top dest rect scan ! 781: mov edx,[esi].xLeft ! 782: shr edx,3 ;byte X address ! 783: add eax,edx ;offset in bitmap of first dest byte ! 784: mov ulLeftEdgeDest,eax ;that's where the left dest edge is ! 785: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next ! 786: ; byte, unless the left edge is a whole ! 787: ; byte and is thus part of the whole ! 788: ; bytes already ! 789: add eax,culWholeBytesWidth ;point to the right edge ! 790: mov ulRightEdgeDest,eax ;where the right dest edge starts ! 791: dec eax ;back up to the last whole byte ! 792: mov ulWholeBytesDest,eax ;where the whole dest bytes start ! 793: ! 794: mov esi,pptlsrc ! 795: mov eax,[esi].ptl_y ! 796: mov ulCurrentSrcScan,eax ;start at top of source copy rect ! 797: mul ulNextScan ;offset in bitmap of top dest rect scan ! 798: mov edx,[esi].ptl_x ! 799: shr edx,3 ;byte X address ! 800: add eax,edx ;offset in bitmap of first source byte ! 801: mov ulLeftEdgeSrc,eax ;that's where the left src edge is ! 802: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next ! 803: ; byte, unless the left edge is a whole ! 804: ; byte and is thus part of the whole ! 805: ; bytes already ! 806: add eax,culWholeBytesWidth ;point to the right edge ! 807: mov ulRightEdgeSrc,eax ;where the right src edge starts ! 808: dec eax ;back up to the last whole byte ! 809: mov ulWholeBytesSrc,eax ;where the src whole bytes start ! 810: ! 811: ; Branch to the appropriate top-to-bottom bank enumeration loop. ! 812: ! 813: mov eax,ulAdapterType ! 814: jmp TopToBottomLoopTable[eax*4] ! 815: ! 816: ! 817: ! 818: ;-----------------------------------------------------------------------; ! 819: ; Set-up code for left-to-right, bottom-to-top copies. ! 820: ;-----------------------------------------------------------------------; ! 821: ! 822: align 4 ! 823: left_to_right_bottom_to_top: ! 824: ! 825: cld ;we'll copy left to right ! 826: ! 827: mov edi,pdsurf ! 828: mov eax,[edi].dsurf_lNextScan ! 829: neg eax ! 830: mov ulNextScan,eax ;copy bottom to top ! 831: sub eax,culWholeBytesWidth ;offset from end of one whole byte scan ! 832: mov ulWholeScanDelta,eax ; to start of next, given that we're ! 833: ; copying one way and going scan-to- ! 834: ; scan the other way ! 835: mov esi,ulLWRType ;3-bit flag field for left, whole, and ! 836: ; right involvement in operation ! 837: or esi,LEFT_TO_RIGHT_FIELD_SET ;add left-to-right into the index ! 838: mov eax,MasterThreadTable[esi*4] ! 839: mov pCurrentThread,eax ;threading when no buffering is needed ! 840: mov edx,ulAdapterType ! 841: shl edx,ADAPTER_FIELD_SHIFT ! 842: or esi,edx ;factor adapter type into the index ! 843: mov eax,MasterThreadTableViaBuffer[esi*4] ! 844: mov pCurrentThreadViaBuffer,eax ;threading when buffering is needed ! 845: ! 846: mov ulCurrentJustification,JustifyBottom ;copy bottom to top ! 847: ! 848: mov esi,prcldest ! 849: mov edx,[esi].yTop ! 850: mov ulLastDestScan,edx ;end at top of dest copy rect ! 851: mov eax,[esi].yBottom ! 852: dec eax ;rectangle definition is non-inclusive, ! 853: ; so advance to first scan we'll copy ! 854: sub edx,eax ;-(offset from rect top to bottom) ! 855: push edx ;remember for use with source ! 856: mov ulCurrentDestScan,eax ;start at bottom of dest copy rect ! 857: mul [edi].dsurf_lNextScan ;offset in bitmap of bottom dest rect ! 858: ; scan (first scan to which to copy) ! 859: mov edx,[esi].xLeft ! 860: shr edx,3 ;byte X address ! 861: add eax,edx ;offset in bitmap of first dest byte ! 862: mov ulLeftEdgeDest,eax ;that's where the left dest edge is ! 863: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next ! 864: ; byte, unless the left edge is a whole ! 865: ; byte and is thus part of the whole ! 866: ; bytes already ! 867: mov ulWholeBytesDest,eax ;where the whole dest bytes start ! 868: add eax,culWholeBytesWidth ;point to the right edge ! 869: mov ulRightEdgeDest,eax ;where the right dest edge starts ! 870: ! 871: mov esi,pptlsrc ! 872: mov eax,[esi].ptl_y ! 873: pop edx ;retrieve -(offset from top to bottom) ! 874: sub eax,edx ;advance to bottom of source rect ! 875: ; (inclusive; this is first scan from ! 876: ; which to copy) ! 877: mov ulCurrentSrcScan,eax ;start at bottom of source copy rect ! 878: mul [edi].dsurf_lNextScan ;offset in bitmap of bottom dest rect ! 879: ; scan ! 880: mov edx,[esi].ptl_x ! 881: shr edx,3 ;byte X address ! 882: add eax,edx ;offset in bitmap of first source byte ! 883: mov ulLeftEdgeSrc,eax ;that's where the left src edge is ! 884: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next ! 885: ; byte, unless the left edge is a whole ! 886: ; byte and is thus part of the whole ! 887: ; bytes already ! 888: mov ulWholeBytesSrc,eax ;where the src whole bytes start ! 889: add eax,culWholeBytesWidth ;point to the right edge ! 890: mov ulRightEdgeSrc,eax ;where the right src edge starts ! 891: ! 892: ; Branch to the appropriate bottom-to-top bank enumeration loop. ! 893: ! 894: mov eax,ulAdapterType ! 895: jmp BottomToTopLoopTable[eax*4] ! 896: ! 897: ! 898: ;-----------------------------------------------------------------------; ! 899: ; Set-up code for right-to-left, bottom-to-top copies. ! 900: ;-----------------------------------------------------------------------; ! 901: ! 902: align 4 ! 903: right_to_left_bottom_to_top: ! 904: ! 905: std ;we'll copy right to left ! 906: ! 907: mov edi,pdsurf ! 908: mov eax,[edi].dsurf_lNextScan ! 909: neg eax ! 910: mov ulNextScan,eax ;copy bottom to top ! 911: add eax,culWholeBytesWidth ;offset from end of one whole byte scan ! 912: mov ulWholeScanDelta,eax ; to start of next ! 913: mov esi,ulLWRType ;3-bit flag field for left, whole, and ! 914: ; right involvement in operation ! 915: ;leave left-to-right field cleared, so ! 916: ; we look up right-to-left entries ! 917: mov eax,MasterThreadTable[esi*4] ! 918: mov pCurrentThread,eax ;threading when no buffering is needed ! 919: mov edx,ulAdapterType ! 920: shl edx,ADAPTER_FIELD_SHIFT ! 921: or esi,edx ;factor adapter type into the index ! 922: mov eax,MasterThreadTableViaBuffer[esi*4] ! 923: mov pCurrentThreadViaBuffer,eax ;threading when buffering is needed ! 924: ! 925: mov ulCurrentJustification,JustifyBottom ;copy bottom to top ! 926: ! 927: mov esi,prcldest ! 928: mov edx,[esi].yTop ! 929: mov ulLastDestScan,edx ;end at top of dest copy rect ! 930: mov eax,[esi].yBottom ! 931: dec eax ;rectangle definition is non-inclusive, ! 932: ; so advance to first scan we'll copy ! 933: sub edx,eax ;-(offset from rect top to bottom) ! 934: push edx ;remember for use with source ! 935: mov ulCurrentDestScan,eax ;start at bottom of dest copy rect ! 936: mul [edi].dsurf_lNextScan ;offset in bitmap of bottom dest rect ! 937: ; scan (first scan to which to copy) ! 938: mov edx,[esi].xLeft ! 939: shr edx,3 ;byte X address ! 940: add eax,edx ! 941: mov ulLeftEdgeDest,eax ;that's where the left dest edge is ! 942: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next ! 943: ; byte, unless the left edge is a whole ! 944: ; byte and is thus part of the whole ! 945: ; bytes already ! 946: add eax,culWholeBytesWidth ;point to the right edge ! 947: mov ulRightEdgeDest,eax ;where the right dest edge starts ! 948: dec eax ;back up to the last whole byte ! 949: mov ulWholeBytesDest,eax ;where the whole dest bytes start ! 950: ! 951: mov esi,pptlsrc ! 952: mov eax,[esi].ptl_y ! 953: pop edx ;retrieve -(offset from top to bottom) ! 954: sub eax,edx ;advance to bottom of source rect ! 955: ; (inclusive; this is first scan from ! 956: ; which to copy) ! 957: mov ulCurrentSrcScan,eax ;start at bottom of source copy rect ! 958: mul [edi].dsurf_lNextScan ;offset in bitmap of bottom dest rect ! 959: ; scan ! 960: mov edx,[esi].ptl_x ! 961: shr edx,3 ;byte X address ! 962: add eax,edx ;offset in bitmap of first source byte ! 963: mov ulLeftEdgeSrc,eax ;that's where the left src edge is ! 964: add eax,ulLeftEdgeAdjust ;the whole bytes start at the next ! 965: ; byte, unless the left edge is a whole ! 966: ; byte and is thus part of the whole ! 967: ; bytes already ! 968: add eax,culWholeBytesWidth ;point to the right edge ! 969: mov ulRightEdgeSrc,eax ;where the right src edge starts ! 970: dec eax ;back up to the last whole byte ! 971: mov ulWholeBytesSrc,eax ;where the src whole bytes start ! 972: ! 973: ; Branch to the appropriate bottom-to-top bank enumeration loop. ! 974: ! 975: mov eax,ulAdapterType ! 976: jmp BottomToTopLoopTable[eax*4] ! 977: ! 978: ! 979: ;***********************************************************************; ! 980: ; ! 981: ; The following routines are the banking loops. ! 982: ; ! 983: ;***********************************************************************; ! 984: ! 985: ! 986: ;-----------------------------------------------------------------------; ! 987: ; Banking for 2 R/W and unbanked adapters, top to bottom. ! 988: ;-----------------------------------------------------------------------; ! 989: align 4 ! 990: top_to_bottom_2RW: ! 991: ! 992: ; We're going top to bottom. Map in the source and dest, top-justified. ! 993: ! 994: mov ebx,pdsurf ! 995: mov edx,ulCurrentSrcScan ! 996: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is source top less than ! 997: ; current source bank? ! 998: jl short top_2RW_map_init_src_bank ;yes, map in proper bank ! 999: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;source top greater than ! 1000: ; current source bank? ! 1001: jl short top_2RW_init_src_bank_mapped ! 1002: ;no, proper bank already mapped ! 1003: top_2RW_map_init_src_bank: ! 1004: ! 1005: ; Map bank containing the top source scan line into source window. ! 1006: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1007: ! 1008: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1009: <ebx,edx,JustifyTop,MapSourceBank> ! 1010: ! 1011: top_2RW_init_src_bank_mapped: ! 1012: ! 1013: mov edx,ulCurrentDestScan ! 1014: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is dest top less than ! 1015: ; current dest bank? ! 1016: jl short top_2RW_map_init_dest_bank ;yes, map in proper bank ! 1017: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest top greater than ! 1018: ; current dest bank? ! 1019: jl short top_2RW_init_dest_bank_mapped ! 1020: ;no, proper bank already mapped ! 1021: top_2RW_map_init_dest_bank: ! 1022: ! 1023: ; Map bank containing the top dest scan line into source window. ! 1024: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1025: ! 1026: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1027: <ebx,edx,JustifyTop,MapDestBank> ! 1028: ! 1029: top_2RW_init_dest_bank_mapped: ! 1030: ! 1031: ; Bank-by-bank top-to-bottom copy loop. ! 1032: ! 1033: top_2RW_bank_loop: ! 1034: ! 1035: ; Decide how far we can go before we run out of bank or rectangle to copy. ! 1036: ! 1037: mov edx,ulLastDestScan ! 1038: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ! 1039: jl short @F ;copy rectangle bottom is in this bank ! 1040: mov edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest extends to end ! 1041: ; of bank, at least ! 1042: @@: ! 1043: sub edx,ulCurrentDestScan ;# of scans we can and want to do in ! 1044: ; the dest bank ! 1045: mov eax,[ebx].dsurf_rcl2WindowClipS.yBottom ! 1046: sub eax,ulCurrentSrcScan ;# of scans we can do in the src bank ! 1047: ! 1048: cmp edx,eax ! 1049: jb short @F ;source bank isn't limiting ! 1050: mov edx,eax ;source bank is limiting ! 1051: @@: ! 1052: mov ulBlockHeight,edx ;# of scans we'll do in this bank ! 1053: ! 1054: ; We're ready to copy this block. ! 1055: ! 1056: THREAD_AND_START ! 1057: ! 1058: ; Any more scans to copy? ! 1059: ! 1060: mov eax,ulCurrentDestScan ! 1061: mov esi,ulBlockHeight ! 1062: add eax,esi ;we've copied to dest up to here ! 1063: cmp ulLastDestScan,eax ;are we at the dest rect bottom? ! 1064: jz short top_2RW_done ;yes, we're done ! 1065: mov ulCurrentDestScan,eax ! 1066: ! 1067: ; Now advance either or both banks, as needed. ! 1068: ! 1069: mov ebx,pdsurf ! 1070: cmp eax,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest scan greater than ! 1071: ; current dest bank? ! 1072: jl short top_2RW_dest_bank_mapped ;no, proper bank still mapped ! 1073: ! 1074: ; Map bank containing the current dest scan line into source window. ! 1075: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1076: ! 1077: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1078: <ebx,eax,JustifyTop,MapDestBank> ! 1079: ! 1080: top_2RW_dest_bank_mapped: ! 1081: ! 1082: add esi,ulCurrentSrcScan ;we've copied from source up to here ! 1083: mov ulCurrentSrcScan,esi ! 1084: ! 1085: cmp esi,[ebx].dsurf_rcl2WindowClipS.yBottom ;src scan greater than ! 1086: ; current src bank? ! 1087: jl short top_2RW_src_bank_mapped ;no, proper bank still mapped ! 1088: ! 1089: ; Map bank containing the current source scan line into source window. ! 1090: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1091: ! 1092: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1093: <ebx,esi,JustifyTop,MapSourceBank> ! 1094: ! 1095: top_2RW_src_bank_mapped: ! 1096: ! 1097: jmp top_2RW_bank_loop ! 1098: ! 1099: top_2RW_done: ! 1100: PLAIN_RET ! 1101: ! 1102: ! 1103: ;-----------------------------------------------------------------------; ! 1104: ; Banking for 2 R/W and unbanked adapters, bottom to top. ! 1105: ;-----------------------------------------------------------------------; ! 1106: align 4 ! 1107: bottom_to_top_2RW: ! 1108: ! 1109: ; We're going bottom to top. Map in the source and dest, bottom-justified. ! 1110: ! 1111: mov ebx,pdsurf ! 1112: mov edx,ulCurrentSrcScan ! 1113: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is source bottom less than ! 1114: ; current source bank? ! 1115: jl short bot_2RW_map_init_src_bank ;yes, map in proper bank ! 1116: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;source bottom greater ! 1117: ; than current src bank? ! 1118: jl short bot_2RW_init_src_bank_mapped ! 1119: ;no, proper bank already mapped ! 1120: bot_2RW_map_init_src_bank: ! 1121: ! 1122: ; Map bank containing the bottom source scan line into source window. ! 1123: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1124: ! 1125: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1126: <ebx,edx,JustifyBottom,MapSourceBank> ! 1127: ! 1128: bot_2RW_init_src_bank_mapped: ! 1129: ! 1130: mov edx,ulCurrentDestScan ! 1131: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is dest bottom less than ! 1132: ; current dest bank? ! 1133: jl short bot_2RW_map_init_dest_bank ;yes, map in proper bank ! 1134: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest bottom greater ! 1135: ; than current dst bank? ! 1136: jl short bot_2RW_init_dest_bank_mapped ! 1137: ;no, proper bank already mapped ! 1138: bot_2RW_map_init_dest_bank: ! 1139: ! 1140: ; Map bank containing the bottom dest scan line into source window. ! 1141: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1142: ! 1143: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1144: <ebx,edx,JustifyBottom,MapDestBank> ! 1145: ! 1146: bot_2RW_init_dest_bank_mapped: ! 1147: ! 1148: ; Bank-by-bank bottom-to-top copy loop. ! 1149: ! 1150: bot_2RW_bank_loop: ! 1151: ! 1152: ; Decide how far we can go before we run out of bank or rectangle to copy. ! 1153: ! 1154: mov edx,ulLastDestScan ! 1155: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ! 1156: jg short @F ;copy rectangle top is in this bank ! 1157: mov edx,[ebx].dsurf_rcl2WindowClipD.yTop ;dest extends to end ! 1158: ; of bank, at least ! 1159: @@: ! 1160: neg edx ! 1161: add edx,ulCurrentDestScan ;# of scans we can and want to do in ! 1162: inc edx ; the dest bank ! 1163: ! 1164: mov eax,ulCurrentSrcScan ! 1165: sub eax,[ebx].dsurf_rcl2WindowClipS.yTop ! 1166: inc eax ;# of scans we can do in the src bank ! 1167: ! 1168: cmp edx,eax ! 1169: jb short @F ;source bank isn't limiting ! 1170: mov edx,eax ;source bank is limiting ! 1171: @@: ! 1172: mov ulBlockHeight,edx ;# of scans we'll do in this bank ! 1173: ! 1174: ; We're ready to copy this block. ! 1175: ! 1176: THREAD_AND_START ! 1177: ! 1178: ; Any more scans to copy? ! 1179: ! 1180: mov eax,ulCurrentDestScan ! 1181: mov esi,ulBlockHeight ! 1182: sub eax,esi ;we've copied to dest up to here ! 1183: cmp ulLastDestScan,eax ;are we past the dest rect top? ! 1184: jg short bot_2RW_done ;yes, we're done ! 1185: mov ulCurrentDestScan,eax ! 1186: ! 1187: ; Now advance either or both banks, as needed. ! 1188: ! 1189: mov ebx,pdsurf ! 1190: cmp eax,[ebx].dsurf_rcl2WindowClipD.yTop ;dest scan less than ! 1191: ; current dest bank? ! 1192: jge short bot_2RW_dest_bank_mapped ;no, proper bank still mapped ! 1193: ! 1194: ; Map bank containing the current dest scan line into source window. ! 1195: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1196: ! 1197: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1198: <ebx,eax,JustifyBottom,MapDestBank> ! 1199: ! 1200: bot_2RW_dest_bank_mapped: ! 1201: ! 1202: mov eax,ulCurrentSrcScan ! 1203: sub eax,esi ;we've copied from source up to here ! 1204: mov ulCurrentSrcScan,eax ! 1205: ! 1206: cmp eax,[ebx].dsurf_rcl2WindowClipS.yTop ;src scan less than ! 1207: ; current src bank? ! 1208: jge short bot_2RW_src_bank_mapped ;no, proper bank still mapped ! 1209: ! 1210: ; Map bank containing the current source scan line into source window. ! 1211: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1212: ! 1213: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1214: <ebx,eax,JustifyBottom,MapSourceBank> ! 1215: ! 1216: bot_2RW_src_bank_mapped: ! 1217: ! 1218: jmp bot_2RW_bank_loop ! 1219: ! 1220: bot_2RW_done: ! 1221: PLAIN_RET ! 1222: ! 1223: ! 1224: ;-----------------------------------------------------------------------; ! 1225: ; Banking for 1R/1W adapters, top to bottom. ! 1226: ;-----------------------------------------------------------------------; ! 1227: align 4 ! 1228: top_to_bottom_1R1W: ! 1229: ! 1230: ; We're going top to bottom. Map in the source and dest, top-justified. ! 1231: ! 1232: mov ebx,pdsurf ! 1233: mov edx,ulCurrentSrcScan ! 1234: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is source top less than ! 1235: ; current source bank? ! 1236: jl short top_1R1W_map_init_src_bank ;yes, map in proper bank ! 1237: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;source top greater than ! 1238: ; current source bank? ! 1239: jl short top_1R1W_init_src_bank_mapped ! 1240: ;no, proper bank already mapped ! 1241: top_1R1W_map_init_src_bank: ! 1242: ! 1243: ; Map bank containing the top source scan line into source window. ! 1244: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1245: ! 1246: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1247: <ebx,edx,JustifyTop,MapSourceBank> ! 1248: ! 1249: top_1R1W_init_src_bank_mapped: ! 1250: ! 1251: mov edx,ulCurrentDestScan ! 1252: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is dest top less than ! 1253: ; current dest bank? ! 1254: jl short top_1R1W_map_init_dest_bank ;yes, map in proper bank ! 1255: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest top greater than ! 1256: ; current dest bank? ! 1257: jl short top_1R1W_init_dest_bank_mapped ! 1258: ;no, proper bank already mapped ! 1259: top_1R1W_map_init_dest_bank: ! 1260: ! 1261: ; Map bank containing the top dest scan line into source window. ! 1262: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1263: ! 1264: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1265: <ebx,edx,JustifyTop,MapDestBank> ! 1266: ! 1267: top_1R1W_init_dest_bank_mapped: ! 1268: ! 1269: ; Bank-by-bank top-to-bottom copy loop. ! 1270: ! 1271: top_1R1W_bank_loop: ! 1272: ! 1273: ; Decide how far we can go before we run out of bank or rectangle to copy. ! 1274: ! 1275: mov edx,ulLastDestScan ! 1276: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ! 1277: jl short @F ;copy rectangle bottom is in this bank ! 1278: mov edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest extends to end ! 1279: ; of bank, at least ! 1280: @@: ! 1281: sub edx,ulCurrentDestScan ;# of scans we can and want to do in ! 1282: ; the dest bank ! 1283: mov eax,[ebx].dsurf_rcl2WindowClipS.yBottom ! 1284: sub eax,ulCurrentSrcScan ;# of scans we can do in the src bank ! 1285: ! 1286: cmp edx,eax ! 1287: jb short @F ;source bank isn't limiting ! 1288: mov edx,eax ;source bank is limiting ! 1289: @@: ! 1290: mov ulBlockHeight,edx ;# of scans we'll do in this bank ! 1291: ! 1292: ; We're ready to copy this block. ! 1293: ; Select different threading, depending on whether the source and destination ! 1294: ; are currently in the same bank; we can do edges faster if they are. ! 1295: ! 1296: mov eax,[ebx].dsurf_ulWindowBank ! 1297: cmp eax,[ebx].dsurf_ulWindowBank[4] ! 1298: jz short top_1R1W_copy_same_bank ! 1299: ! 1300: ; Source and dest are currently in different banks, must go through temp buffer. ! 1301: ! 1302: THREAD_AND_START pCurrentThreadViaBuffer,top_1R1W_check_more_scans ! 1303: ! 1304: ; Source and dest are currently in the same bank. ! 1305: ! 1306: align 4 ! 1307: top_1R1W_copy_same_bank: ! 1308: THREAD_AND_START ! 1309: ! 1310: ; Any more scans to copy? ! 1311: ! 1312: top_1R1W_check_more_scans: ! 1313: ! 1314: mov eax,ulCurrentDestScan ! 1315: mov esi,ulBlockHeight ! 1316: add eax,esi ;we've copied to dest up to here ! 1317: cmp ulLastDestScan,eax ;are we at the dest rect bottom? ! 1318: jz short top_1R1W_done ;yes, we're done ! 1319: mov ulCurrentDestScan,eax ! 1320: ! 1321: ; Now advance either or both banks, as needed. ! 1322: ! 1323: mov ebx,pdsurf ! 1324: cmp eax,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest scan greater than ! 1325: ; current dest bank? ! 1326: jl short top_1R1W_dest_bank_mapped ;no, proper bank still mapped ! 1327: ! 1328: ; Map bank containing the current dest scan line into source window. ! 1329: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1330: ! 1331: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1332: <ebx,eax,JustifyTop,MapDestBank> ! 1333: ! 1334: top_1R1W_dest_bank_mapped: ! 1335: ! 1336: add esi,ulCurrentSrcScan ;we've copied from source up to here ! 1337: mov ulCurrentSrcScan,esi ! 1338: ! 1339: cmp esi,[ebx].dsurf_rcl2WindowClipS.yBottom ;src scan greater than ! 1340: ; current src bank? ! 1341: jl short top_1R1W_src_bank_mapped ;no, proper bank still mapped ! 1342: ! 1343: ; Map bank containing the current source scan line into source window. ! 1344: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1345: ! 1346: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1347: <ebx,esi,JustifyTop,MapSourceBank> ! 1348: ! 1349: top_1R1W_src_bank_mapped: ! 1350: ! 1351: jmp top_1R1W_bank_loop ! 1352: ! 1353: top_1R1W_done: ! 1354: PLAIN_RET ! 1355: ! 1356: ! 1357: ;-----------------------------------------------------------------------; ! 1358: ; Banking for 1R/1W adapters, bottom to top. ! 1359: ;-----------------------------------------------------------------------; ! 1360: align 4 ! 1361: bottom_to_top_1R1W: ! 1362: ! 1363: ; We're going bottom to top. Map in the source and dest, bottom-justified. ! 1364: ! 1365: mov ebx,pdsurf ! 1366: mov edx,ulCurrentSrcScan ! 1367: cmp edx,[ebx].dsurf_rcl2WindowClipS.yTop ;is source bottom less than ! 1368: ; current source bank? ! 1369: jl short bot_1R1W_map_init_src_bank ;yes, map in proper bank ! 1370: cmp edx,[ebx].dsurf_rcl2WindowClipS.yBottom ;source bottom greater ! 1371: ; than current src bank? ! 1372: jl short bot_1R1W_init_src_bank_mapped ! 1373: ;no, proper bank already mapped ! 1374: bot_1R1W_map_init_src_bank: ! 1375: ! 1376: ; Map bank containing the bottom source scan line into source window. ! 1377: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1378: ! 1379: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1380: <ebx,edx,JustifyBottom,MapSourceBank> ! 1381: ! 1382: bot_1R1W_init_src_bank_mapped: ! 1383: ! 1384: mov edx,ulCurrentDestScan ! 1385: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ;is dest bottom less than ! 1386: ; current dest bank? ! 1387: jl short bot_1R1W_map_init_dest_bank ;yes, map in proper bank ! 1388: cmp edx,[ebx].dsurf_rcl2WindowClipD.yBottom ;dest bottom greater ! 1389: ; than current dst bank? ! 1390: jl short bot_1R1W_init_dest_bank_mapped ! 1391: ;no, proper bank already mapped ! 1392: bot_1R1W_map_init_dest_bank: ! 1393: ! 1394: ; Map bank containing the bottom dest scan line into source window. ! 1395: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1396: ! 1397: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1398: <ebx,edx,JustifyBottom,MapDestBank> ! 1399: ! 1400: bot_1R1W_init_dest_bank_mapped: ! 1401: ! 1402: ; Bank-by-bank bottom-to-top copy loop. ! 1403: ! 1404: bot_1R1W_bank_loop: ! 1405: ! 1406: ; Decide how far we can go before we run out of bank or rectangle to copy. ! 1407: ! 1408: mov edx,ulLastDestScan ! 1409: cmp edx,[ebx].dsurf_rcl2WindowClipD.yTop ! 1410: jg short @F ;copy rectangle top is in this bank ! 1411: mov edx,[ebx].dsurf_rcl2WindowClipD.yTop ;dest extends to end ! 1412: ; of bank, at least ! 1413: @@: ! 1414: neg edx ! 1415: add edx,ulCurrentDestScan ;# of scans we can and want to do in ! 1416: inc edx ; the dest bank ! 1417: ! 1418: mov eax,ulCurrentSrcScan ! 1419: sub eax,[ebx].dsurf_rcl2WindowClipS.yTop ! 1420: inc eax ;# of scans we can do in the src bank ! 1421: ! 1422: cmp edx,eax ! 1423: jb short @F ;source bank isn't limiting ! 1424: mov edx,eax ;source bank is limiting ! 1425: @@: ! 1426: mov ulBlockHeight,edx ;# of scans we'll do in this bank ! 1427: ! 1428: ; We're ready to copy this block. ! 1429: ; Select different threading, depending on whether the source and destination ! 1430: ; are currently in the same bank; we can do edges faster if they are. ! 1431: ! 1432: mov al,byte ptr [ebx].dsurf_ulWindowBank ! 1433: cmp al,byte ptr [ebx].dsurf_ulWindowBank[4] ! 1434: jz short bot_1R1W_copy_same_bank ! 1435: ! 1436: ; Source and dest are currently in different banks, must go through temp buffer. ! 1437: ! 1438: THREAD_AND_START pCurrentThreadViaBuffer,bot_1R1W_check_more_scans ! 1439: ! 1440: ; Source and dest are currently in the same bank. ! 1441: ! 1442: align 4 ! 1443: bot_1R1W_copy_same_bank: ! 1444: THREAD_AND_START ! 1445: ! 1446: ; Any more scans to copy? ! 1447: ! 1448: align 4 ! 1449: bot_1R1W_check_more_scans: ! 1450: ! 1451: mov eax,ulCurrentDestScan ! 1452: mov esi,ulBlockHeight ! 1453: sub eax,esi ;we've copied to dest up to here ! 1454: cmp ulLastDestScan,eax ;are we past the dest rect top? ! 1455: jg short bot_1R1W_done ;yes, we're done ! 1456: mov ulCurrentDestScan,eax ! 1457: ! 1458: ; Now advance either or both banks, as needed. ! 1459: ! 1460: mov ebx,pdsurf ! 1461: cmp eax,[ebx].dsurf_rcl2WindowClipD.yTop ;dest scan less than ! 1462: ; current dest bank? ! 1463: jge short bot_1R1W_dest_bank_mapped ;no, proper bank still mapped ! 1464: ! 1465: ; Map bank containing the current dest scan line into source window. ! 1466: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1467: ! 1468: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1469: <ebx,eax,JustifyBottom,MapDestBank> ! 1470: ! 1471: bot_1R1W_dest_bank_mapped: ! 1472: ! 1473: mov eax,ulCurrentSrcScan ! 1474: sub eax,esi ;we've copied from source up to here ! 1475: mov ulCurrentSrcScan,eax ! 1476: ! 1477: cmp eax,[ebx].dsurf_rcl2WindowClipS.yTop ;src scan less than ! 1478: ; current src bank? ! 1479: jge short bot_1R1W_src_bank_mapped ;no, proper bank still mapped ! 1480: ! 1481: ; Map bank containing the current source scan line into source window. ! 1482: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1483: ! 1484: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 1485: <ebx,eax,JustifyBottom,MapSourceBank> ! 1486: ! 1487: bot_1R1W_src_bank_mapped: ! 1488: ! 1489: jmp bot_1R1W_bank_loop ! 1490: ! 1491: bot_1R1W_done: ! 1492: PLAIN_RET ! 1493: ! 1494: ! 1495: ;-----------------------------------------------------------------------; ! 1496: ; Banking for 1 R/W adapters, top to bottom. ! 1497: ;-----------------------------------------------------------------------; ! 1498: align 4 ! 1499: top_to_bottom_1RW: ! 1500: ! 1501: ; We're going top to bottom. Map in the dest, top-justified. ! 1502: ! 1503: mov ebx,pdsurf ! 1504: mov esi,ulCurrentDestScan ! 1505: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;is dest top less than ! 1506: ; current bank? ! 1507: jl short top_1RW_map_init_dest_bank ;yes, map in proper bank ! 1508: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest top greater than ! 1509: ; current bank? ! 1510: jl short top_1RW_init_dest_bank_mapped ! 1511: ;no, proper bank already mapped ! 1512: top_1RW_map_init_dest_bank: ! 1513: ! 1514: ; Map bank containing the top dest scan line into source window. ! 1515: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1516: ! 1517: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyTop> ! 1518: ! 1519: top_1RW_init_dest_bank_mapped: ! 1520: ! 1521: ; Bank-by-bank top-to-bottom copy loop. ! 1522: ! 1523: top_1RW_bank_loop: ! 1524: ! 1525: ; Decide how far we can go before we run out of bank or rectangle to copy. ! 1526: ! 1527: mov edi,ulLastDestScan ! 1528: cmp edi,[ebx].dsurf_rcl1WindowClip.yBottom ! 1529: jl short @F ;copy rectangle bottom is in this bank ! 1530: mov edi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest extends to end ! 1531: ; of bank, at least ! 1532: @@: ! 1533: sub edi,esi ;# of scans we can and want to do in the dest bank ! 1534: ! 1535: ; Now make sure source is mapped in. This is the condition the copying routines ! 1536: ; expect, and we need to figure out how far we can go in the source. ! 1537: ! 1538: sub edx,edx ;assume source and dest are in the same ! 1539: ; bank ! 1540: mov esi,ulCurrentSrcScan ! 1541: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;src scan less than ! 1542: ; current bank? ! 1543: jl short top_1RW_map_src_Bank ;yes, must map in ! 1544: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;src scan greater than ! 1545: ; current bank? ! 1546: jl short top_1RW_src_bank_mapped ;no, proper bank still mapped ! 1547: ! 1548: top_1RW_map_src_Bank: ! 1549: ! 1550: ; Map bank containing the current source scan line into source window. ! 1551: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1552: ! 1553: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyTop> ! 1554: ! 1555: mov edx,1 ;mark that source and dest are not in ! 1556: ; the same bank ! 1557: top_1RW_src_bank_mapped: ! 1558: ! 1559: mov eax,[ebx].dsurf_rcl1WindowClip.yBottom ! 1560: sub eax,esi ;# of scans we can do in the src bank ! 1561: ! 1562: cmp edi,eax ! 1563: jb short @F ;source bank isn't limiting ! 1564: mov edi,eax ;source bank is limiting ! 1565: @@: ! 1566: mov ulBlockHeight,edi ;# of scans we'll do in this bank ! 1567: ! 1568: ; We're ready to copy this block. ! 1569: ; Select different threading, depending on whether the source and destination ! 1570: ; are currently in the same bank; we can do edges faster if they are. ! 1571: ! 1572: and edx,edx ! 1573: jz short top_1RW_copy_same_bank ! 1574: ! 1575: ; Source and dest are currently in different banks, must go through temp buffer. ! 1576: ! 1577: THREAD_AND_START pCurrentThreadViaBuffer,top_1RW_check_more_scans ! 1578: ! 1579: ; Source and dest are currently in the same bank. ! 1580: ! 1581: align 4 ! 1582: top_1RW_copy_same_bank: ! 1583: THREAD_AND_START ! 1584: ! 1585: ; Any more scans to copy? ! 1586: ! 1587: top_1RW_check_more_scans: ! 1588: ! 1589: mov esi,ulCurrentDestScan ! 1590: mov edi,ulBlockHeight ! 1591: add esi,edi ;we've copied to dest up to here ! 1592: cmp ulLastDestScan,esi ;are we at the dest rect bottom? ! 1593: jz short top_1RW_done ;yes, we're done ! 1594: mov ulCurrentDestScan,esi ! 1595: ! 1596: ; Now make sure the dest bank is mapped in. ! 1597: ! 1598: mov ebx,pdsurf ! 1599: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;dest scan less than ! 1600: ; current bank? ! 1601: jl short top_1RW_map_dest_bank ;yes, map in dest bank ! 1602: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest scan greater than ! 1603: ; current bank? ! 1604: jl short top_1RW_dest_bank_mapped ;no, proper bank mapped ! 1605: ! 1606: top_1RW_map_dest_bank: ! 1607: ! 1608: ; Map bank containing the current dest scan line into source window. ! 1609: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1610: ! 1611: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyTop> ! 1612: ! 1613: top_1RW_dest_bank_mapped: ! 1614: ! 1615: add ulCurrentSrcScan,edi ;we've copied from source up to here ! 1616: ! 1617: jmp top_1RW_bank_loop ! 1618: ! 1619: top_1RW_done: ! 1620: PLAIN_RET ! 1621: ! 1622: ! 1623: ;-----------------------------------------------------------------------; ! 1624: ; Banking for 1 R/W adapters, bottom to top. ! 1625: ;-----------------------------------------------------------------------; ! 1626: align 4 ! 1627: bottom_to_top_1RW: ! 1628: ! 1629: ; We're going bottom to top. Map in the dest, bottom-justified. ! 1630: ! 1631: mov ebx,pdsurf ! 1632: mov esi,ulCurrentDestScan ! 1633: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;is dest bottom less than ! 1634: ; current dest bank? ! 1635: jl short bot_1RW_map_init_dest_bank ;yes, map in proper bank ! 1636: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest bottom greater ! 1637: ; than current dst bank? ! 1638: jl short bot_1RW_init_dest_bank_mapped ! 1639: ;no, proper bank already mapped ! 1640: bot_1RW_map_init_dest_bank: ! 1641: ! 1642: ; Map bank containing the bottom dest scan line into source window. ! 1643: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1644: ! 1645: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyBottom> ! 1646: ! 1647: bot_1RW_init_dest_bank_mapped: ! 1648: ! 1649: ; Bank-by-bank bottom-to-top copy loop. ! 1650: ! 1651: bot_1RW_bank_loop: ! 1652: ! 1653: ; Decide how far we can go before we run out of bank or rectangle to copy. ! 1654: ! 1655: mov edi,ulLastDestScan ! 1656: cmp edi,[ebx].dsurf_rcl1WindowClip.yTop ! 1657: jg short @F ;copy rectangle top is in this bank ! 1658: mov edi,[ebx].dsurf_rcl1WindowClip.yTop ;dest extends to end ! 1659: ; of bank, at least ! 1660: @@: ! 1661: neg edi ! 1662: add edi,esi ;# of scans we can and want to do in ! 1663: inc edi ; the dest bank ! 1664: ! 1665: ; Now make sure source is mapped in. This is the condition the copying routines ! 1666: ; expect, and we need to figure out how far we can go in the source. ! 1667: ! 1668: sub edx,edx ;assume source and dest are in the same ! 1669: ; bank ! 1670: mov esi,ulCurrentSrcScan ! 1671: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;src scan less than ! 1672: ; current bank? ! 1673: jl short bot_1RW_map_src_Bank ;yes, must map in ! 1674: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;src scan greater than ! 1675: ; current bank? ! 1676: jl short bot_1RW_src_bank_mapped ;no, proper bank still mapped ! 1677: ! 1678: bot_1RW_map_src_Bank: ! 1679: ! 1680: ; Map bank containing the current source scan line into source window. ! 1681: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1682: ! 1683: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyBottom> ! 1684: ! 1685: mov edx,1 ;mark that source and dest are not in ! 1686: ; the same bank ! 1687: bot_1RW_src_bank_mapped: ! 1688: ! 1689: sub esi,[ebx].dsurf_rcl1WindowClip.yTop ! 1690: inc esi ;# of scans we can do in the src bank ! 1691: ! 1692: cmp edi,esi ! 1693: jb short @F ;source bank isn't limiting ! 1694: mov edi,esi ;source bank is limiting ! 1695: @@: ! 1696: mov ulBlockHeight,edi ;# of scans we'll do in this bank ! 1697: ! 1698: ; We're ready to copy this block. ! 1699: ; Select different threading, depending on whether the source and destination ! 1700: ; are currently in the same bank; we can copy much faster if they are. ! 1701: ! 1702: and edx,edx ! 1703: jz short bot_1RW_copy_same_bank ! 1704: ! 1705: ; Source and dest are currently in different banks, must go through temp buffer. ! 1706: ! 1707: THREAD_AND_START pCurrentThreadViaBuffer,bot_1RW_check_more_scans ! 1708: ! 1709: ; Source and dest are currently in the same bank. ! 1710: ! 1711: align 4 ! 1712: bot_1RW_copy_same_bank: ! 1713: THREAD_AND_START ! 1714: ! 1715: ; Any more scans to copy? ! 1716: ! 1717: align 4 ! 1718: bot_1RW_check_more_scans: ! 1719: ! 1720: mov esi,ulCurrentDestScan ! 1721: mov edi,ulBlockHeight ! 1722: sub esi,edi ;we've copied to dest up to here ! 1723: cmp ulLastDestScan,esi ;are we past the dest rect top? ! 1724: jg short bot_1RW_done ;yes, we're done ! 1725: mov ulCurrentDestScan,esi ! 1726: ! 1727: ; Now make sure the dest bank is mapped in. ! 1728: ! 1729: mov ebx,pdsurf ! 1730: cmp esi,[ebx].dsurf_rcl1WindowClip.yTop ;dest scan less than ! 1731: ; current bank? ! 1732: jl short bot_1RW_map_dest_bank ;yes, map in dest bank ! 1733: cmp esi,[ebx].dsurf_rcl1WindowClip.yBottom ;dest scan greater than ! 1734: ; current bank? ! 1735: jl short bot_1RW_dest_bank_mapped ;no, proper bank mapped ! 1736: ! 1737: bot_1RW_map_dest_bank: ! 1738: ! 1739: ; Map bank containing the current dest scan line into source window. ! 1740: ; Note: EBX, ESI, and EDI preserved, according to C calling conventions. ! 1741: ! 1742: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>,<ebx,esi,JustifyBottom> ! 1743: ! 1744: bot_1RW_dest_bank_mapped: ! 1745: ! 1746: sub ulCurrentSrcScan,edi ;we've copied from source up to here ! 1747: ! 1748: jmp bot_1RW_bank_loop ! 1749: ! 1750: bot_1RW_done: ! 1751: PLAIN_RET ! 1752: ! 1753: ! 1754: ;***********************************************************************; ! 1755: ; ! 1756: ; The following routines are the low-level copying routines. They know ! 1757: ; almost nothing about banks (the routines that copy through a temp ! 1758: ; buffer know how to switch banks after filling the temp buffer, but ! 1759: ; that's it). Banking should be taken care of at a higher level. ! 1760: ; ! 1761: ;***********************************************************************; ! 1762: ! 1763: ;-----------------------------------------------------------------------; ! 1764: ; Copies a block of solid bytes from the source to the destination via the ! 1765: ; latches. Can only be used by 2 R/W or 1R/1W window banking, or by ! 1766: ; unbanked modes, or by 1 R/W adapters when the source and dest are in the ! 1767: ; same bank. 1 R/W adapters must go through an intermediate local buffer ! 1768: ; when the source and the destination aren't in the same bank. ! 1769: ; ! 1770: ; Input: ! 1771: ; Direction Flag set for desired direction of copy ! 1772: ; culWholeBytesWidth = # of bytes to copy across each scan line ! 1773: ; ulWholeScanDelta = distance to start of next scan from end of current ! 1774: ; ulBlockHeight = # of scans to copy ! 1775: ; ulWholeBytesSrc = start source offset in bitmap ! 1776: ; ulWholeBytesDest = start dest offset in bitmap ! 1777: ; ! 1778: ; Output: ! 1779: ; Advances ulWholeBytesSrc and ulWholeBytesDest to scan after last ! 1780: ; scan processed ! 1781: ;-----------------------------------------------------------------------; ! 1782: ! 1783: align 4 ! 1784: copy_whole_bytes: ! 1785: ! 1786: ; Set the bit mask to disable all bits, so we can copy through the latches. ! 1787: ! 1788: mov edx,VGA_BASE + GRAF_ADDR ! 1789: mov eax,(000h shl 8) + GRAF_BIT_MASK ! 1790: out dx,ax ! 1791: ! 1792: ; Set Map Mask to enable writes to all planes. ! 1793: ! 1794: mov dl,SEQ_DATA ! 1795: mov al,MM_ALL ! 1796: out dx,al ! 1797: ! 1798: ; Set up to copy the whole bytes via the latches. ! 1799: ! 1800: mov eax,culWholeBytesWidth ! 1801: mov ebx,ulBlockHeight ! 1802: mov edx,ulWholeScanDelta ! 1803: ! 1804: ; Calculate full start addresses. ! 1805: ! 1806: mov ecx,pdsurf ! 1807: mov esi,ulWholeBytesSrc ! 1808: add esi,[ecx].dsurf_pvBitmapStart2WindowS ! 1809: mov edi,ulWholeBytesDest ! 1810: add edi,[ecx].dsurf_pvBitmapStart2WindowD ! 1811: ! 1812: SET_UP_UNROLL_VARS ebx,ecx,ebx,pfnCopyWholeLatchesEntry, \ ! 1813: LOOP_UNROLL_SHIFT ! 1814: jmp ecx ;copy the whole bytes ! 1815: ! 1816: ;-----------------------------------------------------------------------; ! 1817: ; Table of unrolled whole latched loop entry points. ! 1818: ;-----------------------------------------------------------------------; ! 1819: ! 1820: UNROLL_LOOP_ENTRY_TABLE pfnCopyWholeLatchesEntry,WHOLE_LATCHES, \ ! 1821: LOOP_UNROLL_COUNT ! 1822: ! 1823: ;-----------------------------------------------------------------------; ! 1824: ; Unrolled loop for copying a block of whole bytes via the latches. ! 1825: ;-----------------------------------------------------------------------; ! 1826: ! 1827: COPY_WHOLE_LATCHES macro ENTRY_LABEL,ENTRY_INDEX ! 1828: &ENTRY_LABEL&ENTRY_INDEX&: ! 1829: mov ecx,eax ;# of whole bytes to copy ! 1830: rep movsb ;copy the bytes via the latches ! 1831: add esi,edx ;point to next source scan ! 1832: add edi,edx ;point to next dest scan ! 1833: endm ;-----------------------------------; ! 1834: ! 1835: ; EAX = # of bytes to copy ! 1836: ; EBX = count of unrolled loop iterations ! 1837: ; EDX = offset from end of one scan's fill to start of next ! 1838: ; ESI = source address to copy from ! 1839: ; EDI = target address to copy to ! 1840: ! 1841: align 4 ! 1842: whole_latches_loop: ! 1843: UNROLL_LOOP COPY_WHOLE_LATCHES,WHOLE_LATCHES,LOOP_UNROLL_COUNT ! 1844: dec ebx ! 1845: jnz whole_latches_loop ! 1846: ! 1847: ; Remember where we left off, for next time. ! 1848: ! 1849: mov ecx,pdsurf ! 1850: sub esi,[ecx].dsurf_pvBitmapStart2WindowS ! 1851: mov ulWholeBytesSrc,esi ! 1852: sub edi,[ecx].dsurf_pvBitmapStart2WindowD ! 1853: mov ulWholeBytesDest,edi ! 1854: ! 1855: PLAIN_RET ! 1856: ! 1857: ! 1858: ;-----------------------------------------------------------------------; ! 1859: ; Copies a block of solid bytes from the source to the destination via ! 1860: ; the temp buffer. This should only be used by 1 R/W adapters, and then ! 1861: ; only when the source and dest are in different banks. ! 1862: ; ! 1863: ; All relevant bytes are copied from the source to a temp buffer that's an ! 1864: ; image of the source first. Then, we copy each of the four planes for one scan ! 1865: ; line from the temp buffer to the screen before going on to the next scan line. ! 1866: ; It would be faster to do all scans in one plane, then all in the next, and so ! 1867: ; on, but that would give nasty color effects from pixels that were changed in ! 1868: ; some planes but not in others. A compromise would be to do several scans at a ! 1869: ; pop per plane, as is done with the edge bytes; however, given that there can ! 1870: ; be 128 (or more) bytes across a single whole-bytes scan, if we do 16 scan ! 1871: ; lines per chunk, we're going to be performing up to 128*4*16 accesses per ! 1872: ; chunk; at an assumed 1 microsecond per access, that's 8 millisecond per scan ! 1873: ; line, or about 1/2 of a frame time. We're definitely going to see flicker or ! 1874: ; sparkles from partially updated bytes at that point, in my opinion. Another ! 1875: ; alternative would be to dynamically adjust the number of scans processed at a ! 1876: ; pop per plane, depending on the copy width, with more scans copied for ! 1877: ; narrower widths. For all but very narrow copies, though, it seems to me that ! 1878: ; the actual copy time would far outweigh the time for the OUTs to switch ! 1879: ; planes, and the return for some rather complex code would be marginal. ! 1880: ; ! 1881: ; It would be nice if we copied bytes a word or dword at a time. However, it ! 1882: ; becomes rather complex handling fractional words or dwords, especially when ! 1883: ; copying right-to-left, so this is left for LATER. I haven't unrolled these ! 1884: ; loops because of the possibility of this further word/dword optimization; ! 1885: ; no point in fine-tuning sub-optimal code. ! 1886: ; ! 1887: ; Input: ! 1888: ; Direction Flag set for desired direction of copy ! 1889: ; culWholeBytesWidth = # of bytes to copy across each scan line ! 1890: ; ulWholeScanDelta = distance to start of next scan from end of current ! 1891: ; ulBlockHeight = # of scans to copy ! 1892: ; ulWholeBytesSrc = start source offset in bitmap ! 1893: ; ulWholeBytesDest = start dest offset in bitmap ! 1894: ; ppTempPlane0 = pointer to pointer to plane 0 storage in temp buffer ! 1895: ; ppTempPlane3 = pointer to pointer to plane 3 storage in temp buffer ! 1896: ; Expects the source bank to be mapped in; source bank is mapped in on ! 1897: ; exit ! 1898: ; ! 1899: ; Output: ! 1900: ; Advances ulWholeBytesSrc and ulWholeBytesDest to scan after last ! 1901: ; scan processed ! 1902: ;-----------------------------------------------------------------------; ! 1903: ! 1904: align 4 ! 1905: copy_whole_bytes_via_buffer: ! 1906: ! 1907: ; Calculate start source address from bitmap start address and offset within ! 1908: ; bitmap. ! 1909: ! 1910: mov ecx,pdsurf ! 1911: mov eax,ulWholeBytesSrc ! 1912: add eax,[ecx].dsurf_pvBitmapStart ! 1913: mov pSrcAddr,eax ! 1914: sub eax,[ecx].dsurf_pvStart ! 1915: mov ulOffsetInBank,eax ;will come in handy because we treat the ! 1916: ; temp buffer as an image of the current ! 1917: ; bank ! 1918: ! 1919: ; First, copy all the bytes into the temporary buffer. ! 1920: ! 1921: ; Leave the GC Index pointing to the Read Map. ! 1922: ! 1923: mov edx,VGA_BASE + GRAF_ADDR ! 1924: mov al,GRAF_READ_MAP ! 1925: out dx,al ! 1926: ! 1927: mov eax,3 ;start by copying plane 3 ! 1928: copy_whole_to_buffer_plane_loop: ! 1929: mov ebx,ulBlockHeight ;# of scans to copy ! 1930: mov esi,pSrcAddr ;source offset in screen ! 1931: mov edi,ppTempPlane0 ! 1932: mov edi,[edi+eax*4] ;pointer to current plane in temp buffer ! 1933: add edi,ulOffsetInBank ;dest for plane in temp buffer ! 1934: ! 1935: mov edx,VGA_BASE + GRAF_DATA ! 1936: out dx,al ;set Read Map to plane we're copying from. ! 1937: ! 1938: push eax ;remember plane index ! 1939: mov eax,ulWholeScanDelta ;offset to next scan ! 1940: mov edx,culWholeBytesWidth ;# of bytes per scan ! 1941: copy_whole_to_buffer_scan_loop: ! 1942: mov ecx,edx ;# of bytes per scan ! 1943: rep movsb ;copy the scan line to the temp buffer ! 1944: add esi,eax ;point to next source scan ! 1945: add edi,eax ;point to next dest scan ! 1946: ! 1947: dec ebx ;count down scan lines ! 1948: jnz copy_whole_to_buffer_scan_loop ! 1949: ! 1950: pop eax ;get back plane index ! 1951: dec eax ;count down planes ! 1952: jns copy_whole_to_buffer_plane_loop ! 1953: ! 1954: ; Remember where we left off, for next time. ! 1955: ! 1956: mov ebx,pdsurf ! 1957: sub esi,[ebx].dsurf_pvBitmapStart ! 1958: mov ulWholeBytesSrc,esi ! 1959: ! 1960: ! 1961: ; Now copy the temp buffer to the screen. ! 1962: ! 1963: ; Map in the destination bank, so we can read/write to it and let the Bit Mask ! 1964: ; work. ! 1965: ! 1966: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>, \ ! 1967: <ebx,ulCurrentDestScan,ulCurrentJustification> ! 1968: ! 1969: ; Calculate dest start address (if this is a 1 R/W adapter, we had to wait ! 1970: ; until now to calculate this, because the dest bank wasn't mapped earlier). ! 1971: ! 1972: mov eax,ulWholeBytesDest ! 1973: add eax,[ebx].dsurf_pvBitmapStart ! 1974: mov pDestAddr,eax ! 1975: ! 1976: ; Set the bit mask to enable all bits. ! 1977: ! 1978: mov edx,VGA_BASE + GRAF_ADDR ! 1979: mov eax,(0ffh shl 8) + GRAF_BIT_MASK ! 1980: out dx,ax ! 1981: ! 1982: mov dl,SEQ_DATA ;leave DX pointing to the SC Data reg ! 1983: ! 1984: ; Set up to copy the whole bytes from the buffer. ! 1985: ! 1986: mov eax,ulBlockHeight ;# of scans to copy ! 1987: mov culTempCount,eax ! 1988: ! 1989: copy_whole_from_buffer_scan_loop: ! 1990: ! 1991: mov ebx,ppTempPlane3 ;point to plane 3's temp buffer offset ! 1992: mov al,MM_C3 ;start by copying plane 3 ! 1993: ! 1994: copy_whole_from_buffer_plane_loop: ! 1995: ! 1996: ; Set Map Mask to enable writes to the plane we're copying. ! 1997: ! 1998: out dx,al ! 1999: ! 2000: ; Select the corresponding plane from the temp buffer. ! 2001: ! 2002: mov esi,[ebx] ;point to plane start in temp buffer ! 2003: add esi,ulOffsetInBank ;point to current scan start in temp buffer ! 2004: mov edi,pDestAddr ;point to destination start ! 2005: ! 2006: mov ecx,culWholeBytesWidth ;# of whole bytes to copy ! 2007: rep movsb ;copy the bytes from the buffer to the screen ! 2008: ! 2009: ; Do next plane, if any. ! 2010: ! 2011: sub ebx,4 ;point to next temp buffer plane ptr ! 2012: shr al,1 ;advance to next plane ! 2013: jnz copy_whole_from_buffer_plane_loop ! 2014: ! 2015: ; Remember where we left off, for next scan. ! 2016: ! 2017: add edi,ulWholeScanDelta ;point to next dest scan ! 2018: mov pDestAddr,edi ! 2019: mov eax,ulNextScan ! 2020: add ulOffsetInBank,eax ;next scan's start in temp buffer, ! 2021: ; relative to start of plane's storage ! 2022: ! 2023: ; Count down scan lines. ! 2024: ! 2025: dec culTempCount ! 2026: jnz copy_whole_from_buffer_scan_loop ! 2027: ! 2028: ; Remember where we left off, for next time. ! 2029: ! 2030: mov ebx,pdsurf ! 2031: sub edi,[ebx].dsurf_pvBitmapStart ! 2032: mov ulWholeBytesDest,edi ! 2033: ! 2034: ; Put back the original source bank. ! 2035: ! 2036: ptrCall <dword ptr [ebx].dsurf_pfnBankControl>, \ ! 2037: <ebx,ulCurrentSrcScan,ulCurrentJustification> ! 2038: ! 2039: PLAIN_RET ! 2040: ! 2041: ! 2042: ;-----------------------------------------------------------------------; ! 2043: ; Copies a strip of left edge bytes from the source to the destination, ! 2044: ; assuming both the source and the destination are both readable and ! 2045: ; writable. Can only be used by 2 R/W window banking, or by unbanked ! 2046: ; modes. 1 R/W and 1R/1W adapters must go through an intermediate local ! 2047: ; buffer when the source and dest are in different banks. Processes up to ! 2048: ; EDGE_CHUNK_SIZE bytes in each plane at a pop; more bytes might cause ! 2049: ; flicker. ! 2050: ; ! 2051: ; Input: ! 2052: ; ulNextScan = width of scan, in bytes ! 2053: ; ulBlockHeight = # of scans to copy ! 2054: ; ulLeftEdgeSrc = start source offset in bitmap ! 2055: ; ulLeftEdgeDest = start dest offset in bitmap ! 2056: ; jLeftMask = left edge clip mask ! 2057: ; ! 2058: ; Output: ! 2059: ; Advances ulLeftEdgeSrc and ulLeftEdgeDest to scan after last ! 2060: ; scan processed ! 2061: ;-----------------------------------------------------------------------; ! 2062: ! 2063: align 4 ! 2064: copy_left_edge: ! 2065: ! 2066: ; Calculate start source and dest addresses from bitmap start addresses and ! 2067: ; offsets within bitmap. ! 2068: ! 2069: mov ecx,pdsurf ! 2070: mov esi,ulLeftEdgeSrc ! 2071: add esi,[ecx].dsurf_pvBitmapStart2WindowS ! 2072: mov edi,ulLeftEdgeDest ! 2073: add edi,[ecx].dsurf_pvBitmapStart2WindowD ! 2074: ! 2075: ; Copy the edge. ! 2076: ! 2077: mov ah,byte ptr jLeftMask ;clip mask for this edge ! 2078: call copy_edge ! 2079: ! 2080: ; Remember where we left off, for next time. ! 2081: ! 2082: mov ecx,pdsurf ! 2083: sub esi,[ecx].dsurf_pvBitmapStart2WindowS ! 2084: mov ulLeftEdgeSrc,esi ! 2085: sub edi,[ecx].dsurf_pvBitmapStart2WindowD ! 2086: mov ulLeftEdgeDest,edi ! 2087: ! 2088: PLAIN_RET ! 2089: ! 2090: ! 2091: ;-----------------------------------------------------------------------; ! 2092: ; Copies a strip of right edge bytes from the source to the destination, ! 2093: ; assuming both the source and the destination are both readable and ! 2094: ; writable. Can only be used by 2 R/W window banking, or by unbanked ! 2095: ; modes. 1 R/W and 1R/1W adapters must go through an intermediate local ! 2096: ; buffer when the source and dest are in different banks. Processes up to ! 2097: ; EDGE_CHUNK_SIZE bytes in each plane at a pop; more bytes might cause ! 2098: ; flicker. ! 2099: ; ! 2100: ; Input: ! 2101: ; ulNextScan = width of scan, in bytes ! 2102: ; ulBlockHeight = # of scans to copy ! 2103: ; ulRightEdgeSrc = start source offset in bitmap ! 2104: ; ulRightEdgeDest = start dest offset in bitmap ! 2105: ; jRightMask = right edge clip mask ! 2106: ; ! 2107: ; Output: ! 2108: ; Advances ulRightEdgeSrc and ulRightEdgeDest to scan after last ! 2109: ; scan processed ! 2110: ;-----------------------------------------------------------------------; ! 2111: ! 2112: align 4 ! 2113: copy_right_edge: ! 2114: ! 2115: ; Calculate start source and dest addresses from bitmap start addresses and ! 2116: ; offsets within bitmap. ! 2117: ! 2118: mov ecx,pdsurf ! 2119: mov esi,ulRightEdgeSrc ! 2120: add esi,[ecx].dsurf_pvBitmapStart2WindowS ! 2121: mov edi,ulRightEdgeDest ! 2122: add edi,[ecx].dsurf_pvBitmapStart2WindowD ! 2123: ! 2124: ; Copy the edge. ! 2125: ! 2126: mov ah,byte ptr jRightMask ;clip mask for this edge ! 2127: call copy_edge ! 2128: ! 2129: ; Remember where we left off, for next time ! 2130: ! 2131: mov ecx,pdsurf ! 2132: sub esi,[ecx].dsurf_pvBitmapStart2WindowS ! 2133: mov ulRightEdgeSrc,esi ! 2134: sub edi,[ecx].dsurf_pvBitmapStart2WindowD ! 2135: mov ulRightEdgeDest,edi ! 2136: ! 2137: PLAIN_RET ! 2138: ! 2139: ! 2140: ;-----------------------------------------------------------------------; ! 2141: ; Copies an edge from the source to the destination on the screen. ! 2142: ; Entry: ! 2143: ; AH = bit mask setting for edge ! 2144: ; ESI = source address ! 2145: ; EDI = destination address ! 2146: ; ulBlockHeight = # of bytes to copy per plane ! 2147: ; ulNextScan = scan width ! 2148: ; Source readable, and destination readable and writable ! 2149: ; Exit: ! 2150: ; ESI = next source address ! 2151: ; EDI = next destination address ! 2152: ; ! 2153: ; Preserved: EBP ! 2154: ;-----------------------------------------------------------------------; ! 2155: ! 2156: align 4 ! 2157: copy_edge: ! 2158: mov pSrcAddr,esi ! 2159: mov pDestAddr,edi ! 2160: ! 2161: ; Set the clip mask for this edge. ! 2162: ! 2163: mov edx,VGA_BASE + GRAF_ADDR ! 2164: mov al,GRAF_BIT_MASK ! 2165: out dx,ax ! 2166: ! 2167: ; Leave the GC Index pointing to the Read Map. ! 2168: ! 2169: mov al,GRAF_READ_MAP ! 2170: out dx,al ! 2171: ! 2172: mov ecx,offset copy_edge_rw_full_chunk ! 2173: ;entry point into unrolled loop to copy first ! 2174: ; chunk, assuming it's a full chunk ! 2175: mov ebx,ulBlockHeight ! 2176: ! 2177: ; Copy the edge in a series of chunks. ! 2178: ! 2179: copy_edge_chunk_loop: ! 2180: ! 2181: sub ebx,EDGE_CHUNK_SIZE ;scans remaining after this chunk, assuming ! 2182: ; a full chunk ! 2183: jge short @F ;do a full chunk ! 2184: add ebx,EDGE_CHUNK_SIZE ;not a full chunk; process all remaining ! 2185: ; scans ! 2186: mov ecx,pfnCopyEdgeRWEntry[-4][ebx*4] ! 2187: ;entry point into unrolled loop to copy desired ! 2188: ; chunk size ! 2189: sub ebx,ebx ;no scans after this ! 2190: @@: ! 2191: push ebx ;remember remaining scan count ! 2192: ! 2193: mov ah,MM_C3 ;start by copying plane 3 ! 2194: mov ebx,ulNextScan ! 2195: ! 2196: copy_edge_plane_loop: ! 2197: ! 2198: ; Set Map Mask to enable writes to plane we're copying. ! 2199: ! 2200: mov al,ah ! 2201: mov dl,SEQ_DATA ! 2202: out dx,al ! 2203: ! 2204: ; Set Read Map to same plane. ! 2205: ! 2206: shr al,1 ;map plane into ReadMask ! 2207: cmp al,100b ;set Carry if not C3 (plane 3) ! 2208: adc al,-1 ;sub 1 only if C3 ! 2209: mov dl,GRAF_DATA ! 2210: out dx,al ! 2211: ! 2212: mov esi,pSrcAddr ! 2213: mov edi,pDestAddr ! 2214: ! 2215: jmp ecx ;copy the left edge ! 2216: ! 2217: ! 2218: ;-----------------------------------------------------------------------; ! 2219: ; Table of unrolled edge loop entry points. First entry point is to copy ! 2220: ; 1 byte, last entry point is to copy EDGE_CHUNK_SIZE bytes. ! 2221: ;-----------------------------------------------------------------------; ! 2222: ! 2223: pfnCopyEdgeRWEntry label dword ! 2224: INDEX = 1 ! 2225: rept EDGE_CHUNK_SIZE ! 2226: DEFINE_DD EDGE_RW,%INDEX ! 2227: INDEX = INDEX+1 ! 2228: endm ! 2229: ! 2230: ! 2231: ;-----------------------------------------------------------------------; ! 2232: ; Unrolled loop for copying a strip of edge bytes, with source and ! 2233: ; destination both readable and writable. ! 2234: ;-----------------------------------------------------------------------; ! 2235: ! 2236: COPY_EDGE_RW macro ENTRY_LABEL,ENTRY_INDEX ! 2237: &ENTRY_LABEL&ENTRY_INDEX&: ! 2238: mov al,[esi] ;get byte to copy ! 2239: add esi,ebx ;point to next source scan ! 2240: xchg [edi],al ;read before write so Bit Mask can operate ! 2241: add edi,ebx ;point to next dest scan ! 2242: endm ;-----------------------------------; ! 2243: ! 2244: ; EBX = scan line width ! 2245: ; ESI = source address to copy from ! 2246: ; EDI = target address to copy to ! 2247: ; Bit Mask set to desired clipping ! 2248: ; Read Map and Map Mask set to enable the desired plane for read and write ! 2249: ! 2250: align 4 ! 2251: copy_edge_rw_full_chunk: ! 2252: UNROLL_LOOP COPY_EDGE_RW,EDGE_RW,EDGE_CHUNK_SIZE ! 2253: ! 2254: ; Do next plane within this chunk, if any. ! 2255: ! 2256: shr ah,1 ;advance to next plane ! 2257: jnz copy_edge_plane_loop ! 2258: ! 2259: ; Remember where we left off, for the next chunk. ! 2260: ! 2261: mov pSrcAddr,esi ! 2262: mov pDestAddr,edi ! 2263: ! 2264: ; Do next chunk within this bank block, if any. ! 2265: ! 2266: pop ebx ;retrieve remaining scan count ! 2267: and ebx,ebx ;any scans left? ! 2268: jnz copy_edge_chunk_loop ;more scans to do ! 2269: ! 2270: PLAIN_RET ! 2271: ! 2272: ! 2273: ;-----------------------------------------------------------------------; ! 2274: ; Copies a strip of left edge bytes from the source to the destination ! 2275: ; through an intermediate RAM buffer. This is the approach required by ! 2276: ; 1 R/W and 1R/1W adapters when the source and dest are in different banks. ! 2277: ; Writes up to EDGE_CHUNK_SIZE bytes in each plane at a pop; more bytes might ! 2278: ; cause flicker. ! 2279: ; ! 2280: ; Input: ! 2281: ; ulNextScan = width of scan, in bytes ! 2282: ; ulBlockHeight = # of scans to copy ! 2283: ; ulLeftEdgeSrc = start source offset in bitmap ! 2284: ; ulLeftEdgeDest = start dest offset in bitmap ! 2285: ; jLeftMask = left edge clip mask ! 2286: ; pTempPlane = pointer to temp storage buffer ! 2287: ; ulCurrentSrcScan = scan used to map in source bank ! 2288: ; ulCurrentDestScan = scan used to map in dest bank ! 2289: ; ulCurrentJustification = justification used to map in current bank ! 2290: ; For 1 R/W adapters, expects the source bank to be mapped in; banking ! 2291: ; is the same at exit as it was at entry ! 2292: ; ! 2293: ; Output: ! 2294: ; Advances ulLeftEdgeSrc and ulLeftEdgeDest to scan after last ! 2295: ; scan processed ! 2296: ; ! 2297: ; Note that this should never be called for an unbanked or 2 R/W adapter, ! 2298: ; because the source and dest are always both addressable simultaneously then. ! 2299: ;-----------------------------------------------------------------------; ! 2300: ! 2301: align 4 ! 2302: copy_left_edge_via_buffer: ! 2303: ! 2304: ; First, copy all the bytes into the temporary buffer. ! 2305: ! 2306: ; Calculate start source and dest addresses from bitmap start addresses and ! 2307: ; offsets within bitmap. ! 2308: ! 2309: mov ecx,pdsurf ! 2310: mov esi,ulLeftEdgeSrc ! 2311: add esi,[ecx].dsurf_pvBitmapStart2WindowS ! 2312: ! 2313: ; Copy the edge from the source to the temp buffer. ! 2314: ! 2315: call copy_screen_to_buffered_edge ! 2316: ! 2317: ; Remember where we left off, for next time ! 2318: ! 2319: mov ebx,pdsurf ! 2320: sub esi,[ebx].dsurf_pvBitmapStart2WindowS ! 2321: mov ulLeftEdgeSrc,esi ! 2322: ! 2323: ; Now copy the temp buffer to the screen. ! 2324: ! 2325: ; Map in the source bank to match the destination, so we can read/write to it ! 2326: ; and let the Bit Mask work. Note that on a 1 R/W adapter, both banks will be ! 2327: ; mapped by this call, which is fine. ! 2328: ! 2329: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 2330: <ebx,ulCurrentDestScan,ulCurrentJustification,MapSourceBank> ! 2331: ! 2332: ; Calculate dest start address (if this is a 1 R/W adapter, we had to wait ! 2333: ; until now to calculate this, because the dest bank wasn't mapped earlier). ! 2334: ! 2335: mov edi,ulLeftEdgeDest ! 2336: add edi,[ebx].dsurf_pvBitmapStart2WindowD ! 2337: ! 2338: mov ah,byte ptr jLeftMask ;clip mask for this edge ! 2339: call copy_buffered_edge_to_screen ;do the copy ! 2340: ! 2341: ; Remember where we left off, for next time. ! 2342: ! 2343: mov ebx,pdsurf ! 2344: sub edi,[ebx].dsurf_pvBitmapStart2WindowD ! 2345: mov ulLeftEdgeDest,edi ! 2346: ! 2347: ; Put back the original source bank. Note that on a 1 R/W adapter, both banks ! 2348: ; will be mapped by this call, which is fine. ! 2349: ! 2350: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 2351: <ebx,ulCurrentSrcScan,ulCurrentJustification,MapSourceBank> ! 2352: ! 2353: PLAIN_RET ! 2354: ! 2355: ! 2356: ;-----------------------------------------------------------------------; ! 2357: ; Copies a strip of right edge bytes from the source to the destination ! 2358: ; through an intermediate RAM buffer. This is the approach required by ! 2359: ; 1 R/W and 1R/1W adapters when the source and dest are in different banks. ! 2360: ; Writes up to EDGE_CHUNK_SIZE bytes in each plane at a pop; more bytes might ! 2361: ; cause flicker. ! 2362: ; ! 2363: ; Input: ! 2364: ; ulNextScan = width of scan, in bytes ! 2365: ; ulBlockHeight = # of scans to copy ! 2366: ; ulRightEdgeSrc = start source offset in bitmap ! 2367: ; ulRightEdgeDest = start dest offset in bitmap ! 2368: ; jRightMask = right edge clip mask ! 2369: ; pTempPlane = pointer to temp storage buffer ! 2370: ; ulCurrentSrcScan = scan used to map in source bank ! 2371: ; ulCurrentDestScan = scan used to map in dest bank ! 2372: ; ulCurrentJustification = justification used to map in current bank ! 2373: ; For 1 R/W adapters, expects the source bank to be mapped in; banking ! 2374: ; is the same at exit as it was at entry ! 2375: ; ! 2376: ; Output: ! 2377: ; Advances ulRightEdgeSrc and ulRightEdgeDest to scan after last ! 2378: ; scan processed ! 2379: ; ! 2380: ; Note that this should never be called for an unbanked or 2 R/W adapter, ! 2381: ; because the source and dest are always both addressable simultaneously then. ! 2382: ;-----------------------------------------------------------------------; ! 2383: ! 2384: align 4 ! 2385: copy_right_edge_via_buffer: ! 2386: ! 2387: ; First, copy all the bytes into the temporary buffer. ! 2388: ! 2389: ; Calculate start source address from bitmap start addresses and ! 2390: ; offsets within bitmap. ! 2391: ! 2392: mov ecx,pdsurf ! 2393: mov esi,ulRightEdgeSrc ! 2394: add esi,[ecx].dsurf_pvBitmapStart2WindowS ! 2395: ! 2396: ; Copy the edge from the source to the temp buffer. ! 2397: ! 2398: call copy_screen_to_buffered_edge ! 2399: ! 2400: ; Remember where we left off, for next time ! 2401: ! 2402: mov ebx,pdsurf ! 2403: sub esi,[ebx].dsurf_pvBitmapStart2WindowS ! 2404: mov ulRightEdgeSrc,esi ! 2405: ! 2406: ; Now copy the temp buffer to the screen. ! 2407: ! 2408: ; Map in the source bank to match the destination, so we can read/write to it ! 2409: ; and let the Bit Mask work. Note that on a 1 R/W adapter, both banks will be ! 2410: ; mapped by this call, which is correct. ! 2411: ! 2412: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 2413: <ebx,ulCurrentDestScan,ulCurrentJustification,MapSourceBank> ! 2414: ! 2415: ; Calculate dest start address (if this is a 1 R/W adapter, we had to wait ! 2416: ; until now to calculate this, because the dest bank wasn't mapped earlier). ! 2417: ! 2418: mov edi,ulRightEdgeDest ! 2419: add edi,[ebx].dsurf_pvBitmapStart2WindowD ! 2420: ! 2421: mov ah,byte ptr jRightMask ;clip mask for this edge ! 2422: call copy_buffered_edge_to_screen ;do the copy ! 2423: ! 2424: ; Remember where we left off, for next time. ! 2425: ! 2426: mov ebx,pdsurf ! 2427: sub edi,[ebx].dsurf_pvBitmapStart2WindowD ! 2428: mov ulRightEdgeDest,edi ! 2429: ! 2430: ; Put back the original source bank. Note that on a 1 R/W adapter, both banks ! 2431: ; will be mapped by this call, which is fine. ! 2432: ! 2433: ptrCall <dword ptr [ebx].dsurf_pfnBankControl2Window>, \ ! 2434: <ebx,ulCurrentSrcScan,ulCurrentJustification,MapSourceBank> ! 2435: ! 2436: PLAIN_RET ! 2437: ! 2438: ! 2439: ;-----------------------------------------------------------------------; ! 2440: ; Copies an edge from the temp buffer to the screen. ! 2441: ; Entry: ! 2442: ; AH = bit mask setting for edge ! 2443: ; DH = VGA_BASE SHR 8 ! 2444: ; EDI = destination address ! 2445: ; pTempPlane = temp buffer from which to copy ! 2446: ; ulBlockHeight = # of bytes to copy per plane ! 2447: ; ulNextScan = scan width ! 2448: ; Source and dest banks both pointing to destination ! 2449: ; Exit: ! 2450: ; EDI = next destination address ! 2451: ; ! 2452: ; Preserved: EBP ! 2453: ;-----------------------------------------------------------------------; ! 2454: ! 2455: align 4 ! 2456: copy_buffered_edge_to_screen: ! 2457: ! 2458: mov pDestAddr,edi ! 2459: ! 2460: mov dl,GRAF_ADDR ! 2461: mov al,GRAF_BIT_MASK ! 2462: out dx,ax ! 2463: ! 2464: mov pTempEntry,offset copy_edge_from_buf_full_chunk ! 2465: ;entry point into unrolled loop to copy first ! 2466: ; chunk, assuming it's a full chunk ! 2467: mov ecx,pTempPlane ;temp buffer start (copy from here) ! 2468: mov ebx,ulBlockHeight ;total # of scans to copy ! 2469: ! 2470: ; Copy the edge in a series of chunks, to avoid flicker. ! 2471: ! 2472: copy_from_buffer_chunk_loop: ! 2473: ! 2474: sub ebx,EDGE_CHUNK_SIZE ;scans remaining after this chunk, assuming ! 2475: ; a full chunk ! 2476: jge short @F ;do a full chunk ! 2477: add ebx,EDGE_CHUNK_SIZE ;not a full chunk; process all remaining ! 2478: ; scans ! 2479: mov ebx,pfnCopyEdgesFromBufferEntry[-4][ebx*4] ! 2480: mov pTempEntry,ebx ;entry point into unrolled loop to copy desired ! 2481: ; chunk size ! 2482: sub ebx,ebx ;no scans after this ! 2483: @@: ! 2484: push ebx ;remember remaining scan count ! 2485: ! 2486: mov al,MM_C3 ;start by copying plane 3 ! 2487: mov ebx,ulNextScan ! 2488: ! 2489: push ecx ;remember current temp buffer start ! 2490: ! 2491: mov dl,SEQ_DATA ;leave DX pointing to Sequencer Data reg ! 2492: copy_from_buffer_plane_loop: ! 2493: ! 2494: ; Set Map Mask to enable writes to plane we're copying. ! 2495: ! 2496: out dx,al ! 2497: ! 2498: ; Calculate the equivalent Read Map, and use that to select the correct plane ! 2499: ; from the temp buffer. ! 2500: ! 2501: mov esi,ecx ;point to current plane's source byte ! 2502: add ecx,ulBlockHeight ;point to next plane's source byte ! 2503: ! 2504: mov edi,pDestAddr ! 2505: ! 2506: jmp pTempEntry ;copy the left edge ! 2507: ! 2508: ! 2509: ;-----------------------------------------------------------------------; ! 2510: ; Table of unrolled edge copy-from-buffer loop entry points. First entry ! 2511: ; point is to copy 1 byte, last entry point is to copy EDGE_CHUNK_SIZE ! 2512: ; bytes. ! 2513: ;-----------------------------------------------------------------------; ! 2514: ! 2515: pfnCopyEdgesFromBufferEntry label dword ! 2516: INDEX = 1 ! 2517: rept EDGE_CHUNK_SIZE ! 2518: DEFINE_DD EDGE_FROM_BUFFER,%INDEX ! 2519: INDEX = INDEX+1 ! 2520: endm ! 2521: ! 2522: ! 2523: ;-----------------------------------------------------------------------; ! 2524: ; Unrolled loop for copying a strip of edge bytes from the temp buffer. ! 2525: ;-----------------------------------------------------------------------; ! 2526: ! 2527: COPY_EDGE_FROM_BUFFER macro ENTRY_LABEL,ENTRY_INDEX ! 2528: &ENTRY_LABEL&ENTRY_INDEX&: ! 2529: mov ah,[esi] ;get byte to copy ! 2530: inc esi ;point to next source (temp buffer) byte ! 2531: xchg [edi],ah ;read before write so Bit Mask can operate ! 2532: add edi,ebx ;point to next dest (screen) scna ! 2533: endm ;-----------------------------------; ! 2534: ! 2535: ; EBX = scan line width ! 2536: ; ESI = source address to copy from (temp buffer) ! 2537: ; EDI = target address to copy to (screen) ! 2538: ; Bit Mask set to desired clipping ! 2539: ; Map Mask set to enable the desired plane for write ! 2540: ! 2541: align 4 ! 2542: copy_edge_from_buf_full_chunk: ! 2543: UNROLL_LOOP COPY_EDGE_FROM_BUFFER,EDGE_FROM_BUFFER,EDGE_CHUNK_SIZE ! 2544: ! 2545: ; Do next plane within this chunk, if any. ! 2546: ! 2547: shr al,1 ;advance to next plane ! 2548: jnz copy_from_buffer_plane_loop ! 2549: ! 2550: ; Remember where we left off, for next chunk. ! 2551: ! 2552: mov pDestAddr,edi ! 2553: pop ecx ;get back current temp buffer start ! 2554: add ecx,EDGE_CHUNK_SIZE ;point to next chunk's start ! 2555: ! 2556: ; Do next chunk within this bank block, if any. ! 2557: ! 2558: pop ebx ;retrieve remaining scan count ! 2559: and ebx,ebx ;any scans left? ! 2560: jnz copy_from_buffer_chunk_loop ;more scans to do ! 2561: ! 2562: PLAIN_RET ! 2563: ! 2564: ! 2565: ;-----------------------------------------------------------------------; ! 2566: ; Copies an edge from the screen to the temp buffer. ! 2567: ; Entry: ! 2568: ; ESI = source address ! 2569: ; pTempPlane = temp buffer from which to copy ! 2570: ; ulBlockHeight = # of bytes to copy per plane ! 2571: ; ulNextScan = scan width ! 2572: ; Source bank pointing to source ! 2573: ; Exit: ! 2574: ; DH = VGA_BASE SHR 8 ! 2575: ; ESI = next source address ! 2576: ; ! 2577: ; Preserved: EBP ! 2578: ;-----------------------------------------------------------------------; ! 2579: ! 2580: align 4 ! 2581: copy_screen_to_buffered_edge: ! 2582: ! 2583: mov pSrcAddr,esi ! 2584: ! 2585: ; Leave the GC Index pointing to the Read Map. ! 2586: ! 2587: mov edx,VGA_BASE + GRAF_ADDR ! 2588: mov al,GRAF_READ_MAP ! 2589: out dx,al ! 2590: ! 2591: mov ebx,ulBlockHeight ! 2592: SET_UP_UNROLL_VARS ebx,ecx,ebx,pfnCopyEdgeToTempEntry, \ ! 2593: LOOP_UNROLL_SHIFT ! 2594: mov culTempCount,ebx ;remember # of unrolled loop iterations ! 2595: mov pTempEntry,ecx ;ditto for entry point ! 2596: ! 2597: mov ecx,ulNextScan ! 2598: mov edi,pTempPlane ;dest offset in temp buffer for plane 3 bytes. ! 2599: ;The rest of the planes are stored ! 2600: ; consecutively ! 2601: mov al,3 ;start by copying plane 3 ! 2602: mov dl,GRAF_DATA ;leave DX pointing to GC Data reg ! 2603: copy_edge_to_buffer_plane_loop: ! 2604: mov esi,pSrcAddr ;source pointer ! 2605: ! 2606: out dx,al ;set Read Map to plane we're copying from. ! 2607: ! 2608: mov ebx,culTempCount ;# of unrolled loop iterations ! 2609: jmp pTempEntry ;copy the edge bytes for this plane to the ! 2610: ; temp buffer ! 2611: ! 2612: ;-----------------------------------------------------------------------; ! 2613: ; Table of unrolled edge copy to temp buffer loop entry points. ! 2614: ;-----------------------------------------------------------------------; ! 2615: ! 2616: UNROLL_LOOP_ENTRY_TABLE pfnCopyEdgeToTempEntry,EDGE_TO_TEMP, \ ! 2617: LOOP_UNROLL_COUNT ! 2618: ! 2619: ;-----------------------------------------------------------------------; ! 2620: ; Unrolled loop for copying edge bytes to the temp buffer. ! 2621: ;-----------------------------------------------------------------------; ! 2622: ! 2623: COPY_EDGE_TO_TEMP macro ENTRY_LABEL,ENTRY_INDEX ! 2624: &ENTRY_LABEL&ENTRY_INDEX&: ! 2625: mov ah,[esi] ;get byte to copy ! 2626: add esi,ecx ;point to next source scan ! 2627: mov [edi],ah ;copy byte to temp buffer ! 2628: inc edi ;point to next temp buffer byte ! 2629: endm ;-----------------------------------; ! 2630: ! 2631: ; EBX = count of unrolled loop iterations ! 2632: ; ECX = offset from end of one scan's fill to start of next ! 2633: ; ESI = source address to copy from (screen) ! 2634: ; EDI = target address to copy to (temp buffer) ! 2635: ; Read Map set to enable the desired plane for read ! 2636: ! 2637: align 4 ! 2638: edge_to_buffer_loop: ! 2639: UNROLL_LOOP COPY_EDGE_TO_TEMP,EDGE_TO_TEMP,LOOP_UNROLL_COUNT ! 2640: dec ebx ! 2641: jnz edge_to_buffer_loop ! 2642: ! 2643: dec al ;count down planes ! 2644: jns copy_edge_to_buffer_plane_loop ! 2645: ! 2646: PLAIN_RET ! 2647: ! 2648: ! 2649: ;-----------------------------------------------------------------------; ! 2650: ! 2651: endProc vAlignedSrcCopy ! 2652: ! 2653: _TEXT$03 ends ! 2654: ! 2655: end ! 2656:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.