![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitblt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / jz484|
Return to bitblt.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / jz484 |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1992 Microsoft Corporation ! 4: ! 5: Module Name: ! 6: ! 7: BitBlt.c ! 8: ! 9: Abstract: ! 10: ! 11: This module hooks DrvBitBlt and DrvCopyBits for the Jaguar VXL board. ! 12: ! 13: The following operations are supported for DrvBitBlt: ! 14: SRCCOPY from screen to screen ! 15: BLACKNESS ! 16: WHITNESS ! 17: PATCOPY when the Brush pattern is a solid color ! 18: NOTPATCOPY when the Brush pattern is a solid color ! 19: ! 20: DrvCopyBits copies the data if source and dest surfaces are the ! 21: frame buffer. ! 22: ! 23: Environment: ! 24: ! 25: User mode. ! 26: ! 27: Revision History: ! 28: ! 29: --*/ ! 30: ! 31: #include "driver.h" ! 32: #include "jzvxl484.h" ! 33: ! 34: // ! 35: //Tmp savescreenbits vars ! 36: // ! 37: ! 38: ! 39: BOOL ! 40: DrvpIntersectRect( ! 41: IN PRECTL Rectl1, ! 42: IN PRECTL Rectl2, ! 43: OUT PRECTL DestRectl ! 44: ) ! 45: ! 46: /*++ ! 47: ! 48: Routine Description: ! 49: ! 50: This routine checks to see if the two specified retangles intersect. ! 51: ! 52: N.B. This routine is adopted from a routine written by darrinm. ! 53: ! 54: Arguments: ! 55: ! 56: Rectl1 - Supplies the coordinates of the first rectangle. ! 57: ! 58: Rectl2 - Supplies the coordinates of the second rectangle. ! 59: ! 60: DestRectl - Supplies the coordinates of the utput rectangle. ! 61: ! 62: Return Value: ! 63: ! 64: A value of TRUE is returned if the rectangles intersect. Otherwise, ! 65: a value of FALSE is returned. ! 66: ! 67: --*/ ! 68: ! 69: ! 70: { ! 71: ! 72: // ! 73: // Compute the maximum left edge and the minimum right edge. ! 74: // ! 75: ! 76: DestRectl->left = max(Rectl1->left, Rectl2->left); ! 77: DestRectl->right = min(Rectl1->right, Rectl2->right); ! 78: ! 79: // ! 80: // If the minimum right edge is greater than the maximum left edge, ! 81: // then the rectanges may intersect. Otherwise, they do not intersect. ! 82: // ! 83: ! 84: if (DestRectl->left < DestRectl->right) { ! 85: ! 86: // ! 87: // Compute the maximum top edge and the minimum bottom edge. ! 88: // ! 89: ! 90: DestRectl->top = max(Rectl1->top, Rectl2->top); ! 91: DestRectl->bottom = min(Rectl1->bottom, Rectl2->bottom); ! 92: ! 93: // ! 94: // If the minimum bottom edge is greater than the maximum top ! 95: // edge, then the rectanges intersect. Otherwise, they do not ! 96: // intersect. ! 97: // ! 98: ! 99: if (DestRectl->top < DestRectl->bottom) { ! 100: return TRUE; ! 101: } ! 102: } ! 103: ! 104: return FALSE; ! 105: } ! 106: ! 107: VOID ! 108: DrvpFillRectangle( ! 109: IN PRECTL DstRect, ! 110: IN ULONG Color ! 111: ) ! 112: /*++ ! 113: ! 114: Routine Description: ! 115: ! 116: Place a solid color fill command into the FIFO ! 117: ! 118: Arguments: ! 119: ! 120: DestRect - Rectangle to fill ! 121: Color - Fill color ! 122: ! 123: Return Value: ! 124: ! 125: Status of operation. ! 126: ! 127: --*/ ! 128: { ! 129: ! 130: ULONG X,Y; ! 131: ULONG XYCmd; ! 132: ULONG DstAdr; ! 133: ! 134: // ! 135: // calculate size of the fill. ! 136: // ! 137: ! 138: X = (ULONG)(DstRect->right - DstRect->left); ! 139: Y = (ULONG)(DstRect->bottom - DstRect->top); ! 140: Y &= 0x3FF; ! 141: ! 142: XYCmd=(JAGUAR_SOLID_FILL << XYCMD_CMD_SHIFT) | (Y << XYCMD_Y_SHIFT) | X; ! 143: ! 144: DstAdr= Vxl.JaguarScreenX*DstRect->top + (DstRect->left << Vxl.ColorModeShift); ! 145: ! 146: // ! 147: // Write command to the FIFO. ! 148: // ! 149: ! 150: FifoWrite(DstAdr,Color,XYCmd); ! 151: ! 152: } ! 153: ! 154: VOID ! 155: DrvpSolidFill( ! 156: IN PRECTL DstRect, ! 157: IN CLIPOBJ *pco, ! 158: IN ULONG Color ! 159: ) ! 160: /*++ ! 161: ! 162: Routine Description: ! 163: ! 164: This routine fills the unclipped areas of the destination rectangle with ! 165: the given color. ! 166: ! 167: Arguments: ! 168: ! 169: DstRect - Destination Rectangle ! 170: pco - Clipping area. ! 171: Color - Color to fill with. ! 172: ! 173: Return Value: ! 174: ! 175: None. ! 176: ! 177: --*/ ! 178: { ! 179: RECTL BltRectl; ! 180: ENUMRECTLIST ClipEnum; ! 181: BOOL MoreClipRects; ! 182: ULONG ClipRegions; ! 183: BYTE FixedComplexity; ! 184: ! 185: // ! 186: // Figure out the real clipping complexity ! 187: // ! 188: if (pco == (CLIPOBJ *)NULL) { ! 189: FixedComplexity = DC_TRIVIAL; ! 190: } else { ! 191: FixedComplexity = pco->iDComplexity; ! 192: } ! 193: switch (FixedComplexity) { ! 194: ! 195: // ! 196: // Entire destination is to be updated. ! 197: // Proceed with the Solid Fill. ! 198: // ! 199: case DC_TRIVIAL: ! 200: ! 201: DrvpFillRectangle(DstRect, // Target rectangle ! 202: Color); // Color ! 203: ! 204: break; ! 205: ! 206: // ! 207: // Only one clip region. ! 208: // ! 209: ! 210: case DC_RECT: ! 211: // ! 212: // only do the Fill if there is an intersection ! 213: // ! 214: ! 215: if (DrvpIntersectRect(DstRect,&pco->rclBounds,&BltRectl)) { ! 216: ! 217: DrvpFillRectangle(&BltRectl, // Target rectangle ! 218: Color); // Color ! 219: } ! 220: break; ! 221: ! 222: // ! 223: // Multiple clip regions. ! 224: // ! 225: ! 226: case DC_COMPLEX: ! 227: ! 228: CLIPOBJ_cEnumStart(pco,FALSE,CT_RECTANGLES,CD_ANY,BB_RECT_LIMIT); ! 229: do { ! 230: ! 231: // ! 232: // Get list of clip rectangles. ! 233: // ! 234: ! 235: MoreClipRects = CLIPOBJ_bEnum(pco,sizeof(ClipEnum),(PVOID)&ClipEnum); ! 236: ! 237: for (ClipRegions=0;ClipRegions<ClipEnum.c;ClipRegions++) { ! 238: ! 239: // ! 240: // If the rectangles intersect do the fill ! 241: // ! 242: if (DrvpIntersectRect(DstRect, ! 243: &ClipEnum.arcl[ClipRegions], ! 244: &BltRectl)) { ! 245: DrvpFillRectangle(&BltRectl, // Target rectangle ! 246: Color); // Color ! 247: ! 248: } ! 249: } ! 250: } while (MoreClipRects); ! 251: break; ! 252: ! 253: } // end switch complexity ! 254: } ! 255: ! 256: VOID ! 257: DrvpBitBlt( ! 258: IN PRECTL DstRect, ! 259: IN PPOINTL SrcPoint, ! 260: IN BOOL BltDir ! 261: ) ! 262: /*++ ! 263: ! 264: Routine Description: ! 265: ! 266: Place a BitBlt command into the FIFO ! 267: ! 268: Arguments: ! 269: ! 270: DstRect - Destination Rectangle ! 271: SrcPoint - Source Point ! 272: BltDir - FALSE = Left to Right Top to Bottom. ! 273: TRUE = Right to Left Bottom to Top ! 274: ! 275: Return Value: ! 276: ! 277: None. ! 278: ! 279: --*/ ! 280: { ! 281: ! 282: ULONG X,Y; ! 283: ULONG XYCmd; ! 284: ULONG SrcAdr; ! 285: ULONG DstAdr; ! 286: ! 287: X = DstRect->right - DstRect->left; ! 288: Y = DstRect->bottom - DstRect->top; ! 289: if (BltDir) { ! 290: ! 291: // ! 292: // This is a Right To Left Bottom to Top BitBlt ! 293: // Src and Dest adr are the first byte of the pixel to ! 294: // be moved. That is the most significant byte of the pixel. ! 295: // The Rectangle excludes the bottom right corner which ! 296: // is the start address for these sort of bitblts. ! 297: // One is substracted from the Y to exclude the last line. ! 298: // One is substracted from the X after addjusting it to the ! 299: // size of the pixel. So the address of the next pixel is computed ! 300: // and then one is substracted which gives the address of the ! 301: // most significant byte of the previous pixel. ! 302: // ! 303: ! 304: DstAdr=Vxl.JaguarScreenX*(DstRect->bottom-1) + ((DstRect->right) << Vxl.ColorModeShift) -1; ! 305: SrcAdr=Vxl.JaguarScreenX*(SrcPoint->y+Y-1) + ((SrcPoint->x+X) << Vxl.ColorModeShift) -1; ! 306: XYCmd=JAGUAR_BITBLT_RIGHTLEFT << XYCMD_CMD_SHIFT; ! 307: ! 308: } else { ! 309: ! 310: // ! 311: // This is a Left To Right Top to Bottom. ! 312: // ! 313: ! 314: DstAdr=Vxl.JaguarScreenX*DstRect->top + (DstRect->left << Vxl.ColorModeShift); ! 315: SrcAdr=Vxl.JaguarScreenX*SrcPoint->y + (SrcPoint->x << Vxl.ColorModeShift); ! 316: XYCmd=JAGUAR_BITBLT_LEFTRIGHT << XYCMD_CMD_SHIFT; ! 317: ! 318: } ! 319: Y &= 0x3FF; ! 320: ! 321: XYCmd = XYCmd | (Y << XYCMD_Y_SHIFT) | X; ! 322: FifoWrite(DstAdr,SrcAdr,XYCmd); ! 323: } ! 324: ! 325: BOOL ! 326: DrvBitBlt( ! 327: IN SURFOBJ *psoDst, // Target surface ! 328: IN SURFOBJ *psoSrc, // Source surface ! 329: IN SURFOBJ *psoMask, // Mask ! 330: IN CLIPOBJ *pco, // Clip through this ! 331: IN XLATEOBJ *pxlo, // Color translation ! 332: IN PRECTL prclDst, // Target offset and extent ! 333: IN PPOINTL pptlSrc, // Source offset ! 334: IN PPOINTL pptlMask, // Mask offset ! 335: IN BRUSHOBJ *pdbrush, // Brush data (from cbRealizeBrush) ! 336: IN PPOINTL pptlBrush, // Brush offset (origin) ! 337: IN ROP4 rop4 // Raster operation ! 338: ) ! 339: ! 340: /*++ ! 341: ! 342: Routine Description: ! 343: ! 344: Code for "hooking" Bit Blt functions for Jaguar VXL. ! 345: ! 346: Arguments: ! 347: ! 348: ! 349: Return Value: ! 350: ! 351: ! 352: --*/ ! 353: ! 354: { ! 355: ! 356: FLONG BltDir; ! 357: BOOL JaguarDir; ! 358: RECTL BltRectl; ! 359: ENUMRECTLIST ClipEnum; ! 360: BOOL MoreClipRects; ! 361: ULONG ClipRegions; ! 362: POINTL SrcPoint; ! 363: PPDEV ppdev = (PPDEV) psoDst->dhpdev; ! 364: BYTE FixedComplexity; ! 365: ! 366: // ! 367: // Check that there is no color translation. ! 368: // ! 369: ! 370: if ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)) { ! 371: ! 372: // ! 373: // Check that the blt operation has the screen as target surface. ! 374: // ! 375: ! 376: if (psoDst->pvBits == (PVOID)Vxl.ScreenBase) { ! 377: ! 378: // ! 379: // Check for rops that Jaguar handles. ! 380: // Solid Fills, ! 381: // SRCCOPPY ! 382: // ! 383: ! 384: switch(rop4) { ! 385: case 0x00000000: // DDx (BLACKNESS) ! 386: DrvpSolidFill(prclDst,pco,0); ! 387: return(TRUE); ! 388: ! 389: case 0x0000FFFF: // DDxn (WHITENESS) ! 390: DrvpSolidFill(prclDst,pco,0xFFFFFF); ! 391: return(TRUE); ! 392: ! 393: case 0x0000F0F0: // P (PATCOPY) ! 394: case 0x00000F0F: // Pn (NOTPATCOPY) ! 395: ! 396: // ! 397: // This is a pattern fill. Check if the brush pattern ! 398: // is just a plain color, in this case procede with the ! 399: // Solid Color Fill. ! 400: // ! 401: ! 402: if (pdbrush->iSolidColor != 0xFFFFFFFF) { ! 403: DrvpSolidFill(prclDst, ! 404: pco, ! 405: (rop4 == 0xF0F) ? ~(pdbrush->iSolidColor) : pdbrush->iSolidColor); ! 406: return(TRUE); ! 407: } ! 408: ! 409: break; ! 410: ! 411: // ! 412: // Source copy ! 413: // ! 414: ! 415: case 0x0000CCCC: ! 416: ! 417: // ! 418: // Check that Source and Destination Surfaces are the same. ! 419: // This is enough as we already checked that the dst is the frame buffer ! 420: // ! 421: ! 422: if (psoDst->pvBits == psoSrc->pvBits) { ! 423: ! 424: // ! 425: // check BLT direction for setting up clip regions ! 426: // And for Jaguar BitBlt Commands as follows: ! 427: // - If BltDir is UPWARDS do the BitBlt RightToLeft Bottom ! 428: // to Top except when Src & Dst are in the same scan line ! 429: // and BltDir is not LEFTWARDS ! 430: // ! 431: ! 432: BltDir = 0; ! 433: JaguarDir = FALSE; ! 434: if (pptlSrc->y <= prclDst->top) { ! 435: BltDir = CD_UPWARDS; ! 436: JaguarDir = TRUE; ! 437: } ! 438: ! 439: if (pptlSrc->x <= prclDst->left) { ! 440: BltDir |= CD_LEFTWARDS; ! 441: } else { ! 442: if ((JaguarDir) && (pptlSrc->y == prclDst->top)) { ! 443: JaguarDir = FALSE; ! 444: } ! 445: } ! 446: ! 447: // ! 448: // Figure out the real clipping complexity ! 449: // ! 450: ! 451: if (pco == (CLIPOBJ *)NULL) { ! 452: FixedComplexity = DC_TRIVIAL; ! 453: } else { ! 454: FixedComplexity = pco->iDComplexity; ! 455: } ! 456: ! 457: switch (FixedComplexity) { ! 458: ! 459: // ! 460: // Entire destination is to be updated. ! 461: // Proceed with the BitBlt. ! 462: // ! 463: ! 464: case DC_TRIVIAL: ! 465: ! 466: DrvpBitBlt(prclDst, // Target rectangle ! 467: pptlSrc, // Source offset ! 468: JaguarDir // Direction ! 469: ); ! 470: return(TRUE); ! 471: ! 472: // ! 473: // Only one clip region. ! 474: // ! 475: ! 476: case DC_RECT: ! 477: ! 478: // ! 479: // only do the BLT if there is an intersection ! 480: // ! 481: ! 482: if (DrvpIntersectRect(prclDst,&pco->rclBounds,&BltRectl)) { ! 483: ! 484: // ! 485: // Adjust the Source for the intersection rectangle. ! 486: // ! 487: ! 488: pptlSrc->x += BltRectl.left - prclDst->left; ! 489: pptlSrc->y += BltRectl.top - prclDst->top; ! 490: ! 491: DrvpBitBlt(&BltRectl, // Target rectangle ! 492: pptlSrc, // Source offset ! 493: JaguarDir // Direction ! 494: ); ! 495: } ! 496: ! 497: return(TRUE); ! 498: ! 499: // ! 500: // Multiple clip regions. ! 501: // ! 502: ! 503: case DC_COMPLEX: ! 504: ! 505: CLIPOBJ_cEnumStart(pco,FALSE,CT_RECTANGLES,BltDir,BB_RECT_LIMIT); ! 506: do { ! 507: ! 508: // ! 509: // Get list of clip rectangles. ! 510: // ! 511: ! 512: MoreClipRects = CLIPOBJ_bEnum(pco,sizeof(ClipEnum),(PVOID)&ClipEnum); ! 513: ! 514: for (ClipRegions=0;ClipRegions<ClipEnum.c;ClipRegions++) { ! 515: ! 516: // ! 517: // If the rectangles intersect calculate the offset to the ! 518: // source start location to match and do the BitBlt. ! 519: // ! 520: if (DrvpIntersectRect(prclDst, ! 521: &ClipEnum.arcl[ClipRegions], ! 522: &BltRectl)) { ! 523: SrcPoint.x = pptlSrc->x + BltRectl.left - prclDst->left; ! 524: SrcPoint.y = pptlSrc->y + BltRectl.top - prclDst->top; ! 525: DrvpBitBlt(&BltRectl, // Target rectangle ! 526: &SrcPoint, // Source offset ! 527: JaguarDir // Direction ! 528: ); ! 529: } ! 530: } ! 531: } while (MoreClipRects); ! 532: ! 533: return(TRUE); ! 534: ! 535: // ! 536: // Unknown Clip complexity ! 537: // ! 538: ! 539: default: ! 540: break; ! 541: } // end switch complexity ! 542: } // end if Src surface = Dst surface ! 543: } // end switch rop4 ! 544: } ! 545: } ! 546: ! 547: // ! 548: // Call GDI to do the Blt for us. No need to syncrhonize here since ! 549: // EngXXX routines call DrvSynchronize. ! 550: // ! 551: ! 552: return(EngBitBlt(psoDst, // Target surface ! 553: psoSrc, // Source surface ! 554: psoMask, // Mask ! 555: pco, // Clip through this ! 556: pxlo, // Color translation ! 557: prclDst, // Target offset and extent ! 558: pptlSrc, // Source offset ! 559: pptlMask, // Mask offset ! 560: pdbrush, // Brush data (from cbRealizeBrush) ! 561: pptlBrush, // Brush offset (origin) ! 562: rop4 // Raster operation ! 563: ) ! 564: ); ! 565: } ! 566: ! 567: BOOL ! 568: DrvCopyBits( ! 569: SURFOBJ *psoDst, ! 570: SURFOBJ *psoSrc, ! 571: CLIPOBJ *pco, ! 572: XLATEOBJ *pxlo, ! 573: RECTL *prclDst, ! 574: POINTL *pptlSrc) ! 575: ! 576: /*++ ! 577: ! 578: Routine Description: ! 579: ! 580: Code for "hooking" CopyBits function for Jaguar VXL. ! 581: ! 582: Arguments: ! 583: ! 584: ! 585: Return Value: ! 586: ! 587: ! 588: --*/ ! 589: ! 590: { ! 591: RECTL BltRectl; ! 592: ENUMRECTLIST ClipEnum; ! 593: BYTE FixedComplexity; ! 594: BOOL MoreClipRects; ! 595: FLONG BltDir; ! 596: BOOL JaguarDir; ! 597: ULONG ClipRegions; ! 598: POINTL SrcPoint; ! 599: ! 600: ! 601: ! 602: // ! 603: // Check that there is no color translation. ! 604: // ! 605: ! 606: if ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)) { ! 607: ! 608: // ! 609: // Check that source and destination surfaces are the frame buffer. ! 610: // ! 611: ! 612: if ((psoSrc->pvBits == (PVOID)Vxl.ScreenBase) && ! 613: (psoDst->pvBits == (PVOID)Vxl.ScreenBase)) { ! 614: ! 615: // ! 616: // check BLT direction for setting up clip regions ! 617: // And for Jaguar BitBlt Commands as follows: ! 618: // - If BltDir is UPWARDS do the BitBlt RightToLeft Bottom ! 619: // to Top except when Src & Dst are in the same scan line ! 620: // and BltDir is not LEFTWARDS ! 621: // ! 622: ! 623: BltDir = 0; ! 624: JaguarDir = FALSE; ! 625: if (pptlSrc->y <= prclDst->top) { ! 626: BltDir = CD_UPWARDS; ! 627: JaguarDir = TRUE; ! 628: } ! 629: ! 630: if (pptlSrc->x <= prclDst->left) { ! 631: BltDir |= CD_LEFTWARDS; ! 632: } else { ! 633: if ((JaguarDir) && (pptlSrc->y == prclDst->top)) { ! 634: JaguarDir = FALSE; ! 635: } ! 636: } ! 637: ! 638: // ! 639: // Figure out the real clipping complexity ! 640: // ! 641: ! 642: if (pco == (CLIPOBJ *)NULL) { ! 643: FixedComplexity = DC_TRIVIAL; ! 644: } else { ! 645: FixedComplexity = pco->iDComplexity; ! 646: } ! 647: ! 648: switch (FixedComplexity) { ! 649: ! 650: // ! 651: // Entire destination is to be updated. ! 652: // Proceed with the BitBlt. ! 653: // ! 654: ! 655: case DC_TRIVIAL: ! 656: ! 657: DrvpBitBlt(prclDst, // Target rectangle ! 658: pptlSrc, // Source offset ! 659: JaguarDir // Direction ! 660: ); ! 661: return(TRUE); ! 662: ! 663: // ! 664: // Only one clip region. ! 665: // ! 666: ! 667: case DC_RECT: ! 668: ! 669: // ! 670: // only do the BLT if there is an intersection ! 671: // ! 672: ! 673: if (DrvpIntersectRect(prclDst,&pco->rclBounds,&BltRectl)) { ! 674: ! 675: // ! 676: // Adjust the Source for the intersection rectangle. ! 677: // ! 678: ! 679: pptlSrc->x += BltRectl.left - prclDst->left; ! 680: pptlSrc->y += BltRectl.top - prclDst->top; ! 681: ! 682: DrvpBitBlt(&BltRectl, // Target rectangle ! 683: pptlSrc, // Source offset ! 684: JaguarDir // Direction ! 685: ); ! 686: } ! 687: ! 688: return(TRUE); ! 689: ! 690: // ! 691: // Multiple clip regions. ! 692: // ! 693: ! 694: case DC_COMPLEX: ! 695: ! 696: CLIPOBJ_cEnumStart(pco,FALSE,CT_RECTANGLES,BltDir,BB_RECT_LIMIT); ! 697: do { ! 698: ! 699: // ! 700: // Get list of clip rectangles. ! 701: // ! 702: ! 703: MoreClipRects = CLIPOBJ_bEnum(pco,sizeof(ClipEnum),(PVOID)&ClipEnum); ! 704: ! 705: for (ClipRegions=0;ClipRegions<ClipEnum.c;ClipRegions++) { ! 706: ! 707: // ! 708: // If the rectangles intersect calculate the offset to the ! 709: // source start location to match and do the BitBlt. ! 710: // ! 711: if (DrvpIntersectRect(prclDst, ! 712: &ClipEnum.arcl[ClipRegions], ! 713: &BltRectl)) { ! 714: SrcPoint.x = pptlSrc->x + BltRectl.left - prclDst->left; ! 715: SrcPoint.y = pptlSrc->y + BltRectl.top - prclDst->top; ! 716: DrvpBitBlt(&BltRectl, // Target rectangle ! 717: &SrcPoint, // Source offset ! 718: JaguarDir // Direction ! 719: ); ! 720: } ! 721: } ! 722: } while (MoreClipRects); ! 723: ! 724: return(TRUE); ! 725: ! 726: // ! 727: // Unknown Clip complexity ! 728: // ! 729: ! 730: default: ! 731: break; ! 732: } // end switch complexity ! 733: } ! 734: ! 735: } ! 736: ! 737: // ! 738: // If the copy operation could be performed by the accelerator, ! 739: // this routine has already returned. ! 740: // If execution falls here, call the Engine routine. ! 741: // No need to Synchronize here since the Eng routine will call DrvSyncrhonize. ! 742: // ! 743: ! 744: return EngCopyBits(psoDst, ! 745: psoSrc, ! 746: pco, ! 747: pxlo, ! 748: prclDst, ! 749: pptlSrc); ! 750: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.