![[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 / s3|
Return to bitblt.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3 |
1.1 ! root 1: /******************************Module*Header*******************************\ ! 2: * Module Name: bitblt.c ! 3: * ! 4: * Banked Frame Buffer bitblit ! 5: * ! 6: * Copyright (c) 1992 Microsoft Corporation ! 7: * ! 8: \**************************************************************************/ ! 9: ! 10: #include "driver.h" ! 11: ! 12: #define SRCBM_CACHE 1 ! 13: ! 14: BOOL bTest = FALSE; ! 15: ! 16: ULONG nColorBrushes, ! 17: nColorBrushCacheHit, ! 18: nColorBrushExpansionCacheHit, ! 19: nColorBrushCacheInvalidations; ! 20: ! 21: ULONG nMonoBrushes, ! 22: nMonoBrushCacheHit, ! 23: nMonoBrushExpansionCacheHit, ! 24: nMonoBrushCacheInvalidations; ! 25: ! 26: ULONG n8BppBitmaps, ! 27: n8BppBmCacheHits; ! 28: ! 29: ULONG n1BppBitmaps, ! 30: n1BppBmCacheHits; ! 31: ! 32: ! 33: extern ULONG nSsbMovedToHostFromSrcBmCache; ! 34: ! 35: BYTE ajMonoPatPlanes[] = {0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80}; ! 36: ! 37: ! 38: /// Define the A vector polynomial bits ! 39: // ! 40: // Each bit corresponds to one of the terms in the polynomial ! 41: // ! 42: // Rop(D,S,P) = a + a D + a S + a P + a DS + a DP + a SP + a DSP ! 43: // 0 d s p ds dp sp dsp ! 44: ! 45: #define AVEC_NOT 0x01 ! 46: #define AVEC_D 0x02 ! 47: #define AVEC_S 0x04 ! 48: #define AVEC_P 0x08 ! 49: #define AVEC_DS 0x10 ! 50: #define AVEC_DP 0x20 ! 51: #define AVEC_SP 0x40 ! 52: #define AVEC_DSP 0x80 ! 53: ! 54: #define AVEC_NEED_SOURCE (AVEC_S | AVEC_DS | AVEC_SP | AVEC_DSP) ! 55: #define AVEC_NEED_PATTERN (AVEC_P | AVEC_DP | AVEC_SP | AVEC_DSP) ! 56: ! 57: #define BB_TARGET_SCREEN 0x0001 ! 58: #define BB_TARGET_ONLY 0x0002 ! 59: #define BB_SOURCE_COPY 0x0004 ! 60: #define BB_PATTERN_COPY 0x0008 ! 61: ! 62: ! 63: /******************************Public*Data*********************************\ ! 64: * ROP translation table ! 65: * ! 66: * Translates the usual ternary rop into A-vector notation. Each bit in ! 67: * this new notation corresponds to a term in a polynomial translation of ! 68: * the rop. ! 69: * ! 70: * Rop(D,S,P) = a + a D + a S + a P + a DS + a DP + a SP + a DSP ! 71: * 0 d s p ds dp sp dsp ! 72: \**************************************************************************/ ! 73: ! 74: BYTE gajRop[] = ! 75: { ! 76: 0x00, 0xff, 0xb2, 0x4d, 0xd4, 0x2b, 0x66, 0x99, ! 77: 0x90, 0x6f, 0x22, 0xdd, 0x44, 0xbb, 0xf6, 0x09, ! 78: 0xe8, 0x17, 0x5a, 0xa5, 0x3c, 0xc3, 0x8e, 0x71, ! 79: 0x78, 0x87, 0xca, 0x35, 0xac, 0x53, 0x1e, 0xe1, ! 80: 0xa0, 0x5f, 0x12, 0xed, 0x74, 0x8b, 0xc6, 0x39, ! 81: 0x30, 0xcf, 0x82, 0x7d, 0xe4, 0x1b, 0x56, 0xa9, ! 82: 0x48, 0xb7, 0xfa, 0x05, 0x9c, 0x63, 0x2e, 0xd1, ! 83: 0xd8, 0x27, 0x6a, 0x95, 0x0c, 0xf3, 0xbe, 0x41, ! 84: 0xc0, 0x3f, 0x72, 0x8d, 0x14, 0xeb, 0xa6, 0x59, ! 85: 0x50, 0xaf, 0xe2, 0x1d, 0x84, 0x7b, 0x36, 0xc9, ! 86: 0x28, 0xd7, 0x9a, 0x65, 0xfc, 0x03, 0x4e, 0xb1, ! 87: 0xb8, 0x47, 0x0a, 0xf5, 0x6c, 0x93, 0xde, 0x21, ! 88: 0x60, 0x9f, 0xd2, 0x2d, 0xb4, 0x4b, 0x06, 0xf9, ! 89: 0xf0, 0x0f, 0x42, 0xbd, 0x24, 0xdb, 0x96, 0x69, ! 90: 0x88, 0x77, 0x3a, 0xc5, 0x5c, 0xa3, 0xee, 0x11, ! 91: 0x18, 0xe7, 0xaa, 0x55, 0xcc, 0x33, 0x7e, 0x81, ! 92: 0x80, 0x7f, 0x32, 0xcd, 0x54, 0xab, 0xe6, 0x19, ! 93: 0x10, 0xef, 0xa2, 0x5d, 0xc4, 0x3b, 0x76, 0x89, ! 94: 0x68, 0x97, 0xda, 0x25, 0xbc, 0x43, 0x0e, 0xf1, ! 95: 0xf8, 0x07, 0x4a, 0xb5, 0x2c, 0xd3, 0x9e, 0x61, ! 96: 0x20, 0xdf, 0x92, 0x6d, 0xf4, 0x0b, 0x46, 0xb9, ! 97: 0xb0, 0x4f, 0x02, 0xfd, 0x64, 0x9b, 0xd6, 0x29, ! 98: 0xc8, 0x37, 0x7a, 0x85, 0x1c, 0xe3, 0xae, 0x51, ! 99: 0x58, 0xa7, 0xea, 0x15, 0x8c, 0x73, 0x3e, 0xc1, ! 100: 0x40, 0xbf, 0xf2, 0x0d, 0x94, 0x6b, 0x26, 0xd9, ! 101: 0xd0, 0x2f, 0x62, 0x9d, 0x04, 0xfb, 0xb6, 0x49, ! 102: 0xa8, 0x57, 0x1a, 0xe5, 0x7c, 0x83, 0xce, 0x31, ! 103: 0x38, 0xc7, 0x8a, 0x75, 0xec, 0x13, 0x5e, 0xa1, ! 104: 0xe0, 0x1f, 0x52, 0xad, 0x34, 0xcb, 0x86, 0x79, ! 105: 0x70, 0x8f, 0xc2, 0x3d, 0xa4, 0x5b, 0x16, 0xe9, ! 106: 0x08, 0xf7, 0xba, 0x45, 0xdc, 0x23, 0x6e, 0x91, ! 107: 0x98, 0x67, 0x2a, 0xd5, 0x4c, 0xb3, 0xfe, 0x01 ! 108: }; ! 109: ! 110: BOOL b8BppHostToScrnCachedWithRop( ! 111: SURFOBJ *psoTrg, ! 112: SURFOBJ *psoSrc, ! 113: CLIPOBJ *pco, ! 114: XLATEOBJ *pxlo, ! 115: RECTL *prclTrg, ! 116: POINTL *pptlSrc, ! 117: WORD s3Rop); ! 118: ! 119: BOOL b1BppHostToScrnCachedWithRop( ! 120: SURFOBJ *psoTrg, ! 121: SURFOBJ *psoSrc, ! 122: CLIPOBJ *pco, ! 123: XLATEOBJ *pxlo, ! 124: RECTL *prclTrg, ! 125: POINTL *pptlSrc, ! 126: WORD s3Rop); ! 127: ! 128: BOOL b8BppHostToScrnWithRop( ! 129: SURFOBJ *psoTrg, ! 130: SURFOBJ *psoSrc, ! 131: CLIPOBJ *pco, ! 132: XLATEOBJ *pxlo, ! 133: RECTL *prclTrg, ! 134: POINTL *pptlSrc, ! 135: WORD s3Rop); ! 136: ! 137: VOID vLowLevel8BppHostToScrnWithRop( ! 138: PPDEV ppdev, ! 139: PPOINT pptTrg, ! 140: PSIZE psizBlt, ! 141: PWORD pwFirstWord, ! 142: INT lSrcDelta, ! 143: XLATEOBJ *pxlo, ! 144: WORD s3Rop); ! 145: ! 146: BOOL b1BppHostToScrnWithRop( ! 147: SURFOBJ *psoTrg, ! 148: SURFOBJ *psoSrc, ! 149: CLIPOBJ *pco, ! 150: XLATEOBJ *pxlo, ! 151: RECTL *prclTrg, ! 152: POINTL *pptlSrc, ! 153: WORD s3Rop); ! 154: ! 155: VOID vLowLevel1BppHostToScrnWithRop( ! 156: PPDEV ppdev, ! 157: PPOINT pptTrg, ! 158: PSIZE psizBlt, ! 159: INT xSrc, ! 160: PWORD pwFirstWord, ! 161: INT lSrcDelta, ! 162: XLATEOBJ *pxlo, ! 163: WORD s3Rop); ! 164: ! 165: BOOL b4BppHostToScrnWithRop( ! 166: SURFOBJ *psoTrg, ! 167: SURFOBJ *psoSrc, ! 168: CLIPOBJ *pco, ! 169: XLATEOBJ *pxlo, ! 170: RECTL *prclTrg, ! 171: POINTL *pptlSrc, ! 172: WORD s3Rop); ! 173: ! 174: ! 175: VOID vLowLevel4BppHostToScrnWithRop( ! 176: PPDEV ppdev, ! 177: PPOINT pptTrg, ! 178: PSIZE psizBlt, ! 179: INT xSrc, ! 180: PWORD pwFirstWord, ! 181: INT lSrcDelta, ! 182: XLATEOBJ *pxlo, ! 183: WORD s3Rop); ! 184: ! 185: ! 186: WORD wXlateSrcRop3toS3Rop(PPDEV pdev, WORD rop3); ! 187: ! 188: ROP4 bXlatePatRop4toS3Rop( ! 189: PPDEV pdev, ! 190: ROP4 rop4); ! 191: ! 192: BOOL bDownLoadBrushIntoColorCache( ! 193: PPDEV ppdev, ! 194: PS3BRUSH ps3Brush, ! 195: PPOINT ppt); ! 196: ! 197: BOOL bDownLoadBrushIntoMonoCache( ! 198: PPDEV ppdev, ! 199: PS3BRUSH p3Brush, ! 200: PXYZPOINT pxyzPt); ! 201: ! 202: BOOL bExpandColorBrushIntoHorzCache( ! 203: PPDEV ppdev, ! 204: PPOINT ppt); ! 205: ! 206: BOOL bExpandMonoBrushIntoHorzCache( ! 207: PPDEV ppdev, ! 208: PXYZPOINT pxyzPtl, ! 209: INT zHorz); ! 210: ! 211: BOOL bExpandColorBrushIntoVertCache( ! 212: PPDEV ppdev, ! 213: PPOINT ppt); ! 214: ! 215: BOOL bExpandMonoBrushIntoVertCache( ! 216: PPDEV ppdev, ! 217: PXYZPOINT pxyzPt, ! 218: INT zVert); ! 219: ! 220: BOOL bColorHorzCacheToScreen( ! 221: PPDEV ppdev, ! 222: PS3BRUSH ps3Brush, ! 223: PPOINT pptBrushOrg, ! 224: PPOINT pptDest, ! 225: PSIZE psizDest, ! 226: WORD s3ForeRop, ! 227: WORD s3BackRop); ! 228: ! 229: BOOL bColorExpandHorzCacheToScreen( ! 230: PPDEV ppdev, ! 231: PS3BRUSH ps3Brush, ! 232: INT zHorz, ! 233: PPOINT pptBrushOrg, ! 234: PPOINT pptDest, ! 235: PSIZE psizDest, ! 236: WORD s3ForeRop, ! 237: WORD s3BackRop); ! 238: ! 239: BOOL bCpyColorHorzCacheToScreen( ! 240: PPDEV ppdev, ! 241: PS3BRUSH ps3Brush, ! 242: PPOINT pptBrushOrg, ! 243: PPOINT pptDest, ! 244: PSIZE psizDest); ! 245: ! 246: BOOL bCpyColorExpandHorzCacheToScreen( ! 247: PPDEV ppdev, ! 248: PS3BRUSH ps3Brush, ! 249: INT zHorz, ! 250: PPOINT pptBrushOrg, ! 251: PPOINT pptDest, ! 252: PSIZE psizDest); ! 253: ! 254: BOOL bColorVertCacheToScreen( ! 255: PPDEV ppdev, ! 256: PS3BRUSH ps3Brush, ! 257: PPOINT pptBrushOrg, ! 258: PPOINT pptDest, ! 259: PSIZE psizDest, ! 260: WORD s3ForeRop, ! 261: WORD s3BackRop); ! 262: ! 263: BOOL bColorExpandVertCacheToScreen( ! 264: PPDEV ppdev, ! 265: PS3BRUSH ps3Brush, ! 266: INT zHorz, ! 267: PPOINT pptBrushOrg, ! 268: PPOINT pptDest, ! 269: PSIZE psizDest, ! 270: WORD s3ForeRop, ! 271: WORD s3BackRop); ! 272: ! 273: ! 274: BOOL bPuntBlit( ! 275: SURFOBJ *psoTrg, ! 276: SURFOBJ *psoSrc, ! 277: SURFOBJ *psoMask, ! 278: CLIPOBJ *pco, ! 279: XLATEOBJ *pxlo, ! 280: RECTL *prclTrg, ! 281: POINTL *pptlSrc, ! 282: POINTL *pptlMask, ! 283: BRUSHOBJ *pbo, ! 284: POINTL *pptlBrush, ! 285: ROP4 rop4); ! 286: ! 287: BOOL bScrnToScrnPuntBlit( ! 288: SURFOBJ *psoTrg, ! 289: SURFOBJ *psoSrc, ! 290: SURFOBJ *psoMask, ! 291: CLIPOBJ *pco, ! 292: XLATEOBJ *pxlo, ! 293: RECTL *prclTrg, ! 294: POINTL *pptlSrc, ! 295: POINTL *pptlMask, ! 296: BRUSHOBJ *pbo, ! 297: POINTL *pptlBrush, ! 298: ROP4 rop4); ! 299: ! 300: ! 301: BOOL bSpecialBlits( ! 302: SURFOBJ *psoTrg, ! 303: SURFOBJ *psoSrc, ! 304: SURFOBJ *psoMask, ! 305: CLIPOBJ *pco, ! 306: XLATEOBJ *pxlo, ! 307: RECTL *prclTrg, ! 308: POINTL *pptlSrc, ! 309: POINTL *pptlMask, ! 310: BRUSHOBJ *pbo, ! 311: POINTL *pptlBrush, ! 312: ROP4 rop4); ! 313: ! 314: BOOL bScrnToScrnWithRop( ! 315: SURFOBJ *psoTrg, ! 316: SURFOBJ *psoSrc, ! 317: CLIPOBJ *pco, ! 318: RECTL *prclTrg, ! 319: POINTL *pptlSrc, ! 320: WORD s3Rop); ! 321: ! 322: ! 323: VOID S3ScrnToScrnBlt( ! 324: PPDEV ppdev, ! 325: INT xSrc, ! 326: INT ySrc, ! 327: INT xTrg, ! 328: INT yTrg, ! 329: INT width, ! 330: INT height, ! 331: WORD s3Rop, ! 332: WORD Cmd); ! 333: ! 334: BOOL bPatternSolid( ! 335: SURFOBJ *psoTrg, ! 336: SURFOBJ *psoSrc, ! 337: SURFOBJ *psoMask, ! 338: CLIPOBJ *pco, ! 339: XLATEOBJ *pxlo, ! 340: RECTL *prclTrg, ! 341: POINTL *pptlSrc, ! 342: POINTL *pptlMask, ! 343: BRUSHOBJ *pbo, ! 344: POINTL *pptlBrush, ! 345: ROP4 rop4); ! 346: ! 347: VOID vS3SolidPattern( ! 348: PPDEV ppdev, ! 349: INT left, ! 350: INT top, ! 351: INT width, ! 352: INT height, ! 353: INT color, ! 354: WORD s3Mix); ! 355: ! 356: ! 357: BOOL bPatternBrush( ! 358: SURFOBJ *psoTrg, ! 359: CLIPOBJ *pco, ! 360: RECTL *prclTrg, ! 361: BRUSHOBJ *pbo, ! 362: POINTL *pptlBrush, ! 363: ROP4 rop4); ! 364: ! 365: ! 366: ! 367: /***************************************************************************** ! 368: * S3 (Banked Frame Buffer) DrvCopyBits ! 369: * ! 370: * An I/O through the transfer register take 43 clocks. ! 371: * A Memory access on the S3 takes 23 clocks, the memory window wins, ! 372: * so this transfers bits through the memory window for some things. ! 373: ****************************************************************************/ ! 374: BOOL DrvCopyBits( ! 375: SURFOBJ *psoDest, ! 376: SURFOBJ *psoSrc, ! 377: CLIPOBJ *pco, ! 378: XLATEOBJ *pxlo, ! 379: RECTL *prclDest, ! 380: POINTL *pptlSrc) ! 381: { ! 382: #if defined(_X86_) || defined(i386) ! 383: ! 384: INT cy; ! 385: RECTL rclScans; ! 386: RECTL rclDest, rclTmp; ! 387: SURFOBJ *pso; ! 388: PPDEV ppdev; ! 389: BOOL bRet, bResetBounds; ! 390: ! 391: DISPDBG((3,"S3.DLL!DrvCopyBits - Entry\n")); ! 392: ! 393: bResetBounds = FALSE; ! 394: ! 395: rclDest = *prclDest; ! 396: ! 397: cy = prclDest->bottom - prclDest->top; ! 398: ! 399: if (psoDest->iType == STYPE_DEVICE) ! 400: { ! 401: ppdev = (PPDEV) psoDest->dhsurf; ! 402: ! 403: GPWAIT(); ! 404: ! 405: if (pco == NULL) ! 406: pco = ppdev->pcoDefault; ! 407: ! 408: if (psoSrc->iType == STYPE_DEVICE) ! 409: { ! 410: // At this point we know it's a screen to screen copy. ! 411: // If a color translation needs to be applied then go through ScrnToScrnPuntBlit ! 412: ! 413: if ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)) ! 414: { ! 415: bScrnToScrnWithRop(psoDest, psoSrc, pco, prclDest, pptlSrc, OVERPAINT); ! 416: return (TRUE); ! 417: } ! 418: else ! 419: { ! 420: bRet = bScrnToScrnPuntBlit(psoDest, ! 421: psoSrc, ! 422: NULL, ! 423: pco, ! 424: pxlo, ! 425: prclDest, ! 426: pptlSrc, ! 427: NULL, ! 428: NULL, ! 429: NULL, ! 430: 0x0000CCCC); ! 431: ! 432: return (bRet); ! 433: } ! 434: } ! 435: ! 436: else if (psoSrc->lDelta < 0) ! 437: { ! 438: rclScans.top = prclDest->top; ! 439: rclScans.bottom = rclScans.top + cy; ! 440: ! 441: pso = ppdev->pSurfObj; ! 442: psoDest = pso; ! 443: bBankEnumStart(ppdev, &rclScans, pso, pco); ! 444: } ! 445: ! 446: else ! 447: { ! 448: switch (psoSrc->iBitmapFormat) ! 449: { ! 450: case BMF_DEVICE: ! 451: case BMF_8BPP: ! 452: bRet = b8BppHostToScrnCachedWithRop(psoDest, psoSrc, ! 453: pco, pxlo, ! 454: prclDest, pptlSrc, ! 455: OVERPAINT); ! 456: break; ! 457: ! 458: case BMF_1BPP: ! 459: bRet = b1BppHostToScrnCachedWithRop(psoDest, psoSrc, ! 460: pco, pxlo, ! 461: prclDest, pptlSrc, ! 462: OVERPAINT); ! 463: break; ! 464: ! 465: case BMF_4BPP: ! 466: bRet = b4BppHostToScrnWithRop(psoDest, psoSrc, pco, pxlo, ! 467: prclDest, pptlSrc, OVERPAINT); ! 468: break; ! 469: ! 470: case BMF_16BPP: ! 471: case BMF_24BPP: ! 472: case BMF_32BPP: ! 473: case BMF_4RLE: ! 474: case BMF_8RLE: ! 475: default: ! 476: bRet = FALSE; ! 477: } ! 478: ! 479: if (bRet == TRUE) ! 480: { ! 481: return (TRUE); ! 482: } ! 483: ! 484: rclScans.top = prclDest->top; ! 485: rclScans.bottom = rclScans.top + cy; ! 486: ! 487: pso = ppdev->pSurfObj; ! 488: psoDest = pso; ! 489: bBankEnumStart(ppdev, &rclScans, pso, pco); ! 490: } ! 491: } ! 492: else ! 493: { ! 494: rclScans.top = pptlSrc->y; ! 495: rclScans.bottom = pptlSrc->y + cy; ! 496: ! 497: ppdev = (PPDEV) psoSrc->dhsurf; ! 498: ! 499: GPWAIT(); ! 500: ! 501: if (pco == NULL) ! 502: { ! 503: pco = ppdev->pcoDefault; ! 504: ! 505: // BUGBUG: This mucking around with pcoDefaults's rclBounds is ! 506: // no longer required by bSrcBankEnumStart: ! 507: ! 508: rclTmp = pco->rclBounds; ! 509: pco->rclBounds = *prclDest; ! 510: bResetBounds = TRUE; ! 511: } ! 512: ! 513: pso = ppdev->pSurfObj; ! 514: psoSrc = pso; ! 515: bSrcBankEnumStart(ppdev, &rclScans, pso, pco, prclDest); ! 516: } ! 517: ! 518: do ! 519: { ! 520: bRet = EngCopyBits(psoDest, psoSrc, pco, pxlo, &rclDest, pptlSrc); ! 521: ! 522: } while (bRet && (bBankEnum(ppdev, &rclScans, pso, pco))); ! 523: ! 524: bBankEnumEnd(ppdev, pso, pco); ! 525: ! 526: if (bResetBounds) ! 527: { ! 528: ppdev->pcoDefault->rclBounds = rclTmp; ! 529: } ! 530: ! 531: return(bRet); ! 532: ! 533: #else ! 534: ! 535: // A DrvCopyBits is just a simplified DrvBitBlt: ! 536: ! 537: return(DrvBitBlt(psoDest, ! 538: psoSrc, ! 539: NULL, // psoMask ! 540: pco, ! 541: pxlo, ! 542: prclDest, ! 543: pptlSrc, ! 544: NULL, // pptlMask ! 545: NULL, // pbo ! 546: NULL, // pptlBrush ! 547: 0x0000CCCC)); // mix = SRCCOPY ! 548: ! 549: #endif ! 550: } ! 551: ! 552: ! 553: ! 554: ! 555: /***************************************************************************** ! 556: * S3 DrvBitBlt ! 557: ****************************************************************************/ ! 558: BOOL DrvBitBlt( ! 559: SURFOBJ *psoTrg, ! 560: SURFOBJ *psoSrc, ! 561: SURFOBJ *psoMask, ! 562: CLIPOBJ *pco, ! 563: XLATEOBJ *pxlo, ! 564: RECTL *prclTrg, ! 565: POINTL *pptlSrc, ! 566: POINTL *pptlMask, ! 567: BRUSHOBJ *pbo, ! 568: POINTL *pptlBrush, ! 569: ROP4 rop4) ! 570: ! 571: { ! 572: BOOL b; ! 573: PPDEV ppdev; ! 574: ! 575: DISPDBG((3,"S3.DLL!DrvBitBlt - Entry\n")); ! 576: ! 577: // Since we don't support Device-Format Bitmaps, either the source ! 578: // or the destination (or both) will be the device surface: ! 579: ! 580: if (psoTrg->iType == STYPE_DEVICE) ! 581: ppdev = (PPDEV) psoTrg->dhpdev; ! 582: else ! 583: ppdev = (PPDEV) psoSrc->dhpdev; ! 584: ! 585: // Protect the driver from a potentially NULL clip object. ! 586: ! 587: if (pco == NULL) ! 588: { ! 589: pco = ppdev->pcoDefault; ! 590: } ! 591: ! 592: if (bTest == FALSE) ! 593: { ! 594: b = bSpecialBlits(psoTrg, psoSrc, psoMask, ! 595: pco, pxlo, ! 596: prclTrg, pptlSrc, pptlMask, ! 597: pbo, pptlBrush, ! 598: rop4); ! 599: } ! 600: else ! 601: { ! 602: b = FALSE; ! 603: } ! 604: ! 605: if (b != TRUE) ! 606: { ! 607: bPuntBlit(psoTrg, ! 608: psoSrc, ! 609: psoMask, ! 610: pco, ! 611: pxlo, ! 612: prclTrg, ! 613: pptlSrc, ! 614: pptlMask, ! 615: pbo, ! 616: pptlBrush, ! 617: rop4); ! 618: } ! 619: ! 620: return (TRUE); ! 621: } ! 622: ! 623: /***************************************************************************** ! 624: * S3 General purpose blit handler. This routine will handle any blit. ! 625: * Albeit slow, but it will be handled. ! 626: * ! 627: * Returns TRUE if the blit was handled. ! 628: ****************************************************************************/ ! 629: BOOL bPuntBlit( ! 630: SURFOBJ *psoTrg, ! 631: SURFOBJ *psoSrc, ! 632: SURFOBJ *psoMask, ! 633: CLIPOBJ *pco, ! 634: XLATEOBJ *pxlo, ! 635: RECTL *prclTrg, ! 636: POINTL *pptlSrc, ! 637: POINTL *pptlMask, ! 638: BRUSHOBJ *pbo, ! 639: POINTL *pptlBrush, ! 640: ROP4 rop4) ! 641: { ! 642: ! 643: ! 644: #if defined(_X86_) || defined(i386) ! 645: ! 646: RECTL rclScans; ! 647: RECTL rclTrg; ! 648: PPDEV ppdevTrg, ppdevSrc, ppdevBank; ! 649: SURFOBJ *psoBank; ! 650: BOOL bRet; ! 651: PPDEV ppdev; ! 652: ! 653: DISPDBG((2,"S3.DLL!bPuntBlit - Entry\n")); ! 654: ! 655: if (psoTrg->iType == STYPE_DEVICE) ! 656: ppdev = (PPDEV) psoTrg->dhsurf; ! 657: else ! 658: ppdev = (PPDEV) psoSrc->dhsurf; ! 659: ! 660: // Wait for the S3 coprocessor to finish with the VRAM before we touch it through ! 661: // the apperature. ! 662: ! 663: GPWAIT(); ! 664: ! 665: rclTrg = *prclTrg; ! 666: ! 667: rclScans.top = prclTrg->top; ! 668: rclScans.bottom = prclTrg->bottom; ! 669: ! 670: // Get the correct surface object for the target and the source ! 671: ! 672: if ((psoTrg->iType == STYPE_DEVICE) && ! 673: ((psoSrc == NULL) || (psoSrc->iType != STYPE_DEVICE))) ! 674: { ! 675: ppdevTrg = (PPDEV) psoTrg->dhsurf; ! 676: psoTrg = ppdevTrg->pSurfObj; ! 677: ! 678: bBankEnumStart(ppdevTrg, &rclScans, psoTrg, pco); ! 679: ppdevBank = ppdevTrg; ! 680: psoBank = psoTrg; ! 681: ! 682: } ! 683: ! 684: else if ((psoTrg->iType != STYPE_DEVICE) && ! 685: (psoSrc != NULL) && (psoSrc->iType == STYPE_DEVICE)) ! 686: { ! 687: ppdevSrc = (PPDEV) psoSrc->dhsurf; ! 688: psoSrc = ppdevSrc->pSurfObj; ! 689: ! 690: rclScans.top = pptlSrc->y; ! 691: rclScans.bottom = pptlSrc->y + (prclTrg->bottom - prclTrg->top); ! 692: ! 693: bSrcBankEnumStart(ppdevSrc, &rclScans, psoSrc, pco, prclTrg); ! 694: ppdevBank = ppdevSrc; ! 695: psoBank = psoSrc; ! 696: ! 697: } ! 698: else ! 699: { ! 700: bRet = bScrnToScrnPuntBlit(psoTrg, ! 701: psoSrc, ! 702: psoMask, ! 703: pco, ! 704: pxlo, ! 705: prclTrg, ! 706: pptlSrc, ! 707: pptlMask, ! 708: pbo, ! 709: pptlBrush, ! 710: rop4); ! 711: return (bRet); ! 712: } ! 713: ! 714: do ! 715: { ! 716: bRet = EngBitBlt(psoTrg, ! 717: psoSrc, ! 718: psoMask, ! 719: pco, ! 720: pxlo, ! 721: &rclTrg, ! 722: pptlSrc, ! 723: pptlMask, ! 724: pbo, ! 725: pptlBrush, ! 726: rop4); ! 727: ! 728: } while ((bBankEnum(ppdevBank, &rclScans, psoBank, pco)) && bRet); ! 729: ! 730: bBankEnumEnd(ppdevBank, psoBank, pco); ! 731: ! 732: return bRet; ! 733: ! 734: #else ! 735: ! 736: BOOL bRet; ! 737: PPDEV ppdev; ! 738: RECTL rclSrc; ! 739: ! 740: if (psoTrg->iType == STYPE_DEVICE) ! 741: { ! 742: ppdev = (PPDEV) psoTrg->dhsurf; ! 743: ! 744: if ((psoSrc != NULL) && (psoSrc->iType == STYPE_DEVICE)) ! 745: { ! 746: // ------------------------------------------------------- ! 747: // Handle screen-to-screen blit: ! 748: ! 749: // We have to copy both the source rectangle and the destination ! 750: // rectangle to the temporary bitmap (the destination rectangle ! 751: // is needed if there's complex clipping or if there's a ROP that ! 752: // affects need the destination). ! 753: // ! 754: // We simply copy the smallest entire rectangle containing both ! 755: // the source and the destination rectangles: ! 756: ! 757: rclSrc.left = min(pptlSrc->x, prclTrg->left); ! 758: rclSrc.top = min(pptlSrc->y, prclTrg->top); ! 759: rclSrc.right = max(pptlSrc->x + prclTrg->right - prclTrg->left, ! 760: prclTrg->right); ! 761: rclSrc.bottom = max(pptlSrc->y + prclTrg->bottom - prclTrg->top, ! 762: prclTrg->bottom); ! 763: ! 764: vPuntGetBits(ppdev, psoSrc, &rclSrc); ! 765: ! 766: // Now do the copy entirely on the temporary bitmap surface: ! 767: ! 768: bRet = EngBitBlt(ppdev->psoTemp, ! 769: ppdev->psoTemp, ! 770: psoMask, ! 771: pco, ! 772: pxlo, ! 773: prclTrg, ! 774: pptlSrc, ! 775: pptlMask, ! 776: pbo, ! 777: pptlBrush, ! 778: rop4); ! 779: ! 780: // Just have to copy the destination back to the surface: ! 781: ! 782: if (bRet) ! 783: { ! 784: vPuntPutBits(ppdev, psoTrg, prclTrg); ! 785: } ! 786: } ! 787: else ! 788: { ! 789: // ------------------------------------------------------- ! 790: // Handle bitmap-to-screen blit: ! 791: ! 792: // Make a copy of the destination rectangle in case the ROP ! 793: // modifies the destination: ! 794: ! 795: vPuntGetBits(ppdev, psoTrg, prclTrg); ! 796: ! 797: // Do the blit operation on the temporary bitmap: ! 798: ! 799: bRet = EngBitBlt(ppdev->psoTemp, ! 800: psoSrc, ! 801: psoMask, ! 802: pco, ! 803: pxlo, ! 804: prclTrg, ! 805: pptlSrc, ! 806: pptlMask, ! 807: pbo, ! 808: pptlBrush, ! 809: rop4); ! 810: ! 811: // Copy everything back to the surface: ! 812: ! 813: if (bRet) ! 814: { ! 815: vPuntPutBits(ppdev, psoTrg, prclTrg); ! 816: } ! 817: } ! 818: } ! 819: else ! 820: { ! 821: // ------------------------------------------------------- ! 822: // Handle screen-to-bitmap blit: ! 823: ! 824: ppdev = (PPDEV) psoSrc->dhsurf; ! 825: ! 826: // Copy the source rectangle to the temporary bitmap, then get ! 827: // GDI to blit to the target surface: ! 828: ! 829: rclSrc.left = pptlSrc->x; ! 830: rclSrc.top = pptlSrc->y; ! 831: rclSrc.right = pptlSrc->x + (prclTrg->right - prclTrg->left); ! 832: rclSrc.bottom = pptlSrc->y + (prclTrg->bottom - prclTrg->top); ! 833: ! 834: vPuntGetBits(ppdev, psoSrc, &rclSrc); ! 835: ! 836: bRet = EngBitBlt(psoTrg, ! 837: ppdev->psoTemp, ! 838: psoMask, ! 839: pco, ! 840: pxlo, ! 841: prclTrg, ! 842: pptlSrc, ! 843: pptlMask, ! 844: pbo, ! 845: pptlBrush, ! 846: rop4); ! 847: } ! 848: ! 849: vResetS3Clipping(ppdev); // Always reset after using vPunt routines ! 850: ! 851: return(bRet); ! 852: ! 853: #endif ! 854: } ! 855: ! 856: /****************************************************************************** ! 857: * bScrnToScrnPuntBlit - Screen To Screen Punt Blit ! 858: *****************************************************************************/ ! 859: BOOL bScrnToScrnPuntBlit( ! 860: SURFOBJ *psoTrg, ! 861: SURFOBJ *psoSrc, ! 862: SURFOBJ *psoMask, ! 863: CLIPOBJ *pco, ! 864: XLATEOBJ *pxlo, ! 865: RECTL *prclTrg, ! 866: POINTL *pptlSrc, ! 867: POINTL *pptlMask, ! 868: BRUSHOBJ *pbo, ! 869: POINTL *pptlBrush, ! 870: ROP4 rop4) ! 871: { ! 872: ! 873: SIZEL sizl; ! 874: HSURF hsurfBm; ! 875: SURFOBJ *psoTempSrc; ! 876: WORD cmd; ! 877: INT i, cxInWords; ! 878: PBYTE pb; ! 879: PWORD pw; ! 880: PPDEV ppdev; ! 881: RECTL rclScans, rclTrg; ! 882: BOOL bRet; ! 883: POINTL ptlTempSrc; ! 884: ! 885: DISPDBG((2,"S3.DLL!bScrnToScrnPuntBlit - Entry\n")); ! 886: ! 887: // Pickup our pdev and a pointer to the surface object. ! 888: ! 889: ppdev = (PPDEV) psoTrg->dhsurf; ! 890: psoTrg = ppdev->pSurfObj; ! 891: ! 892: // Set the default bounding rectangle for the bank manager. ! 893: ! 894: rclTrg = *prclTrg; ! 895: ! 896: // Create a temporary surface and bitmap. ! 897: ! 898: sizl.cx = prclTrg->right - prclTrg->left; ! 899: sizl.cy = prclTrg->bottom - prclTrg->top; ! 900: ! 901: hsurfBm = (HSURF) EngCreateBitmap(sizl, ! 902: sizl.cx, ! 903: BMF_8BPP, ! 904: BMF_TOPDOWN, ! 905: NULL); ! 906: if (hsurfBm == NULL) ! 907: { ! 908: DISPDBG((0, "S3.DLL!bScrnToScrnPuntBlit - EngCreateBitmap failed\n")); ! 909: return(FALSE); ! 910: } ! 911: ! 912: // Get a pointer to the surface object. ! 913: ! 914: psoTempSrc = EngLockSurface(hsurfBm); ! 915: ! 916: // Copy the bits into it. ! 917: ! 918: if (!(sizl.cx & 0x01)) ! 919: { ! 920: cmd = RECTANGLE_FILL | BYTE_SWAP | BUS_SIZE_16 | ! 921: DRAWING_DIR_TBLRXM | DIR_TYPE_XY | WAIT | ! 922: DRAW | LAST_PIXEL_ON | READ; ! 923: } ! 924: else ! 925: { ! 926: cmd = RECTANGLE_FILL | BUS_SIZE_8 | ! 927: DRAWING_DIR_TBLRXM | DIR_TYPE_XY | WAIT | ! 928: DRAW | LAST_PIXEL_ON | READ; ! 929: } ! 930: ! 931: FIFOWAIT(FIFO_7_EMPTY); ! 932: ! 933: TEST_AND_SET_RD_MASK(0xff); ! 934: OUTPW (MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 935: ! 936: OUTPW (CUR_X, pptlSrc->x); ! 937: OUTPW (CUR_Y, pptlSrc->y); ! 938: OUTPW (RECT_WIDTH, (sizl.cx - 1)); ! 939: OUTPW (MULTIFUNC_CNTL, (RECT_HEIGHT | (sizl.cy - 1))); ! 940: ! 941: GPWAIT(); ! 942: ! 943: OUTPW (CMD, cmd); ! 944: ! 945: // Wait for the Data Available. ! 946: ! 947: while (!(inpw(GP_STAT) & READ_DATA_AVAILABLE)); ! 948: ! 949: // Now transfer the data from the screen to the host memory bitmap. ! 950: ! 951: if (!(sizl.cx & 0x01)) ! 952: { ! 953: cxInWords = (sizl.cx + 1) / 2; ! 954: pw = (PWORD) psoTempSrc->pvScan0; ! 955: for (i = 0; i < sizl.cy; i++) ! 956: { ! 957: vDataPortIn(ppdev, pw, cxInWords); ! 958: ((PBYTE) pw) += psoTempSrc->lDelta; ! 959: } ! 960: } ! 961: else ! 962: { ! 963: pb = psoTempSrc->pvScan0; ! 964: for (i = 0; i < sizl.cy; i++) ! 965: { ! 966: vDataPortInB(ppdev, pb, sizl.cx); ! 967: pb += psoTempSrc->lDelta; ! 968: } ! 969: } ! 970: ! 971: // Set the new source position ! 972: ! 973: ptlTempSrc.x = 0; ! 974: ptlTempSrc.y = 0; ! 975: ! 976: // Do the banked blit operation. ! 977: ! 978: rclScans.top = prclTrg->top; ! 979: rclScans.bottom = prclTrg->bottom; ! 980: ! 981: bBankEnumStart(ppdev, &rclScans, psoTrg, pco); ! 982: ! 983: do ! 984: { ! 985: bRet = EngBitBlt(psoTrg, ! 986: psoTempSrc, ! 987: psoMask, ! 988: pco, ! 989: pxlo, ! 990: &rclTrg, ! 991: &ptlTempSrc, ! 992: pptlMask, ! 993: pbo, ! 994: pptlBrush, ! 995: rop4); ! 996: ! 997: } while ((bBankEnum(ppdev, &rclScans, psoTrg, pco)) && bRet); ! 998: ! 999: bBankEnumEnd(ppdev, psoTrg, pco); ! 1000: ! 1001: // free the temp bitmap. ! 1002: ! 1003: EngUnlockSurface(psoTempSrc); ! 1004: EngDeleteSurface(hsurfBm); ! 1005: ! 1006: return (bRet); ! 1007: ! 1008: } ! 1009: ! 1010: /***************************************************************************** ! 1011: * S3 Special case Blit handler ! 1012: * ! 1013: * Returns TRUE if the blit was handled. ! 1014: ****************************************************************************/ ! 1015: BOOL bSpecialBlits( ! 1016: SURFOBJ *psoTrg, ! 1017: SURFOBJ *psoSrc, ! 1018: SURFOBJ *psoMask, ! 1019: CLIPOBJ *pco, ! 1020: XLATEOBJ *pxlo, ! 1021: RECTL *prclTrg, ! 1022: POINTL *pptlSrc, ! 1023: POINTL *pptlMask, ! 1024: BRUSHOBJ *pbo, ! 1025: POINTL *pptlBrush, ! 1026: ROP4 rop4) ! 1027: { ! 1028: BOOL bRet; ! 1029: PPDEV ppdev; ! 1030: ROP4 s3Rop4; ! 1031: WORD avecRop, s3Rop; ! 1032: BRUSHOBJ bo; ! 1033: ! 1034: bRet = FALSE; ! 1035: ! 1036: if (psoTrg->iType == STYPE_DEVICE) ! 1037: ppdev = (PPDEV) psoTrg->dhsurf; ! 1038: else ! 1039: ppdev = (PPDEV) psoSrc->dhsurf; ! 1040: ! 1041: // NOTE: If the ForeRop and BackRop are the same implicitly ! 1042: // there is no mask. ! 1043: ! 1044: // First test for copy opperations. ! 1045: ! 1046: if (rop4 == 0x0000CCCC) ! 1047: { ! 1048: if ((psoTrg->iType == STYPE_DEVICE) && (psoSrc->iType == STYPE_DEVICE)) ! 1049: { ! 1050: if ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)) ! 1051: { ! 1052: bRet = bScrnToScrnWithRop(psoTrg, psoSrc, pco, prclTrg, pptlSrc, OVERPAINT); ! 1053: return(bRet); ! 1054: } ! 1055: else ! 1056: { ! 1057: return (FALSE); ! 1058: } ! 1059: } ! 1060: ! 1061: } ! 1062: ! 1063: // Check for a mask. If there is one, at this time, reject the ! 1064: // acceleration. ! 1065: ! 1066: if (psoMask != NULL) ! 1067: { ! 1068: return (FALSE); ! 1069: } ! 1070: ! 1071: // If the background and foreground rops are not the same ! 1072: // reject the blit. ! 1073: ! 1074: if (((rop4 & 0xFF00) >> 8) != (rop4 & 0xff)) ! 1075: { ! 1076: return (FALSE); ! 1077: } ! 1078: ! 1079: // Pickup the avec for some quick decision later. ! 1080: ! 1081: avecRop = gajRop[(rop4 & 0xff)]; ! 1082: ! 1083: // Check for a DIB. If this is a DIB reject the blit. ! 1084: // BUGBUG: At some future date (post BETA2) this should be optimized. ! 1085: ! 1086: if ((avecRop & AVEC_NEED_SOURCE) && (psoSrc->lDelta < 0)) ! 1087: { ! 1088: return (FALSE); ! 1089: } ! 1090: ! 1091: // Check for whitness or blackness ! 1092: ! 1093: if (((rop4 & 0xff) == 0xff) || ! 1094: ((rop4 & 0xff) == 0x00)) ! 1095: { ! 1096: if ((rop4 & 0xff) == 0xff) ! 1097: s3Rop4 = LOGICAL_1; ! 1098: else ! 1099: s3Rop4 = LOGICAL_0; ! 1100: ! 1101: bRet = bPatternSolid(psoTrg, psoSrc, psoMask, ! 1102: pco, pxlo, ! 1103: prclTrg, pptlSrc, pptlMask, ! 1104: pbo, pptlBrush, ! 1105: s3Rop4); ! 1106: return (bRet); ! 1107: } ! 1108: ! 1109: // Check for Dest Invert ! 1110: ! 1111: if ((rop4 & 0xff) == 0x55) ! 1112: { ! 1113: s3Rop4 = SCREEN_XOR_NEW; ! 1114: bo.iSolidColor = 0xffff; ! 1115: ! 1116: bRet = bPatternSolid(psoTrg, psoSrc, psoMask, ! 1117: pco, pxlo, ! 1118: prclTrg, pptlSrc, pptlMask, ! 1119: &bo, pptlBrush, ! 1120: s3Rop4); ! 1121: return (bRet); ! 1122: ! 1123: } ! 1124: ! 1125: ! 1126: // Check for brushes. ! 1127: ! 1128: if ((avecRop & AVEC_NEED_PATTERN) && (!(avecRop & AVEC_NEED_SOURCE))) ! 1129: { ! 1130: // Translate the rop from GDI to S3. ! 1131: ! 1132: s3Rop4 = bXlatePatRop4toS3Rop(ppdev, rop4); ! 1133: ! 1134: // Check for a Solid Brush. ! 1135: ! 1136: if (pbo == NULL || pbo->iSolidColor != -1) ! 1137: { ! 1138: bRet = bPatternSolid(psoTrg, psoSrc, psoMask, ! 1139: pco, pxlo, ! 1140: prclTrg, pptlSrc, pptlMask, ! 1141: pbo, pptlBrush, ! 1142: s3Rop4); ! 1143: } ! 1144: ! 1145: // Handle this as a Pattern Brush. ! 1146: ! 1147: else ! 1148: { ! 1149: bRet = bPatternBrush(psoTrg, pco, prclTrg, pbo, pptlBrush, s3Rop4); ! 1150: } ! 1151: ! 1152: } ! 1153: ! 1154: // Check if we may be able to optimize for screen to screen or ! 1155: // host to screen blits. ! 1156: ! 1157: else if ((!(avecRop & AVEC_NEED_PATTERN)) && ! 1158: (avecRop & AVEC_NEED_SOURCE)) ! 1159: { ! 1160: s3Rop = wXlateSrcRop3toS3Rop(ppdev, LOWORD(rop4)); ! 1161: if (s3Rop != 0) ! 1162: { ! 1163: if ((psoTrg->iType == STYPE_DEVICE) && ! 1164: (psoSrc->iType == STYPE_DEVICE) && ! 1165: ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL))) ! 1166: { ! 1167: bRet = bScrnToScrnWithRop(psoTrg, psoSrc, pco, prclTrg, ! 1168: pptlSrc, s3Rop); ! 1169: } ! 1170: else if (psoSrc->iType == STYPE_BITMAP) ! 1171: { ! 1172: switch (psoSrc->iBitmapFormat) ! 1173: { ! 1174: case BMF_DEVICE: ! 1175: case BMF_8BPP: ! 1176: bRet = b8BppHostToScrnCachedWithRop(psoTrg, ! 1177: psoSrc, ! 1178: pco, ! 1179: pxlo, ! 1180: prclTrg, ! 1181: pptlSrc, ! 1182: s3Rop); ! 1183: break; ! 1184: ! 1185: case BMF_1BPP: ! 1186: bRet = b1BppHostToScrnCachedWithRop(psoTrg, ! 1187: psoSrc, ! 1188: pco, ! 1189: pxlo, ! 1190: prclTrg, ! 1191: pptlSrc, ! 1192: s3Rop); ! 1193: break; ! 1194: ! 1195: case BMF_4BPP: ! 1196: bRet = b4BppHostToScrnWithRop(psoTrg, ! 1197: psoSrc, ! 1198: pco, ! 1199: pxlo, ! 1200: prclTrg, ! 1201: pptlSrc, ! 1202: s3Rop); ! 1203: break; ! 1204: ! 1205: case BMF_16BPP: ! 1206: case BMF_24BPP: ! 1207: case BMF_32BPP: ! 1208: case BMF_4RLE: ! 1209: case BMF_8RLE: ! 1210: default: ! 1211: bRet = FALSE; ! 1212: break; ! 1213: } ! 1214: } ! 1215: } ! 1216: ! 1217: else ! 1218: { ! 1219: DISPDBG((0,"S3.DLL!bSpecialBlits - Missed SrcBlt opportunity - rop: 0x%x\n", ! 1220: rop4)); ! 1221: } ! 1222: } ! 1223: ! 1224: else if ((rop4 & 0xff) == 0xc0) // Merge Copy ! 1225: { ! 1226: if ((psoTrg->iType == STYPE_DEVICE) && ! 1227: (psoSrc->iType == STYPE_DEVICE) && ! 1228: ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL))) ! 1229: ! 1230: { ! 1231: bRet = bScrnToScrnWithRop(psoTrg, psoSrc, ! 1232: pco, prclTrg, pptlSrc, ! 1233: OVERPAINT); ! 1234: ! 1235: if (bRet) ! 1236: { ! 1237: if (pbo == NULL || pbo->iSolidColor != -1) ! 1238: { ! 1239: bRet = bPatternSolid(psoTrg, psoSrc, psoMask, ! 1240: pco, pxlo, ! 1241: prclTrg, pptlSrc, pptlMask, ! 1242: pbo, pptlBrush, ! 1243: SCREEN_AND_NEW); ! 1244: } ! 1245: else ! 1246: { ! 1247: bRet = bPatternBrush(psoTrg, pco, prclTrg, ! 1248: pbo, pptlBrush, ! 1249: (SCREEN_AND_NEW << 8) | SCREEN_AND_NEW); ! 1250: } ! 1251: } ! 1252: } ! 1253: else if (psoSrc->iType == STYPE_BITMAP) ! 1254: { ! 1255: switch (psoSrc->iBitmapFormat) ! 1256: { ! 1257: case BMF_DEVICE: ! 1258: case BMF_8BPP: ! 1259: bRet = b8BppHostToScrnCachedWithRop(psoTrg, ! 1260: psoSrc, ! 1261: pco, ! 1262: pxlo, ! 1263: prclTrg, ! 1264: pptlSrc, ! 1265: OVERPAINT); ! 1266: break; ! 1267: ! 1268: case BMF_1BPP: ! 1269: bRet = b1BppHostToScrnCachedWithRop(psoTrg, ! 1270: psoSrc, ! 1271: pco, ! 1272: pxlo, ! 1273: prclTrg, ! 1274: pptlSrc, ! 1275: OVERPAINT); ! 1276: break; ! 1277: ! 1278: case BMF_4BPP: ! 1279: bRet = b4BppHostToScrnWithRop(psoTrg, ! 1280: psoSrc, ! 1281: pco, ! 1282: pxlo, ! 1283: prclTrg, ! 1284: pptlSrc, ! 1285: OVERPAINT); ! 1286: break; ! 1287: ! 1288: case BMF_16BPP: ! 1289: case BMF_24BPP: ! 1290: case BMF_32BPP: ! 1291: case BMF_4RLE: ! 1292: case BMF_8RLE: ! 1293: default: ! 1294: bRet = FALSE; ! 1295: break; ! 1296: } ! 1297: ! 1298: if (bRet) ! 1299: { ! 1300: if (pbo == NULL || pbo->iSolidColor != -1) ! 1301: { ! 1302: bRet = bPatternSolid(psoTrg, psoSrc, psoMask, ! 1303: pco, pxlo, ! 1304: prclTrg, pptlSrc, pptlMask, ! 1305: pbo, pptlBrush, ! 1306: SCREEN_AND_NEW); ! 1307: } ! 1308: else ! 1309: { ! 1310: bRet = bPatternBrush(psoTrg, pco, prclTrg, ! 1311: pbo, pptlBrush, ! 1312: (SCREEN_AND_NEW << 8) | SCREEN_AND_NEW); ! 1313: } ! 1314: } ! 1315: } ! 1316: } ! 1317: ! 1318: ! 1319: ! 1320: return (bRet); ! 1321: } ! 1322: ! 1323: ! 1324: /***************************************************************************** ! 1325: * S3 Screen to Screen with a Rop ! 1326: * ! 1327: * Returns TRUE if the blit was handled. ! 1328: ****************************************************************************/ ! 1329: BOOL bScrnToScrnWithRop( ! 1330: SURFOBJ *psoTrg, ! 1331: SURFOBJ *psoSrc, ! 1332: CLIPOBJ *pco, ! 1333: RECTL *prclTrg, ! 1334: POINTL *pptlSrc, ! 1335: WORD s3Rop) ! 1336: { ! 1337: INT width, height, xTrg, yTrg, xSrc, ySrc, cx, cy; ! 1338: WORD cmd, wDirCode; ! 1339: RECTL rclSrc, rclTrg; ! 1340: ULONG DirClip; ! 1341: BOOL bMore, bIntersect, bClipRequired; ! 1342: UINT i; ! 1343: ENUMRECTS8 EnumRects8; ! 1344: PPDEV ppdev; ! 1345: RECTL rclBounds; ! 1346: BYTE iDComplexity; ! 1347: ! 1348: // Get the pdev. ! 1349: ! 1350: ppdev = (PPDEV) psoTrg->dhpdev; ! 1351: ! 1352: // There are two completely different code paths. ! 1353: // for the complex and non-complex clip cases. ! 1354: // This is because most of the direction and intersection ! 1355: // calculations need to be done after the clipping. ! 1356: ! 1357: if ((iDComplexity = pco->iDComplexity) != DC_COMPLEX) ! 1358: { ! 1359: // Make a copy of the target, since we will have to change ! 1360: // it for clipping. ! 1361: ! 1362: rclTrg = *prclTrg; ! 1363: ! 1364: if (iDComplexity == DC_RECT) ! 1365: { ! 1366: rclBounds = pco->rclBounds; ! 1367: ! 1368: // First handle the trivial rejection. ! 1369: ! 1370: bClipRequired = bIntersectTest(&rclTrg, &rclBounds); ! 1371: ! 1372: // define the clipped target rectangle. ! 1373: ! 1374: if (bClipRequired) ! 1375: { ! 1376: rclTrg.left = max (rclTrg.left, rclBounds.left); ! 1377: rclTrg.top = max (rclTrg.top, rclBounds.top); ! 1378: rclTrg.right = min (rclTrg.right, rclBounds.right); ! 1379: rclTrg.bottom = min (rclTrg.bottom, rclBounds.bottom); ! 1380: } ! 1381: else ! 1382: { ! 1383: // The destination rectangle is completely clipped out, ! 1384: // so just return. ! 1385: ! 1386: return (TRUE); ! 1387: } ! 1388: } ! 1389: ! 1390: // define the cx & cy. ! 1391: ! 1392: width = (rclTrg.right - rclTrg.left) - 1; ! 1393: height = (rclTrg.bottom - rclTrg.top) - 1; ! 1394: ! 1395: // calculate the cx & cy shift for the source. ! 1396: ! 1397: cx = rclTrg.left - prclTrg->left; ! 1398: cy = rclTrg.top - prclTrg->top; ! 1399: ! 1400: // define the source rectangle. ! 1401: ! 1402: rclSrc.left = pptlSrc->x + cx; ! 1403: rclSrc.top = pptlSrc->y + cy; ! 1404: rclSrc.right = pptlSrc->x + width + 1; ! 1405: rclSrc.bottom = pptlSrc->y + height + 1; ! 1406: ! 1407: // Determine the direction of the blit. ! 1408: // First, check for an intersection of the souce and dest rects. ! 1409: ! 1410: bIntersect = bIntersectTest(&rclTrg, &rclSrc); ! 1411: ! 1412: // Set defaults for the S3 blit direction and the ! 1413: // initial coordinates ! 1414: ! 1415: wDirCode = DRAWING_DIR_TBLRXM; ! 1416: ! 1417: xTrg = rclTrg.left; ! 1418: yTrg = rclTrg.top; ! 1419: xSrc = rclSrc.left; ! 1420: ySrc = rclSrc.top; ! 1421: ! 1422: // If the source & dest rects intersect adjust the ! 1423: // blit direction and initial coordinates. ! 1424: ! 1425: if (bIntersect) ! 1426: { ! 1427: // The horizontal copy direction. ! 1428: ! 1429: if (rclTrg.left > rclSrc.left) ! 1430: { ! 1431: // R to L ! 1432: ! 1433: xTrg = rclTrg.right - 1; ! 1434: xSrc = rclSrc.left + width; ! 1435: wDirCode &= ~PLUS_X; ! 1436: } ! 1437: ! 1438: // The vertical copy direction. ! 1439: ! 1440: if (rclTrg.top > rclSrc.top) ! 1441: { ! 1442: // B to T ! 1443: ! 1444: yTrg = rclTrg.bottom - 1; ! 1445: ySrc = rclSrc.top + height; ! 1446: wDirCode &= ~PLUS_Y; ! 1447: } ! 1448: } ! 1449: ! 1450: // Create the S3 Command. ! 1451: ! 1452: cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE; ! 1453: cmd |= wDirCode; ! 1454: ! 1455: // Do the blit. ! 1456: ! 1457: S3ScrnToScrnBlt(ppdev, xSrc, ySrc, xTrg, yTrg, width, height, s3Rop, cmd); ! 1458: ! 1459: } ! 1460: else ! 1461: { ! 1462: // This a complex clip. ! 1463: ! 1464: DirClip = CD_ANY; ! 1465: wDirCode = DRAWING_DIR_TBLRXM; ! 1466: ! 1467: if (prclTrg->left > pptlSrc->x) ! 1468: wDirCode &= ~PLUS_X; ! 1469: ! 1470: if (prclTrg->top > pptlSrc->y) ! 1471: wDirCode &= ~PLUS_Y; ! 1472: ! 1473: switch (wDirCode) ! 1474: { ! 1475: case DRAWING_DIR_TBLRXM: ! 1476: DirClip = CD_RIGHTDOWN; ! 1477: break; ! 1478: ! 1479: case DRAWING_DIR_TBRLXM: ! 1480: DirClip = CD_LEFTDOWN; ! 1481: break; ! 1482: ! 1483: case DRAWING_DIR_BTLRXM: ! 1484: DirClip = CD_RIGHTUP; ! 1485: break; ! 1486: ! 1487: case DRAWING_DIR_BTRLXM: ! 1488: DirClip = CD_LEFTUP; ! 1489: break; ! 1490: } ! 1491: ! 1492: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, DirClip, 0); ! 1493: ! 1494: do ! 1495: { ! 1496: bMore = CLIPOBJ_bEnum(pco, sizeof (ENUMRECTS8), ! 1497: (PULONG) &EnumRects8); ! 1498: ! 1499: for (i = 0; i < EnumRects8.c; i++) ! 1500: { ! 1501: rclTrg = *prclTrg; ! 1502: rclBounds = EnumRects8.arcl[i]; ! 1503: ! 1504: // handle the trivial rejection. ! 1505: ! 1506: bClipRequired = bIntersectTest(&rclTrg, &rclBounds); ! 1507: ! 1508: // define the clipped target rectangle. ! 1509: ! 1510: if (bClipRequired) ! 1511: { ! 1512: rclTrg.left = max (rclTrg.left, rclBounds.left); ! 1513: rclTrg.top = max (rclTrg.top, rclBounds.top); ! 1514: rclTrg.right = min (rclTrg.right, rclBounds.right); ! 1515: rclTrg.bottom = min (rclTrg.bottom, rclBounds.bottom); ! 1516: } ! 1517: else ! 1518: { ! 1519: // The destination rectangle is completely clipped out, ! 1520: // so use as an early out. ! 1521: ! 1522: continue; ! 1523: } ! 1524: ! 1525: // define the cx & cy. ! 1526: ! 1527: width = (rclTrg.right - rclTrg.left) - 1; ! 1528: height = (rclTrg.bottom - rclTrg.top) - 1; ! 1529: ! 1530: // calculate the cx & cy shift for the source. ! 1531: ! 1532: cx = rclTrg.left - prclTrg->left; ! 1533: cy = rclTrg.top - prclTrg->top; ! 1534: ! 1535: // define the source rectangle. ! 1536: ! 1537: rclSrc.left = pptlSrc->x + cx; ! 1538: rclSrc.top = pptlSrc->y + cy; ! 1539: rclSrc.right = rclSrc.left + width + 1; ! 1540: rclSrc.bottom = rclSrc.top + height + 1; ! 1541: ! 1542: // Determine the direction of the blit. ! 1543: // First, check for an intersection of the souce and dest rects. ! 1544: ! 1545: bIntersect = bIntersectTest(&rclTrg, &rclSrc); ! 1546: ! 1547: // Set defaults for the S3 blit direction and the ! 1548: // initial coordinates ! 1549: ! 1550: wDirCode = DRAWING_DIR_TBLRXM; ! 1551: ! 1552: xTrg = rclTrg.left; ! 1553: yTrg = rclTrg.top; ! 1554: xSrc = rclSrc.left; ! 1555: ySrc = rclSrc.top; ! 1556: ! 1557: // If the source & dest rects intersect adjust the ! 1558: // blit direction and initial coordinates. ! 1559: ! 1560: if (bIntersect) ! 1561: { ! 1562: // The horizontal copy direction. ! 1563: ! 1564: if (rclTrg.left > rclSrc.left) ! 1565: { ! 1566: // R to L ! 1567: ! 1568: xTrg = rclTrg.right - 1; ! 1569: xSrc = rclSrc.left + width; ! 1570: wDirCode &= ~PLUS_X; ! 1571: } ! 1572: ! 1573: // The vertical copy direction. ! 1574: ! 1575: if (rclTrg.top > rclSrc.top) ! 1576: { ! 1577: // B to T ! 1578: ! 1579: yTrg = rclTrg.bottom - 1; ! 1580: ySrc = rclSrc.top + height; ! 1581: wDirCode &= ~PLUS_Y; ! 1582: } ! 1583: } ! 1584: ! 1585: // Create the S3 Command. ! 1586: ! 1587: cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE; ! 1588: cmd |= wDirCode; ! 1589: ! 1590: // Do the blit. ! 1591: ! 1592: S3ScrnToScrnBlt(ppdev, xSrc, ySrc, xTrg, yTrg, width, height, s3Rop, cmd); ! 1593: ! 1594: } ! 1595: ! 1596: } while (bMore); ! 1597: } ! 1598: return(TRUE); ! 1599: } ! 1600: ! 1601: ! 1602: /***************************************************************************** ! 1603: * S3ScrnToScrnBlt ! 1604: ****************************************************************************/ ! 1605: VOID S3ScrnToScrnBlt( ! 1606: PPDEV ppdev, ! 1607: INT xSrc, ! 1608: INT ySrc, ! 1609: INT xTrg, ! 1610: INT yTrg, ! 1611: INT width, ! 1612: INT height, ! 1613: WORD s3Rop, ! 1614: WORD cmd) ! 1615: { ! 1616: ! 1617: #if DBG ! 1618: ! 1619: if (cmd & 0x20) ! 1620: { ! 1621: ASSERTS3(((xTrg + width) < (INT) ppdev->cxScreen), ! 1622: "S3.DLL!S3ScrnToScrnBlt - Blit Operation over right edge (1)\n"); ! 1623: } ! 1624: ! 1625: #endif ! 1626: // This is where the actual S3 registers are set. ! 1627: ! 1628: FIFOWAIT(FIFO_2_EMPTY); ! 1629: ! 1630: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | s3Rop); ! 1631: ! 1632: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 1633: ! 1634: FIFOWAIT(FIFO_7_EMPTY); ! 1635: ! 1636: OUTPW(RECT_WIDTH, width); ! 1637: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | height)); ! 1638: OUTPW(CUR_X, xSrc); ! 1639: OUTPW(CUR_Y, ySrc); ! 1640: OUTPW(DEST_X, xTrg); ! 1641: OUTPW(DEST_Y, yTrg); ! 1642: ! 1643: OUTPW(CMD, cmd); ! 1644: } ! 1645: ! 1646: ! 1647: /***************************************************************************** ! 1648: * S3 Brush Pattern ! 1649: * ! 1650: * Returns TRUE if the blit was handled. ! 1651: ****************************************************************************/ ! 1652: BOOL bPatternBrush( ! 1653: SURFOBJ *psoTrg, ! 1654: CLIPOBJ *pco, ! 1655: RECTL *prclTrg, ! 1656: BRUSHOBJ *pbo, ! 1657: POINTL *pptlBrush, ! 1658: ROP4 s3Rop4) // Note that the least significant byte is ! 1659: // the S3 foreground ROP, and the next byte ! 1660: // is the S3 background ROP. So you can't ! 1661: // just pass in a plain S3 ROP constant! ! 1662: ! 1663: { ! 1664: PPDEV ppdev; ! 1665: PS3BRUSH ps3Brush; ! 1666: POINT pt; ! 1667: XYZPOINT xyzPt; ! 1668: INT zHorz, zVert, i; ! 1669: POINT ptDest; ! 1670: SIZE sizDest; ! 1671: WORD s3ForeRop, s3BackRop; ! 1672: BOOL bClipRequired, bMore; ! 1673: RECTL rclTrg, rclBounds; ! 1674: BYTE iDComplexity; ! 1675: ENUMRECTS8 EnumRects8; ! 1676: ! 1677: DISPDBG((3, "S3.DLL!bPatternBrush - Entry\n")); ! 1678: ! 1679: // Get the pdev. ! 1680: ! 1681: ppdev = (PPDEV) psoTrg->dhpdev; ! 1682: ! 1683: // Get the pointer to our drivers realization of the brush. ! 1684: ! 1685: if (pbo->pvRbrush != NULL) ! 1686: { ! 1687: ps3Brush = pbo->pvRbrush; ! 1688: } ! 1689: else ! 1690: { ! 1691: ps3Brush = BRUSHOBJ_pvGetRbrush(pbo); ! 1692: ! 1693: // Fail if we do not handle the brush. ! 1694: ! 1695: if (ps3Brush == NULL) ! 1696: return (FALSE); ! 1697: } ! 1698: ! 1699: s3ForeRop = (WORD) (s3Rop4 & 0xFF); ! 1700: s3BackRop = (WORD) ((s3Rop4 >> 8) & 0xFF); ! 1701: ! 1702: if (ps3Brush->iBitmapFormat == BMF_1BPP) ! 1703: { ! 1704: DISPDBG((3, "S3.DLL!bPatternBrush - 1BPP brush\n")); ! 1705: ! 1706: // If we have never seen this brush before then allocate a slot ! 1707: // for it. ! 1708: ! 1709: // Keep a count of number of brushes we have seen. ! 1710: // This will be used to determine if the cache system is adaquate. ! 1711: ! 1712: nMonoBrushes++; ! 1713: ! 1714: // If we have never seen this brush before or if the cache has ! 1715: // changed since the last time ! 1716: // we have seen it then allocate a new cache entry for it. ! 1717: ! 1718: if ((ps3Brush->iBrushCacheID == -1) || ! 1719: (ps3Brush->iPatternID != ppdev->pulMonoBrushCacheEntries[ps3Brush->iBrushCacheID])) ! 1720: { ! 1721: // If we have run out of cache entries invalidate the entire cache. ! 1722: ! 1723: if (ppdev->iNextMonoBrushCacheSlot >= ppdev->iMaxCachedMonoBrushes) ! 1724: { ! 1725: nMonoBrushCacheInvalidations++; ! 1726: ! 1727: memset(ppdev->pulMonoBrushCacheEntries, 0, ppdev->iMaxCachedMonoBrushes * sizeof(ULONG)); ! 1728: ppdev->iNextMonoBrushCacheSlot = 0; ! 1729: } ! 1730: ! 1731: // Get a slot in the cache for this brush. ! 1732: ! 1733: i = (ppdev->iNextMonoBrushCacheSlot)++; ! 1734: ps3Brush->iBrushCacheID = i; ! 1735: ! 1736: // Calculate the address of the brush in the cache. ! 1737: ! 1738: xyzPt.x = MONO_PATTERN_CACHE_X + ((i >> 3) * 16); ! 1739: xyzPt.y = MONO_PATTERN_CACHE_Y; ! 1740: xyzPt.z = ajMonoPatPlanes[i & 0x7]; ! 1741: ! 1742: // Associate the brush with this cache entry. ! 1743: ! 1744: ppdev->pulMonoBrushCacheEntries[i] = ps3Brush->iPatternID; ! 1745: ! 1746: // Get an expansion cache slot for this brush. ! 1747: ! 1748: i = ppdev->iNextMonoBrushExpansionSlot; ! 1749: i = ++i % MAX_MONO_BRUSH_EXPANSION_SLOTS; ! 1750: ppdev->iNextMonoBrushExpansionSlot = i; ! 1751: ps3Brush->iExpansionCacheID = i; ! 1752: ! 1753: // Associate this brush with this expansion cache slot. ! 1754: ! 1755: ppdev->aulMonoExpansionCacheTag[i] = ps3Brush->iPatternID; ! 1756: ! 1757: // Set the expansion caches planes ! 1758: ! 1759: zHorz = zVert = ajMonoPatPlanes[i]; ! 1760: ! 1761: // Down load the brush to the cache and expand it into ! 1762: // the horizontal and vertical caches. ! 1763: ! 1764: bDownLoadBrushIntoMonoCache(ppdev, ps3Brush, &xyzPt); ! 1765: bExpandMonoBrushIntoHorzCache(ppdev, &xyzPt, zHorz); ! 1766: bExpandMonoBrushIntoVertCache(ppdev, &xyzPt, zVert); ! 1767: ! 1768: } ! 1769: else ! 1770: { ! 1771: // We got a cache hit, so keep the statistic. ! 1772: ! 1773: nMonoBrushCacheHit++; ! 1774: ! 1775: // Calculate the address of the brush in the cache. ! 1776: ! 1777: i = ps3Brush->iBrushCacheID; ! 1778: xyzPt.x = MONO_PATTERN_CACHE_X + ((i >> 3) * 16); ! 1779: xyzPt.y = MONO_PATTERN_CACHE_Y; ! 1780: xyzPt.z = ajMonoPatPlanes[i & 0x7]; ! 1781: ! 1782: // Check for an hit in the expansion cache. ! 1783: ! 1784: if (ps3Brush->iPatternID == ppdev->aulMonoExpansionCacheTag[(i = ps3Brush->iExpansionCacheID)]) ! 1785: { ! 1786: zHorz = zVert = ajMonoPatPlanes[i]; ! 1787: nMonoBrushExpansionCacheHit++; ! 1788: } ! 1789: else ! 1790: { ! 1791: // Get an expansion cache slot for this brush. ! 1792: ! 1793: i = ppdev->iNextMonoBrushExpansionSlot; ! 1794: i = ++i % MAX_MONO_BRUSH_EXPANSION_SLOTS; ! 1795: ppdev->iNextMonoBrushExpansionSlot = i; ! 1796: ps3Brush->iExpansionCacheID = i; ! 1797: ! 1798: // Associate this brush with this expansion cache slot. ! 1799: ! 1800: ppdev->aulMonoExpansionCacheTag[i] = ps3Brush->iPatternID; ! 1801: ! 1802: // Set the expansion caches planes ! 1803: ! 1804: zHorz = zVert = ajMonoPatPlanes[i]; ! 1805: ! 1806: bExpandMonoBrushIntoHorzCache(ppdev, &xyzPt, zHorz); ! 1807: bExpandMonoBrushIntoVertCache(ppdev, &xyzPt, zVert); ! 1808: } ! 1809: } ! 1810: } ! 1811: else ! 1812: { ! 1813: DISPDBG((3, "S3.DLL!bPatternBrush - 8BPP brush\n")); ! 1814: ! 1815: // If we have never seen this brush before then allocate a slot ! 1816: // for it. ! 1817: ! 1818: // Keep a count of number of brushes we have seen. ! 1819: // This will be used to determine if the cache system is adaquate. ! 1820: ! 1821: nColorBrushes++; ! 1822: ! 1823: // If we have never seen this brush before or if the cache ! 1824: // has changed since the last time ! 1825: // we have seen it then allocate a new cache entry for it. ! 1826: ! 1827: if ((ps3Brush->iBrushCacheID == -1) || ! 1828: (ps3Brush->iPatternID != ppdev->pulColorBrushCacheEntries[ps3Brush->iBrushCacheID])) ! 1829: { ! 1830: // If we have run out of cache entries invalidate the entire cache. ! 1831: ! 1832: if (ppdev->iNextColorBrushCacheSlot >= ppdev->iMaxCachedColorBrushes) ! 1833: { ! 1834: nColorBrushCacheInvalidations++; ! 1835: ! 1836: memset(ppdev->pulColorBrushCacheEntries, 0, ppdev->iMaxCachedColorBrushes * sizeof(ULONG)); ! 1837: ppdev->iNextColorBrushCacheSlot = 0; ! 1838: } ! 1839: ! 1840: // Get a slot in the cache for this brush. ! 1841: ! 1842: i = (ppdev->iNextColorBrushCacheSlot)++; ! 1843: ps3Brush->iBrushCacheID = i; ! 1844: ! 1845: // Calculate the address of the brush in the cache. ! 1846: ! 1847: pt.x = COLOR_PATTERN_CACHE_X + ((i >> 2) * 16); ! 1848: pt.y = COLOR_PATTERN_CACHE_Y + ((i & 0x3) * 16); ! 1849: ! 1850: // Associate the brush with this cache entry. ! 1851: ! 1852: ppdev->pulColorBrushCacheEntries[i] = ps3Brush->iPatternID; ! 1853: ppdev->ulColorExpansionCacheTag = ps3Brush->iPatternID; ! 1854: ! 1855: // Down load the brush to the cache and expand it into ! 1856: // the horizontal and vertical caches. ! 1857: ! 1858: bDownLoadBrushIntoColorCache(ppdev, ps3Brush, &pt); ! 1859: bExpandColorBrushIntoHorzCache(ppdev, &pt); ! 1860: bExpandColorBrushIntoVertCache(ppdev, &pt); ! 1861: } ! 1862: else ! 1863: { ! 1864: // We got a cache hit, so keep the statistic. ! 1865: ! 1866: nColorBrushCacheHit++; ! 1867: ! 1868: // Calculate the address of the brush in the cache. ! 1869: ! 1870: i = ps3Brush->iBrushCacheID; ! 1871: pt.x = COLOR_PATTERN_CACHE_X + ((i >> 2) * 16); ! 1872: pt.y = COLOR_PATTERN_CACHE_Y + ((i & 0x3) * 16); ! 1873: ! 1874: if (ps3Brush->iPatternID == ppdev->ulColorExpansionCacheTag) ! 1875: { ! 1876: nColorBrushExpansionCacheHit++; ! 1877: } ! 1878: else ! 1879: { ! 1880: ppdev->ulColorExpansionCacheTag = ps3Brush->iPatternID; ! 1881: ! 1882: bExpandColorBrushIntoHorzCache(ppdev, &pt); ! 1883: bExpandColorBrushIntoVertCache(ppdev, &pt); ! 1884: } ! 1885: } ! 1886: } ! 1887: ! 1888: // Handle the clipping. ! 1889: ! 1890: if ((iDComplexity = pco->iDComplexity) != DC_COMPLEX) ! 1891: { ! 1892: if (iDComplexity == DC_TRIVIAL) ! 1893: { ! 1894: rclTrg = *prclTrg; ! 1895: } ! 1896: else ! 1897: { ! 1898: rclTrg = *prclTrg; ! 1899: rclBounds = pco->rclBounds; ! 1900: ! 1901: // First handle the trivial rejection. ! 1902: ! 1903: bClipRequired = bIntersectTest(&rclTrg, &rclBounds); ! 1904: ! 1905: if (bClipRequired) ! 1906: { ! 1907: rclTrg.left = max (rclTrg.left, rclBounds.left); ! 1908: rclTrg.top = max (rclTrg.top, rclBounds.top); ! 1909: rclTrg.right = min(rclTrg.right, rclBounds.right); ! 1910: rclTrg.bottom = min(rclTrg.bottom, rclBounds.bottom); ! 1911: } ! 1912: else ! 1913: { ! 1914: // The brush is completely clipped out. ! 1915: // so just return sucessfull. ! 1916: ! 1917: return (TRUE); ! 1918: } ! 1919: } ! 1920: ! 1921: ptDest.x = rclTrg.left; ! 1922: ptDest.y = rclTrg.top; ! 1923: sizDest.cx = rclTrg.right - rclTrg.left; ! 1924: sizDest.cy = rclTrg.bottom - rclTrg.top; ! 1925: ! 1926: // Color expand the monochrome brush in the Hoizontal Cache to the ! 1927: // screen. ! 1928: ! 1929: if (s3ForeRop == OVERPAINT && s3BackRop == OVERPAINT) ! 1930: { ! 1931: if (ps3Brush->iBitmapFormat == BMF_1BPP) ! 1932: { ! 1933: bCpyColorExpandHorzCacheToScreen(ppdev, ps3Brush, zHorz, ! 1934: (PPOINT) pptlBrush, ! 1935: &ptDest, &sizDest); ! 1936: } ! 1937: else ! 1938: { ! 1939: // NOTE: The S3-911/924 requries the cx of any "rolling blt" ! 1940: // to have a cx of >= 64 pels. This is due to how the ! 1941: // chip's internal FIFO works. This test will catch all ! 1942: // the souce copy operations that can be accelerated, ! 1943: // with the rolling blit. ! 1944: ! 1945: if ((sizDest.cx >= 64) || ! 1946: (sizDest.cx > sizDest.cy)) ! 1947: { ! 1948: bCpyColorHorzCacheToScreen(ppdev, ps3Brush, ! 1949: (PPOINT) pptlBrush, ! 1950: &ptDest, &sizDest); ! 1951: } ! 1952: else ! 1953: { ! 1954: bColorVertCacheToScreen(ppdev, ps3Brush, ! 1955: (PPOINT) pptlBrush, ! 1956: &ptDest, &sizDest, ! 1957: s3ForeRop, s3BackRop); ! 1958: } ! 1959: } ! 1960: } ! 1961: else ! 1962: { ! 1963: if (sizDest.cy > sizDest.cx) ! 1964: { ! 1965: if (ps3Brush->iBitmapFormat == BMF_1BPP) ! 1966: { ! 1967: bColorExpandVertCacheToScreen(ppdev, ps3Brush, zVert, ! 1968: (PPOINT) pptlBrush, ! 1969: &ptDest, &sizDest, ! 1970: s3ForeRop, s3BackRop); ! 1971: } ! 1972: else ! 1973: { ! 1974: bColorVertCacheToScreen(ppdev, ps3Brush, ! 1975: (PPOINT) pptlBrush, ! 1976: &ptDest, &sizDest, ! 1977: s3ForeRop, s3BackRop); ! 1978: } ! 1979: } ! 1980: else ! 1981: { ! 1982: if (ps3Brush->iBitmapFormat == BMF_1BPP) ! 1983: { ! 1984: bColorExpandHorzCacheToScreen(ppdev, ps3Brush, zHorz, ! 1985: (PPOINT) pptlBrush, ! 1986: &ptDest, &sizDest, ! 1987: s3ForeRop, s3BackRop); ! 1988: } ! 1989: else ! 1990: { ! 1991: bColorHorzCacheToScreen(ppdev, ps3Brush, ! 1992: (PPOINT) pptlBrush, ! 1993: &ptDest, &sizDest, ! 1994: s3ForeRop, s3BackRop); ! 1995: } ! 1996: } ! 1997: } ! 1998: } ! 1999: else ! 2000: { ! 2001: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0); ! 2002: ! 2003: do ! 2004: { ! 2005: bMore = CLIPOBJ_bEnum(pco, sizeof (ENUMRECTS8), ! 2006: (PULONG) &EnumRects8); ! 2007: ! 2008: for (i = 0; i < (INT) EnumRects8.c; i++) ! 2009: { ! 2010: rclBounds = EnumRects8.arcl[i]; ! 2011: ! 2012: if (rclBounds.left < prclTrg->left) ! 2013: rclBounds.left = prclTrg->left; ! 2014: ! 2015: if (rclBounds.right > prclTrg->right) ! 2016: rclBounds.right = prclTrg->right; ! 2017: ! 2018: if (rclBounds.top < prclTrg->top) ! 2019: rclBounds.top = prclTrg->top; ! 2020: ! 2021: if (rclBounds.bottom > prclTrg->bottom) ! 2022: rclBounds.bottom = prclTrg->bottom; ! 2023: ! 2024: // Get the height and width for the blit. ! 2025: ! 2026: ptDest.x = rclBounds.left; ! 2027: ptDest.y = rclBounds.top; ! 2028: sizDest.cx = rclBounds.right - rclBounds.left; ! 2029: sizDest.cy = rclBounds.bottom - rclBounds.top; ! 2030: ! 2031: // Color expand the monochrome brush in the Hoizontal Cache ! 2032: // to the screen. ! 2033: ! 2034: if (s3ForeRop == OVERPAINT && s3BackRop == OVERPAINT) ! 2035: { ! 2036: if (ps3Brush->iBitmapFormat == BMF_1BPP) ! 2037: { ! 2038: bCpyColorExpandHorzCacheToScreen(ppdev, ps3Brush, zHorz, ! 2039: (PPOINT) pptlBrush, ! 2040: &ptDest, &sizDest); ! 2041: ! 2042: } ! 2043: else ! 2044: { ! 2045: if ((sizDest.cx >= 64) || ! 2046: (sizDest.cx > sizDest.cy)) ! 2047: { ! 2048: bCpyColorHorzCacheToScreen(ppdev, ps3Brush, ! 2049: (PPOINT) pptlBrush, ! 2050: &ptDest, &sizDest); ! 2051: } ! 2052: else ! 2053: { ! 2054: bColorVertCacheToScreen(ppdev, ps3Brush, ! 2055: (PPOINT) pptlBrush, ! 2056: &ptDest, &sizDest, ! 2057: s3ForeRop, s3BackRop); ! 2058: } ! 2059: } ! 2060: } ! 2061: else ! 2062: { ! 2063: if (sizDest.cy > sizDest.cx) ! 2064: { ! 2065: if (ps3Brush->iBitmapFormat == BMF_1BPP) ! 2066: { ! 2067: bColorExpandVertCacheToScreen(ppdev, ps3Brush, zVert, ! 2068: (PPOINT) pptlBrush, ! 2069: &ptDest, &sizDest, ! 2070: s3ForeRop, s3BackRop); ! 2071: } ! 2072: else ! 2073: { ! 2074: bColorVertCacheToScreen(ppdev, ps3Brush, ! 2075: (PPOINT) pptlBrush, ! 2076: &ptDest, &sizDest, ! 2077: s3ForeRop, s3BackRop); ! 2078: } ! 2079: } ! 2080: else ! 2081: { ! 2082: if (ps3Brush->iBitmapFormat == BMF_1BPP) ! 2083: { ! 2084: bColorExpandHorzCacheToScreen(ppdev, ps3Brush, zHorz, ! 2085: (PPOINT) pptlBrush, ! 2086: &ptDest, &sizDest, ! 2087: s3ForeRop, s3BackRop); ! 2088: } ! 2089: else ! 2090: { ! 2091: bColorHorzCacheToScreen(ppdev, ps3Brush, ! 2092: (PPOINT) pptlBrush, ! 2093: &ptDest, &sizDest, ! 2094: s3ForeRop, s3BackRop); ! 2095: } ! 2096: ! 2097: } ! 2098: } ! 2099: } ! 2100: } while (bMore); ! 2101: ! 2102: } ! 2103: ! 2104: return (TRUE); ! 2105: ! 2106: } ! 2107: ! 2108: /***************************************************************************** ! 2109: * wXlateSrcRop3toS3Rop - Translate the Source to Dest Rop 3 to an S3 rop ! 2110: ****************************************************************************/ ! 2111: WORD wXlateSrcRop3toS3Rop(PPDEV pdev, WORD rop3) ! 2112: { ! 2113: WORD s3Rop; ! 2114: ! 2115: switch (LOBYTE(rop3)) ! 2116: { ! 2117: case 0xBB: // DSno ! 2118: s3Rop = SCREEN_OR_NOT_NEW; ! 2119: break; ! 2120: ! 2121: case 0x33: // Sn ! 2122: s3Rop = NOT_NEW; ! 2123: break; ! 2124: ! 2125: case 0x44: // SDna ! 2126: s3Rop = NOT_SCREEN_AND_NEW; ! 2127: break; ! 2128: ! 2129: case 0x66: // DSx ! 2130: s3Rop = SCREEN_XOR_NEW; ! 2131: break; ! 2132: ! 2133: case 0x77: // DSan ! 2134: s3Rop = NOT_SCREEN_OR_NOT_NEW; ! 2135: break; ! 2136: ! 2137: case 0x88: // DSa ! 2138: s3Rop = SCREEN_AND_NEW; ! 2139: break; ! 2140: ! 2141: case 0x99: // DSxn ! 2142: s3Rop = NOT_SCREEN_XOR_NEW; ! 2143: break; ! 2144: ! 2145: case 0xDD: // SDno ! 2146: s3Rop = NOT_SCREEN_OR_NEW; ! 2147: break; ! 2148: ! 2149: case 0xCC: // S ! 2150: s3Rop = OVERPAINT; ! 2151: break; ! 2152: ! 2153: case 0x11: // DSon ! 2154: s3Rop = NOT_SCREEN_AND_NOT_NEW; ! 2155: break; ! 2156: ! 2157: case 0x22: // DSna ! 2158: s3Rop = SCREEN_AND_NOT_NEW; ! 2159: break; ! 2160: ! 2161: case 0xEE: // SDo ! 2162: s3Rop = SCREEN_OR_NEW; ! 2163: break; ! 2164: ! 2165: default: ! 2166: s3Rop = 0; ! 2167: break; ! 2168: } ! 2169: ! 2170: return (s3Rop); ! 2171: ! 2172: } ! 2173: ! 2174: ! 2175: /***************************************************************************** ! 2176: * Translate the ROP4 to S3 rops. ! 2177: ****************************************************************************/ ! 2178: ! 2179: ROP4 bXlatePatRop4toS3Rop( ! 2180: PPDEV pdev, ! 2181: ROP4 rop4) ! 2182: { ! 2183: WORD s3Rop; ! 2184: ROP4 s3Rop4; ! 2185: ! 2186: switch (rop4 & 0xff) ! 2187: { ! 2188: case 0x00: // 0 ! 2189: s3Rop = LOGICAL_0; ! 2190: break; ! 2191: ! 2192: case 0x05: // ~(P | D) ! 2193: s3Rop = NOT_SCREEN_AND_NOT_NEW; ! 2194: break; ! 2195: ! 2196: case 0x0A: // ~P & D ! 2197: s3Rop = SCREEN_AND_NOT_NEW; ! 2198: break; ! 2199: ! 2200: case 0x0F: // ~P ! 2201: s3Rop = NOT_NEW; ! 2202: break; ! 2203: ! 2204: case 0x50: // P & ~D ! 2205: s3Rop = NOT_SCREEN_AND_NEW; ! 2206: break; ! 2207: ! 2208: case 0x55: // ~D ! 2209: s3Rop = NOT_SCREEN; ! 2210: break; ! 2211: ! 2212: case 0x5A: // P ^ D ! 2213: s3Rop = SCREEN_XOR_NEW; ! 2214: break; ! 2215: ! 2216: case 0x5F: // ~(P & D) ! 2217: s3Rop = NOT_SCREEN_OR_NOT_NEW; ! 2218: break; ! 2219: ! 2220: case 0xA0: // P & D ! 2221: s3Rop = SCREEN_AND_NEW; ! 2222: break; ! 2223: ! 2224: case 0xA5: // ~(P ^ D) ! 2225: s3Rop = NOT_SCREEN_XOR_NEW; ! 2226: break; ! 2227: ! 2228: case 0xAA: // D ! 2229: s3Rop = LEAVE_ALONE; ! 2230: break; ! 2231: ! 2232: case 0xAF: // ~P | D ! 2233: s3Rop = SCREEN_OR_NOT_NEW; ! 2234: break; ! 2235: ! 2236: case 0xF0: // P ! 2237: s3Rop = OVERPAINT; ! 2238: break; ! 2239: ! 2240: case 0xF5: // P | ~D ! 2241: s3Rop = NOT_SCREEN_OR_NEW; ! 2242: break; ! 2243: ! 2244: case 0xFA: // P | D ! 2245: s3Rop = SCREEN_OR_NEW; ! 2246: break; ! 2247: ! 2248: case 0xFF: // 1 ! 2249: s3Rop = LOGICAL_1; ! 2250: break; ! 2251: } ! 2252: ! 2253: s3Rop4 = s3Rop | (s3Rop << 8); ! 2254: ! 2255: return(s3Rop4); ! 2256: } ! 2257: ! 2258: /***************************************************************************** ! 2259: * Download the Color Brush to the Color brush cache in ! 2260: * graphics memory. ! 2261: ****************************************************************************/ ! 2262: BOOL bDownLoadBrushIntoColorCache( ! 2263: PPDEV ppdev, ! 2264: PS3BRUSH ps3Brush, ! 2265: PPOINT ppt) ! 2266: { ! 2267: WORD Cmd; ! 2268: ! 2269: DISPDBG((3, "S3.DLL!bDownLoadBrushIntoColorCache - Entry\n")); ! 2270: ! 2271: // Down load the initial pattern image, the upper left 8 X 8 cell. ! 2272: ! 2273: Cmd = RECTANGLE_FILL | BUS_SIZE_8 | WAIT | ! 2274: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 2275: LAST_PIXEL_ON | WRITE; ! 2276: ! 2277: // Setup the S3 chip. ! 2278: ! 2279: FIFOWAIT(FIFO_6_EMPTY); ! 2280: ! 2281: TEST_AND_SET_FRGD_MIX(SRC_CPU_DATA | OVERPAINT); ! 2282: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 2283: ! 2284: OUTPW(CUR_X, ppt->x); ! 2285: OUTPW(CUR_Y, ppt->y); ! 2286: ! 2287: OUTPW(RECT_WIDTH, 7); ! 2288: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | 7)); ! 2289: ! 2290: GPWAIT(); ! 2291: OUTPW(CMD, Cmd); ! 2292: ! 2293: // Now transfer the data from host memory to graphics memory. ! 2294: ! 2295: CHECK_DATA_READY; ! 2296: ! 2297: vDataPortOutB(ppdev, ps3Brush->ajPattern, 64); ! 2298: ! 2299: CHECK_DATA_COMPLETE; ! 2300: ! 2301: // Make the pattern double wide. Make copy of the pattern to the right ! 2302: // of the original pattern. ! 2303: ! 2304: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 2305: MULTIPLE_PIXELS | DRAWING_DIR_TBLRXM; ! 2306: ! 2307: FIFOWAIT(FIFO_8_EMPTY); ! 2308: ! 2309: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 2310: ! 2311: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 2312: ! 2313: OUTPW(CUR_X, ppt->x); ! 2314: OUTPW(CUR_Y, ppt->y); ! 2315: OUTPW(DEST_X, ppt->x + 8); ! 2316: OUTPW(DEST_Y, ppt->y); ! 2317: ! 2318: OUTPW(CMD, Cmd); ! 2319: ! 2320: // Make the pattern double high. Make a copy of the double pattern ! 2321: // pattern below the original one. ! 2322: ! 2323: FIFOWAIT(FIFO_6_EMPTY); ! 2324: ! 2325: OUTPW(RECT_WIDTH, 15); ! 2326: ! 2327: OUTPW(CUR_X, ppt->x); ! 2328: OUTPW(CUR_Y, ppt->y); ! 2329: OUTPW(DEST_X, ppt->x); ! 2330: OUTPW(DEST_Y, ppt->y + 8); ! 2331: ! 2332: OUTPW(CMD, Cmd); ! 2333: ! 2334: return(TRUE); ! 2335: } ! 2336: ! 2337: ! 2338: ! 2339: /***************************************************************************** ! 2340: * Download the Monochrome Brush to the Monochrome brush cache in ! 2341: * graphics memory. ! 2342: ****************************************************************************/ ! 2343: BOOL bDownLoadBrushIntoMonoCache( ! 2344: PPDEV ppdev, ! 2345: PS3BRUSH p3Brush, ! 2346: PXYZPOINT pxyzPt) ! 2347: { ! 2348: WORD Cmd; ! 2349: INT i; ! 2350: BYTE ajPattern[8]; ! 2351: ! 2352: DISPDBG((3, "S3.DLL!bDownLoadBrushIntoMonoCache - Entry\n")); ! 2353: ! 2354: // Compress the dword aligned pattern to a byte aligned pattern. ! 2355: ! 2356: for (i = 0; i < 8; i++) ! 2357: { ! 2358: ajPattern[i] = p3Brush->ajPattern[i * p3Brush->lDeltaPattern]; ! 2359: } ! 2360: ! 2361: // Down load the initial pattern image, the upper left 8 X 8 cell. ! 2362: ! 2363: Cmd = RECTANGLE_FILL | BUS_SIZE_8 | WAIT | ! 2364: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 2365: LAST_PIXEL_ON | MULTIPLE_PIXELS | WRITE; ! 2366: ! 2367: // Setup the S3 chip. ! 2368: ! 2369: FIFOWAIT(FIFO_8_EMPTY); ! 2370: ! 2371: TEST_AND_SET_FRGD_MIX(LOGICAL_1); ! 2372: TEST_AND_SET_BKGD_MIX(LOGICAL_0); ! 2373: ! 2374: TEST_AND_SET_WRT_MASK(LOWORD(pxyzPt->z)); ! 2375: ! 2376: OUTPW(CUR_X, pxyzPt->x); ! 2377: OUTPW(CUR_Y, pxyzPt->y); ! 2378: ! 2379: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | CPU_DATA)); ! 2380: OUTPW(RECT_WIDTH, 7); ! 2381: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | 7)); ! 2382: ! 2383: GPWAIT(); ! 2384: OUTPW(CMD, Cmd); ! 2385: ! 2386: // Now transfer the data from host memory to graphics memory. ! 2387: ! 2388: CHECK_DATA_READY; ! 2389: ! 2390: vDataPortOutB(ppdev, ajPattern, 8); ! 2391: ! 2392: CHECK_DATA_COMPLETE; ! 2393: ! 2394: // Make the pattern double wide. Make copy of the pattern to the right ! 2395: // of the original pattern. ! 2396: ! 2397: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 2398: MULTIPLE_PIXELS | DRAWING_DIR_TBLRXM; ! 2399: ! 2400: FIFOWAIT(FIFO_8_EMPTY); ! 2401: ! 2402: TEST_AND_SET_RD_MASK (LOWORD(pxyzPt->z)); ! 2403: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 2404: ! 2405: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 2406: ! 2407: OUTPW(CUR_X, pxyzPt->x); ! 2408: OUTPW(CUR_Y, pxyzPt->y); ! 2409: OUTPW(DEST_X, pxyzPt->x + 8); ! 2410: OUTPW(DEST_Y, pxyzPt->y); ! 2411: ! 2412: OUTPW(CMD, Cmd); ! 2413: ! 2414: // Make the pattern double high. Make a copy of the double pattern ! 2415: // pattern below the original one. ! 2416: ! 2417: FIFOWAIT(FIFO_6_EMPTY); ! 2418: ! 2419: OUTPW(RECT_WIDTH, 15); ! 2420: ! 2421: OUTPW(CUR_X, pxyzPt->x); ! 2422: OUTPW(CUR_Y, pxyzPt->y); ! 2423: OUTPW(DEST_X, pxyzPt->x); ! 2424: OUTPW(DEST_Y, pxyzPt->y + 8); ! 2425: ! 2426: OUTPW(CMD, Cmd); ! 2427: ! 2428: // Reset the read and write masks. ! 2429: ! 2430: FIFOWAIT(FIFO_2_EMPTY); ! 2431: ! 2432: TEST_AND_SET_WRT_MASK(0xff); ! 2433: TEST_AND_SET_RD_MASK(0xff); ! 2434: ! 2435: return(TRUE); ! 2436: } ! 2437: ! 2438: ! 2439: /***************************************************************************** ! 2440: * Expand the color brush in the vertical dimension. ! 2441: ****************************************************************************/ ! 2442: BOOL bExpandColorBrushIntoVertCache( ! 2443: PPDEV ppdev, ! 2444: PPOINT ppt) ! 2445: { ! 2446: WORD Cmd; ! 2447: ! 2448: DISPDBG((3, "S3.DLL!bExpandColorBrushIntoVertCache - Entry\n")); ! 2449: ! 2450: // Copy the cached double wide, double high pattern to the Horizontal ! 2451: // expansion cache area. ! 2452: ! 2453: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 2454: MULTIPLE_PIXELS | DRAWING_DIR_TBLRXM; ! 2455: ! 2456: FIFOWAIT(FIFO_1_EMPTY); ! 2457: ! 2458: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 2459: ! 2460: FIFOWAIT(FIFO_8_EMPTY); ! 2461: ! 2462: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 2463: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | 15)); ! 2464: OUTPW(RECT_WIDTH, 15); ! 2465: ! 2466: OUTPW(CUR_X, ppt->x); ! 2467: OUTPW(CUR_Y, ppt->y); ! 2468: OUTPW(DEST_X, COLOR_VERT_EXPANSION_CACHE_X); ! 2469: OUTPW(DEST_Y, COLOR_VERT_EXPANSION_CACHE_Y); ! 2470: ! 2471: OUTPW(CMD, Cmd); ! 2472: ! 2473: // Now the rolling blit to fill all the way. ! 2474: ! 2475: FIFOWAIT(FIFO_6_EMPTY); ! 2476: ! 2477: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | COLOR_VERT_EXPANSION_CACHE_CY - 17)); ! 2478: ! 2479: OUTPW(CUR_X, COLOR_VERT_EXPANSION_CACHE_X); ! 2480: OUTPW(CUR_Y, COLOR_VERT_EXPANSION_CACHE_Y); ! 2481: OUTPW(DEST_X, COLOR_VERT_EXPANSION_CACHE_X); ! 2482: OUTPW(DEST_Y, COLOR_VERT_EXPANSION_CACHE_Y + 16); ! 2483: ! 2484: OUTPW(CMD, Cmd); ! 2485: ! 2486: return(TRUE); ! 2487: ! 2488: } ! 2489: ! 2490: ! 2491: ! 2492: /***************************************************************************** ! 2493: * Expand the monochrome brush in the vertical dimension. ! 2494: ****************************************************************************/ ! 2495: BOOL bExpandMonoBrushIntoVertCache( ! 2496: PPDEV ppdev, ! 2497: PXYZPOINT pxyzPt, ! 2498: INT zVert) ! 2499: { ! 2500: WORD Cmd; ! 2501: ! 2502: DISPDBG((3, "S3.DLL!bExpandMonoBrushIntoVertCache - Entry\n")); ! 2503: ! 2504: // Copy the cached double wide, double high pattern to the Horizontal ! 2505: // expansion cache area. ! 2506: ! 2507: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 2508: MULTIPLE_PIXELS | DRAWING_DIR_TBLRXM; ! 2509: ! 2510: FIFOWAIT(FIFO_7_EMPTY); ! 2511: ! 2512: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | DISPLAY_MEMORY)); ! 2513: ! 2514: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | OVERPAINT); ! 2515: TEST_AND_SET_FRGD_COLOR(0xff); ! 2516: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | OVERPAINT); ! 2517: SET_BKGD_COLOR(0); ! 2518: ! 2519: TEST_AND_SET_RD_MASK(LOWORD(pxyzPt->z)); ! 2520: TEST_AND_SET_WRT_MASK(LOWORD(zVert)); ! 2521: ! 2522: FIFOWAIT(FIFO_7_EMPTY); ! 2523: ! 2524: OUTPW(RECT_WIDTH, 15); ! 2525: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | 15)); ! 2526: ! 2527: OUTPW(CUR_X, pxyzPt->x); ! 2528: OUTPW(CUR_Y, pxyzPt->y); ! 2529: OUTPW(DEST_X, MONO_VERT_EXPANSION_CACHE_X); ! 2530: OUTPW(DEST_Y, MONO_VERT_EXPANSION_CACHE_Y); ! 2531: ! 2532: OUTPW(CMD, Cmd); ! 2533: ! 2534: // Now the rolling blit to fill all the way. ! 2535: ! 2536: FIFOWAIT(FIFO_7_EMPTY); ! 2537: ! 2538: TEST_AND_SET_RD_MASK(zVert); ! 2539: ! 2540: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | MONO_VERT_EXPANSION_CACHE_CY - 17)); ! 2541: ! 2542: OUTPW(CUR_X, MONO_VERT_EXPANSION_CACHE_X); ! 2543: OUTPW(CUR_Y, MONO_VERT_EXPANSION_CACHE_Y); ! 2544: OUTPW(DEST_X, MONO_VERT_EXPANSION_CACHE_X); ! 2545: OUTPW(DEST_Y, MONO_VERT_EXPANSION_CACHE_Y + 16); ! 2546: ! 2547: OUTPW(CMD, Cmd); ! 2548: ! 2549: // Now reset the read and write plan masks. ! 2550: ! 2551: FIFOWAIT(FIFO_2_EMPTY); ! 2552: ! 2553: TEST_AND_SET_WRT_MASK(0xff); ! 2554: TEST_AND_SET_RD_MASK(0xff); ! 2555: ! 2556: return(TRUE); ! 2557: ! 2558: } ! 2559: ! 2560: /***************************************************************************** ! 2561: * Expand the color brush in the horizontal dimension. ! 2562: ****************************************************************************/ ! 2563: BOOL bExpandColorBrushIntoHorzCache( ! 2564: PPDEV ppdev, ! 2565: PPOINT ppt) ! 2566: { ! 2567: WORD Cmd; ! 2568: ! 2569: DISPDBG((3, "S3.DLL!bExpandColorBrushIntoHorzCache - Entry\n")); ! 2570: ! 2571: // Copy the cached double wide, double high pattern to the Horizontal ! 2572: // expansion cache area. ! 2573: ! 2574: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 2575: MULTIPLE_PIXELS | DRAWING_DIR_TBLRXM; ! 2576: ! 2577: FIFOWAIT(FIFO_1_EMPTY); ! 2578: ! 2579: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 2580: ! 2581: FIFOWAIT(FIFO_8_EMPTY); ! 2582: ! 2583: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 2584: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | 15)); ! 2585: OUTPW(RECT_WIDTH, 15); ! 2586: ! 2587: OUTPW(CUR_X, ppt->x); ! 2588: OUTPW(CUR_Y, ppt->y); ! 2589: OUTPW(DEST_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 2590: OUTPW(DEST_Y, COLOR_HORZ_EXPANSION_CACHE_Y); ! 2591: ! 2592: OUTPW(CMD, Cmd); ! 2593: ! 2594: // Expand the 16 X 16 double wide, double high. ! 2595: // First to a 32 X 16 ! 2596: ! 2597: FIFOWAIT(FIFO_5_EMPTY); ! 2598: ! 2599: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 2600: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y); ! 2601: OUTPW(DEST_X, COLOR_HORZ_EXPANSION_CACHE_X + 16); ! 2602: OUTPW(DEST_Y, COLOR_HORZ_EXPANSION_CACHE_Y); ! 2603: ! 2604: OUTPW(CMD, Cmd); ! 2605: ! 2606: // Now 64 X 16 ! 2607: ! 2608: FIFOWAIT(FIFO_6_EMPTY); ! 2609: ! 2610: OUTPW(RECT_WIDTH, 31); ! 2611: ! 2612: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 2613: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y); ! 2614: OUTPW(DEST_X, COLOR_HORZ_EXPANSION_CACHE_X + 32); ! 2615: OUTPW(DEST_Y, COLOR_HORZ_EXPANSION_CACHE_Y); ! 2616: ! 2617: OUTPW(CMD, Cmd); ! 2618: ! 2619: // Now the rolling blit to fill all the way to 512 pels. ! 2620: ! 2621: FIFOWAIT(FIFO_7_EMPTY); ! 2622: ! 2623: OUTPW(RECT_WIDTH, COLOR_HORZ_EXPANSION_CACHE_CX - 65); ! 2624: ! 2625: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 2626: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y); ! 2627: OUTPW(DEST_X, COLOR_HORZ_EXPANSION_CACHE_X + 64); ! 2628: OUTPW(DEST_Y, COLOR_HORZ_EXPANSION_CACHE_Y); ! 2629: ! 2630: OUTPW(CMD, Cmd); ! 2631: ! 2632: return(TRUE); ! 2633: } ! 2634: ! 2635: ! 2636: ! 2637: ! 2638: /***************************************************************************** ! 2639: * Expand the monochrome brush in the horizontal dimension. ! 2640: ****************************************************************************/ ! 2641: BOOL bExpandMonoBrushIntoHorzCache( ! 2642: PPDEV ppdev, ! 2643: PXYZPOINT pxyzPt, ! 2644: INT zHorz) ! 2645: { ! 2646: WORD Cmd; ! 2647: ! 2648: DISPDBG((3, "S3.DLL!bExpandMonoBrushIntoHorzCache - Entry\n")); ! 2649: ! 2650: // Copy the cached double wide, double high pattern to the Horizontal ! 2651: // expansion cache area. ! 2652: ! 2653: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 2654: MULTIPLE_PIXELS | DRAWING_DIR_TBLRXM; ! 2655: ! 2656: FIFOWAIT(FIFO_7_EMPTY); ! 2657: ! 2658: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | DISPLAY_MEMORY)); ! 2659: ! 2660: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | OVERPAINT); ! 2661: TEST_AND_SET_FRGD_COLOR(0xff); ! 2662: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | OVERPAINT); ! 2663: SET_BKGD_COLOR(0); ! 2664: ! 2665: TEST_AND_SET_RD_MASK(LOWORD(pxyzPt->z)); ! 2666: TEST_AND_SET_WRT_MASK(LOWORD(zHorz)); ! 2667: ! 2668: FIFOWAIT(FIFO_7_EMPTY); ! 2669: ! 2670: OUTPW(RECT_WIDTH, 15); ! 2671: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | 15)); ! 2672: ! 2673: OUTPW(CUR_X, pxyzPt->x); ! 2674: OUTPW(CUR_Y, pxyzPt->y); ! 2675: OUTPW(DEST_X, MONO_HORZ_EXPANSION_CACHE_X); ! 2676: OUTPW(DEST_Y, MONO_HORZ_EXPANSION_CACHE_Y); ! 2677: ! 2678: OUTPW(CMD, Cmd); ! 2679: ! 2680: // Expand the 16 X 16 double wide, double high. ! 2681: // First to a 32 X 16 ! 2682: ! 2683: FIFOWAIT(FIFO_7_EMPTY); ! 2684: ! 2685: TEST_AND_SET_RD_MASK(LOWORD(zHorz)); ! 2686: ! 2687: OUTPW(RECT_WIDTH, 15); ! 2688: ! 2689: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X); ! 2690: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y); ! 2691: OUTPW(DEST_X, MONO_HORZ_EXPANSION_CACHE_X + 16); ! 2692: OUTPW(DEST_Y, MONO_HORZ_EXPANSION_CACHE_Y); ! 2693: ! 2694: OUTPW(CMD, Cmd); ! 2695: ! 2696: // Now 64 X 16 ! 2697: ! 2698: FIFOWAIT(FIFO_6_EMPTY); ! 2699: ! 2700: OUTPW(RECT_WIDTH, 31); ! 2701: ! 2702: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X); ! 2703: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y); ! 2704: OUTPW(DEST_X, MONO_HORZ_EXPANSION_CACHE_X + 32); ! 2705: OUTPW(DEST_Y, MONO_HORZ_EXPANSION_CACHE_Y); ! 2706: ! 2707: OUTPW(CMD, Cmd); ! 2708: ! 2709: // Now the rolling blit to fill all the way to 512 pels. ! 2710: ! 2711: FIFOWAIT(FIFO_7_EMPTY); ! 2712: ! 2713: OUTPW(RECT_WIDTH, MONO_HORZ_EXPANSION_CACHE_CX - 65); ! 2714: ! 2715: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X); ! 2716: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y); ! 2717: OUTPW(DEST_X, MONO_HORZ_EXPANSION_CACHE_X + 64); ! 2718: OUTPW(DEST_Y, MONO_HORZ_EXPANSION_CACHE_Y); ! 2719: ! 2720: OUTPW(CMD, Cmd); ! 2721: ! 2722: // Now reset the read and write plan masks. ! 2723: ! 2724: FIFOWAIT(FIFO_2_EMPTY); ! 2725: ! 2726: TEST_AND_SET_WRT_MASK(0xff); ! 2727: TEST_AND_SET_RD_MASK(0xff); ! 2728: ! 2729: return(TRUE); ! 2730: } ! 2731: ! 2732: ! 2733: /***************************************************************************** ! 2734: * Color brush in the Vertical Cache to the screen. ! 2735: ****************************************************************************/ ! 2736: BOOL bColorVertCacheToScreen( ! 2737: PPDEV ppdev, ! 2738: PS3BRUSH ps3Brush, ! 2739: PPOINT pptBrushOrg, ! 2740: PPOINT pptDest, ! 2741: PSIZE psizDest, ! 2742: WORD s3ForeRop, ! 2743: WORD s3BackRop) ! 2744: { ! 2745: WORD Cmd; ! 2746: INT ixBlits, ixLast, ! 2747: iyFirst, iyBlits, iyLast, ! 2748: xOffset, yOffset, ! 2749: i, j; ! 2750: ! 2751: DISPDBG((3, "S3.DLL!bColorVertCacheToScreen - Entry\n")); ! 2752: ! 2753: // Take into account the pptBrushOrg. ! 2754: ! 2755: xOffset = pptDest->x - pptBrushOrg->x; ! 2756: yOffset = pptDest->y - pptBrushOrg->y; ! 2757: ! 2758: if (xOffset < 0) ! 2759: xOffset = 8 - (-xOffset % 8); ! 2760: else ! 2761: xOffset %= 8; ! 2762: ! 2763: if (yOffset < 0) ! 2764: yOffset = 8 - (-yOffset % 8); ! 2765: else ! 2766: yOffset %= 8; ! 2767: ! 2768: // Color Expand the monochrome vertical cache to the screen. ! 2769: // This is done in a loop to handle the general case ROPs. ! 2770: ! 2771: if (psizDest->cy < 8 - yOffset) ! 2772: { ! 2773: iyFirst = psizDest->cy; ! 2774: iyBlits = 0; ! 2775: iyLast = 0; ! 2776: ! 2777: } ! 2778: else if (psizDest->cy - yOffset < COLOR_VERT_EXPANSION_CACHE_CY - 8) ! 2779: { ! 2780: iyFirst = 8 - yOffset; ! 2781: iyBlits = 0; ! 2782: iyLast = psizDest->cy - iyFirst; ! 2783: } ! 2784: else ! 2785: { ! 2786: iyFirst = 8 - yOffset; ! 2787: iyBlits = (psizDest->cy - iyFirst) / (COLOR_VERT_EXPANSION_CACHE_CY - 8); ! 2788: iyLast = (psizDest->cy - iyFirst) % (COLOR_VERT_EXPANSION_CACHE_CY - 8); ! 2789: } ! 2790: ! 2791: ixBlits = psizDest->cx / 8; ! 2792: ixLast = psizDest->cx % 8; ! 2793: ! 2794: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 2795: MULTIPLE_PIXELS| DRAWING_DIR_TBLRXM; ! 2796: ! 2797: FIFOWAIT(FIFO_4_EMPTY); ! 2798: ! 2799: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | s3ForeRop); ! 2800: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 2801: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | 7)); ! 2802: OUTPW(RECT_WIDTH, 7); ! 2803: ! 2804: for(i = 0; i < ixBlits; i++) ! 2805: { ! 2806: ASSERTS3(((pptDest->x + (i * 8) + 7) < (INT) ppdev->cxScreen), ! 2807: "S3.DLL!bColorVertCacheToScreen - Blit Operation over right edge (1)\n"); ! 2808: ! 2809: if (iyFirst != 0) ! 2810: { ! 2811: FIFOWAIT(FIFO_6_EMPTY); ! 2812: ! 2813: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyFirst - 1)); ! 2814: ! 2815: OUTPW(CUR_X, COLOR_VERT_EXPANSION_CACHE_X + xOffset); ! 2816: OUTPW(CUR_Y, COLOR_VERT_EXPANSION_CACHE_Y + yOffset); ! 2817: OUTPW(DEST_X, pptDest->x + (i * 8)); ! 2818: OUTPW(DEST_Y, pptDest->y); ! 2819: ! 2820: OUTPW(CMD, Cmd); ! 2821: } ! 2822: ! 2823: if (iyBlits != 0) ! 2824: { ! 2825: FIFOWAIT(FIFO_1_EMPTY); ! 2826: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | (COLOR_VERT_EXPANSION_CACHE_CY - 8) - 1)); ! 2827: } ! 2828: ! 2829: for (j = 0; j <iyBlits; j++) ! 2830: { ! 2831: FIFOWAIT(FIFO_5_EMPTY); ! 2832: ! 2833: OUTPW(CUR_X, COLOR_VERT_EXPANSION_CACHE_X + xOffset); ! 2834: OUTPW(CUR_Y, COLOR_VERT_EXPANSION_CACHE_Y); ! 2835: OUTPW(DEST_X, pptDest->x + (i * 8)); ! 2836: OUTPW(DEST_Y, pptDest->y + iyFirst + ! 2837: (j * (COLOR_VERT_EXPANSION_CACHE_CY - 8))); ! 2838: ! 2839: OUTPW(CMD, Cmd); ! 2840: } ! 2841: ! 2842: if (iyLast != 0) ! 2843: { ! 2844: FIFOWAIT(FIFO_6_EMPTY); ! 2845: ! 2846: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyLast - 1)); ! 2847: ! 2848: OUTPW(CUR_X, COLOR_VERT_EXPANSION_CACHE_X + xOffset); ! 2849: OUTPW(CUR_Y, COLOR_VERT_EXPANSION_CACHE_Y); ! 2850: OUTPW(DEST_X, pptDest->x + (i * 8)); ! 2851: OUTPW(DEST_Y, pptDest->y + iyFirst + ! 2852: (iyBlits * (COLOR_VERT_EXPANSION_CACHE_CY - 8))); ! 2853: ! 2854: OUTPW(CMD, Cmd); ! 2855: } ! 2856: } ! 2857: ! 2858: if (ixLast != 0) ! 2859: { ! 2860: FIFOWAIT(FIFO_1_EMPTY); ! 2861: OUTPW(RECT_WIDTH, ixLast - 1); ! 2862: ! 2863: ASSERTS3(((pptDest->x + (ixBlits * 8) + (ixLast - 1)) < (INT) ppdev->cxScreen), ! 2864: "S3.DLL!bColorVertCacheToScreen - Blit Operation over right edge (2)\n"); ! 2865: ! 2866: if (iyFirst != 0) ! 2867: { ! 2868: FIFOWAIT(FIFO_6_EMPTY); ! 2869: ! 2870: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyFirst - 1)); ! 2871: ! 2872: OUTPW(CUR_X, COLOR_VERT_EXPANSION_CACHE_X + xOffset); ! 2873: OUTPW(CUR_Y, COLOR_VERT_EXPANSION_CACHE_Y + yOffset); ! 2874: OUTPW(DEST_X, pptDest->x + (ixBlits * 8)); ! 2875: OUTPW(DEST_Y, pptDest->y); ! 2876: ! 2877: OUTPW(CMD, Cmd); ! 2878: } ! 2879: ! 2880: if (iyBlits != 0) ! 2881: { ! 2882: FIFOWAIT(FIFO_1_EMPTY); ! 2883: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | (COLOR_VERT_EXPANSION_CACHE_CY - 8) - 1)); ! 2884: } ! 2885: ! 2886: for (j = 0; j <iyBlits; j++) ! 2887: { ! 2888: FIFOWAIT(FIFO_5_EMPTY); ! 2889: ! 2890: OUTPW(CUR_X, COLOR_VERT_EXPANSION_CACHE_X + xOffset); ! 2891: OUTPW(CUR_Y, COLOR_VERT_EXPANSION_CACHE_Y); ! 2892: OUTPW(DEST_X, pptDest->x + (ixBlits * 8)); ! 2893: OUTPW(DEST_Y, pptDest->y + iyFirst + ! 2894: (j * (COLOR_VERT_EXPANSION_CACHE_CY - 8))); ! 2895: ! 2896: OUTPW(CMD, Cmd); ! 2897: } ! 2898: ! 2899: if (iyLast != 0) ! 2900: { ! 2901: FIFOWAIT(FIFO_6_EMPTY); ! 2902: ! 2903: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyLast - 1)); ! 2904: ! 2905: OUTPW(CUR_X, COLOR_VERT_EXPANSION_CACHE_X + xOffset); ! 2906: OUTPW(CUR_Y, COLOR_VERT_EXPANSION_CACHE_Y); ! 2907: OUTPW(DEST_X, pptDest->x + (ixBlits * 8)); ! 2908: OUTPW(DEST_Y, pptDest->y + iyFirst + ! 2909: (iyBlits * (COLOR_VERT_EXPANSION_CACHE_CY - 8))); ! 2910: ! 2911: OUTPW(CMD, Cmd); ! 2912: } ! 2913: } ! 2914: ! 2915: return(TRUE); ! 2916: } ! 2917: ! 2918: /***************************************************************************** ! 2919: * Color expand the monochrome brush in the Vertical Cache to the screen. ! 2920: ****************************************************************************/ ! 2921: BOOL bColorExpandVertCacheToScreen( ! 2922: PPDEV ppdev, ! 2923: PS3BRUSH ps3Brush, ! 2924: INT zVert, ! 2925: PPOINT pptBrushOrg, ! 2926: PPOINT pptDest, ! 2927: PSIZE psizDest, ! 2928: WORD s3ForeRop, ! 2929: WORD s3BackRop) ! 2930: { ! 2931: WORD Cmd; ! 2932: INT ixBlits, ixLast, ! 2933: iyFirst, iyBlits, iyLast, ! 2934: xOffset, yOffset, ! 2935: i, j; ! 2936: ! 2937: DISPDBG((3, "S3.DLL!bColorExpandVertCacheToScreen - Entry\n")); ! 2938: ! 2939: // Take into account the pptBrushOrg. ! 2940: ! 2941: xOffset = pptDest->x - pptBrushOrg->x; ! 2942: yOffset = pptDest->y - pptBrushOrg->y; ! 2943: ! 2944: if (xOffset < 0) ! 2945: xOffset = 8 - (-xOffset % 8); ! 2946: else ! 2947: xOffset %= 8; ! 2948: ! 2949: if (yOffset < 0) ! 2950: yOffset = 8 - (-yOffset % 8); ! 2951: else ! 2952: yOffset %= 8; ! 2953: ! 2954: // Color Expand the monochrome vertical cache to the screen. ! 2955: // This is done in a loop to handle the general case ROPs. ! 2956: ! 2957: if (psizDest->cy < 8 - yOffset) ! 2958: { ! 2959: iyFirst = psizDest->cy; ! 2960: iyBlits = 0; ! 2961: iyLast = 0; ! 2962: ! 2963: } ! 2964: else if (psizDest->cy - yOffset < MONO_VERT_EXPANSION_CACHE_CY - 8) ! 2965: { ! 2966: iyFirst = 8 - yOffset; ! 2967: iyBlits = 0; ! 2968: iyLast = psizDest->cy - iyFirst; ! 2969: } ! 2970: else ! 2971: { ! 2972: iyFirst = 8 - yOffset; ! 2973: iyBlits = (psizDest->cy - iyFirst) / (MONO_VERT_EXPANSION_CACHE_CY - 8); ! 2974: iyLast = (psizDest->cy - iyFirst) % (MONO_VERT_EXPANSION_CACHE_CY - 8); ! 2975: } ! 2976: ! 2977: ixBlits = psizDest->cx / 8; ! 2978: ixLast = psizDest->cx % 8; ! 2979: ! 2980: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 2981: MULTIPLE_PIXELS| DRAWING_DIR_TBLRXM; ! 2982: ! 2983: FIFOWAIT(FIFO_7_EMPTY); ! 2984: ! 2985: TEST_AND_SET_RD_MASK(zVert); ! 2986: ! 2987: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | s3ForeRop); ! 2988: TEST_AND_SET_FRGD_COLOR(LOWORD(ps3Brush->ulForeColor)); ! 2989: ! 2990: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | s3BackRop); ! 2991: SET_BKGD_COLOR(LOWORD(ps3Brush->ulBackColor)); ! 2992: ! 2993: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | DISPLAY_MEMORY)); ! 2994: ! 2995: OUTPW(RECT_WIDTH, 7); ! 2996: ! 2997: for(i = 0; i < ixBlits; i++) ! 2998: { ! 2999: ASSERTS3(((pptDest->x + (i * 8) + 7) < (INT) ppdev->cxScreen), ! 3000: "S3.DLL!bColorExpandVertCacheToScreen - Blit Operation over right edge (1)\n"); ! 3001: ! 3002: if (iyFirst != 0) ! 3003: { ! 3004: FIFOWAIT(FIFO_6_EMPTY); ! 3005: ! 3006: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyFirst - 1)); ! 3007: ! 3008: OUTPW(CUR_X, MONO_VERT_EXPANSION_CACHE_X + xOffset); ! 3009: OUTPW(CUR_Y, MONO_VERT_EXPANSION_CACHE_Y + yOffset); ! 3010: OUTPW(DEST_X, pptDest->x + (i * 8)); ! 3011: OUTPW(DEST_Y, pptDest->y); ! 3012: ! 3013: OUTPW(CMD, Cmd); ! 3014: } ! 3015: ! 3016: if (iyBlits != 0) ! 3017: { ! 3018: FIFOWAIT(FIFO_1_EMPTY); ! 3019: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | (MONO_VERT_EXPANSION_CACHE_CY - 8) - 1)); ! 3020: } ! 3021: ! 3022: for (j = 0; j <iyBlits; j++) ! 3023: { ! 3024: FIFOWAIT(FIFO_5_EMPTY); ! 3025: ! 3026: OUTPW(CUR_X, MONO_VERT_EXPANSION_CACHE_X + xOffset); ! 3027: OUTPW(CUR_Y, MONO_VERT_EXPANSION_CACHE_Y); ! 3028: OUTPW(DEST_X, pptDest->x + (i * 8)); ! 3029: OUTPW(DEST_Y, pptDest->y + iyFirst + ! 3030: (j * (MONO_VERT_EXPANSION_CACHE_CY - 8))); ! 3031: ! 3032: OUTPW(CMD, Cmd); ! 3033: } ! 3034: ! 3035: if (iyLast != 0) ! 3036: { ! 3037: FIFOWAIT(FIFO_6_EMPTY); ! 3038: ! 3039: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyLast - 1)); ! 3040: ! 3041: OUTPW(CUR_X, MONO_VERT_EXPANSION_CACHE_X + xOffset); ! 3042: OUTPW(CUR_Y, MONO_VERT_EXPANSION_CACHE_Y); ! 3043: OUTPW(DEST_X, pptDest->x + (i * 8)); ! 3044: OUTPW(DEST_Y, pptDest->y + iyFirst + ! 3045: (iyBlits * (MONO_VERT_EXPANSION_CACHE_CY - 8))); ! 3046: ! 3047: OUTPW(CMD, Cmd); ! 3048: } ! 3049: } ! 3050: ! 3051: if (ixLast != 0) ! 3052: { ! 3053: FIFOWAIT(FIFO_1_EMPTY); ! 3054: OUTPW(RECT_WIDTH, ixLast - 1); ! 3055: ! 3056: ASSERTS3(((pptDest->x + (ixBlits * 8) + (ixLast - 1)) < (INT) ppdev->cxScreen), ! 3057: "S3.DLL!bColorExpandVertCacheToScreen - Blit Operation over right edge (2)\n"); ! 3058: ! 3059: if (iyFirst != 0) ! 3060: { ! 3061: FIFOWAIT(FIFO_6_EMPTY); ! 3062: ! 3063: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyFirst - 1)); ! 3064: ! 3065: OUTPW(CUR_X, MONO_VERT_EXPANSION_CACHE_X + xOffset); ! 3066: OUTPW(CUR_Y, MONO_VERT_EXPANSION_CACHE_Y + yOffset); ! 3067: OUTPW(DEST_X, pptDest->x + (ixBlits * 8)); ! 3068: OUTPW(DEST_Y, pptDest->y); ! 3069: ! 3070: OUTPW(CMD, Cmd); ! 3071: } ! 3072: ! 3073: if (iyBlits != 0) ! 3074: { ! 3075: FIFOWAIT(FIFO_1_EMPTY); ! 3076: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | (MONO_VERT_EXPANSION_CACHE_CY - 8) - 1)); ! 3077: } ! 3078: ! 3079: for (j = 0; j <iyBlits; j++) ! 3080: { ! 3081: FIFOWAIT(FIFO_5_EMPTY); ! 3082: ! 3083: OUTPW(CUR_X, MONO_VERT_EXPANSION_CACHE_X + xOffset); ! 3084: OUTPW(CUR_Y, MONO_VERT_EXPANSION_CACHE_Y); ! 3085: OUTPW(DEST_X, pptDest->x + (ixBlits * 8)); ! 3086: OUTPW(DEST_Y, pptDest->y + iyFirst + ! 3087: (j * (MONO_VERT_EXPANSION_CACHE_CY - 8))); ! 3088: ! 3089: OUTPW(CMD, Cmd); ! 3090: } ! 3091: ! 3092: if (iyLast != 0) ! 3093: { ! 3094: FIFOWAIT(FIFO_6_EMPTY); ! 3095: ! 3096: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyLast - 1)); ! 3097: ! 3098: OUTPW(CUR_X, MONO_VERT_EXPANSION_CACHE_X + xOffset); ! 3099: OUTPW(CUR_Y, MONO_VERT_EXPANSION_CACHE_Y); ! 3100: OUTPW(DEST_X, pptDest->x + (ixBlits * 8)); ! 3101: OUTPW(DEST_Y, pptDest->y + iyFirst + ! 3102: (iyBlits * (MONO_VERT_EXPANSION_CACHE_CY - 8))); ! 3103: ! 3104: OUTPW(CMD, Cmd); ! 3105: } ! 3106: } ! 3107: ! 3108: // Reset the Read Mask ! 3109: ! 3110: FIFOWAIT(FIFO_2_EMPTY); ! 3111: ! 3112: TEST_AND_SET_WRT_MASK(0xff); ! 3113: TEST_AND_SET_RD_MASK(0xff); ! 3114: ! 3115: return(TRUE); ! 3116: } ! 3117: ! 3118: ! 3119: /***************************************************************************** ! 3120: * Color brush in the Hoizontal Cache to the screen. ! 3121: ****************************************************************************/ ! 3122: BOOL bColorHorzCacheToScreen( ! 3123: PPDEV ppdev, ! 3124: PS3BRUSH ps3Brush, ! 3125: PPOINT pptBrushOrg, ! 3126: PPOINT pptDest, ! 3127: PSIZE psizDest, ! 3128: WORD s3ForeRop, ! 3129: WORD s3BackRop) ! 3130: { ! 3131: WORD Cmd; ! 3132: INT xLeft, cxLeft, cxRight, ixBlits, i, j, x, cx, ! 3133: iyBlits, iyLast, ! 3134: xOffset, yOffset; ! 3135: ! 3136: DISPDBG((3, "S3.DLL!bColorHorzCacheToScreen - Entry\n")); ! 3137: ! 3138: // Take into account the pptBrushOrg. ! 3139: ! 3140: xOffset = pptDest->x - pptBrushOrg->x; ! 3141: yOffset = pptDest->y - pptBrushOrg->y; ! 3142: ! 3143: if (xOffset < 0) ! 3144: xOffset = 8 - (-xOffset % 8); ! 3145: else ! 3146: xOffset %= 8; ! 3147: ! 3148: if (yOffset < 0) ! 3149: yOffset = 8 - (-yOffset % 8); ! 3150: else ! 3151: yOffset %= 8; ! 3152: ! 3153: // Color Expand the monochrome horizontal cache to the screen. ! 3154: // This is done in a loop to handle the general case ROPs. ! 3155: ! 3156: xLeft = pptDest->x; ! 3157: cxLeft = COLOR_HORZ_EXPANSION_CACHE_CX - xOffset; ! 3158: ! 3159: if ((cx = psizDest->cx - cxLeft) < 0) ! 3160: { ! 3161: cxLeft = psizDest->cx; ! 3162: ixBlits = 0; ! 3163: cxRight = 0; ! 3164: } ! 3165: else ! 3166: { ! 3167: ixBlits = cx / COLOR_HORZ_EXPANSION_CACHE_CX; ! 3168: cxRight = cx % COLOR_HORZ_EXPANSION_CACHE_CX; ! 3169: } ! 3170: ! 3171: iyBlits = psizDest->cy / 8; ! 3172: iyLast = psizDest->cy % 8; ! 3173: ! 3174: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 3175: MULTIPLE_PIXELS| DRAWING_DIR_TBLRXM; ! 3176: ! 3177: FIFOWAIT(FIFO_3_EMPTY); ! 3178: ! 3179: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | s3ForeRop); ! 3180: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 3181: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | 7)); ! 3182: ! 3183: for (i = 0; i < iyBlits; i++) ! 3184: { ! 3185: ASSERTS3(((pptDest->x + (cxLeft - 1)) < (INT) ppdev->cxScreen), ! 3186: "S3.DLL!bColorHorzCacheToScreen - Blit Operation over right edge (1)\n"); ! 3187: ! 3188: FIFOWAIT(FIFO_6_EMPTY); ! 3189: ! 3190: OUTPW(RECT_WIDTH, cxLeft - 1); ! 3191: ! 3192: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X + xOffset); ! 3193: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3194: OUTPW(DEST_X, pptDest->x); ! 3195: OUTPW(DEST_Y, pptDest->y + (i * 8)); ! 3196: ! 3197: OUTPW(CMD, Cmd); ! 3198: ! 3199: // If the the cxDest is wider than the cxHorzCache then fill in the ! 3200: // right side of the fill area. ! 3201: ! 3202: if (cx > 0) ! 3203: { ! 3204: FIFOWAIT(FIFO_1_EMPTY); ! 3205: OUTPW(RECT_WIDTH, COLOR_HORZ_EXPANSION_CACHE_CX - 1); ! 3206: ! 3207: for (j = 0; j < ixBlits; j++) ! 3208: { ! 3209: x = pptDest->x + cxLeft + (j * COLOR_HORZ_EXPANSION_CACHE_CX); ! 3210: ! 3211: ASSERTS3(((x + (COLOR_HORZ_EXPANSION_CACHE_CX - 1)) < (INT) ppdev->cxScreen), ! 3212: "S3.DLL!bColorHorzCacheToScreen - Blit Operation over right edge (2)\n"); ! 3213: ! 3214: FIFOWAIT(FIFO_5_EMPTY); ! 3215: ! 3216: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 3217: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3218: OUTPW(DEST_X, x); ! 3219: OUTPW(DEST_Y, pptDest->y + (i * 8)); ! 3220: ! 3221: OUTPW(CMD, Cmd); ! 3222: } ! 3223: ! 3224: if (cxRight != 0) ! 3225: { ! 3226: x = pptDest->x + cxLeft + (ixBlits * COLOR_HORZ_EXPANSION_CACHE_CX); ! 3227: ! 3228: ASSERTS3(((x + (cxRight - 1)) < (INT) ppdev->cxScreen), ! 3229: "S3.DLL!bColorHorzCacheToScreen - Blit Operation over right edge (3)\n"); ! 3230: ! 3231: FIFOWAIT(FIFO_6_EMPTY); ! 3232: ! 3233: OUTPW(RECT_WIDTH, cxRight - 1); ! 3234: ! 3235: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 3236: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3237: OUTPW(DEST_X, x); ! 3238: OUTPW(DEST_Y, pptDest->y + (i * 8)); ! 3239: ! 3240: OUTPW(CMD, Cmd); ! 3241: } ! 3242: } ! 3243: } ! 3244: ! 3245: if (iyLast != 0) ! 3246: { ! 3247: ASSERTS3(((pptDest->x + (cxLeft - 1)) < (INT) ppdev->cxScreen), ! 3248: "S3.DLL!bColorHorzCacheToScreen - Blit Operation over right edge (4)\n"); ! 3249: ! 3250: FIFOWAIT(FIFO_7_EMPTY); ! 3251: ! 3252: OUTPW(RECT_WIDTH, cxLeft - 1); ! 3253: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyLast - 1)); ! 3254: ! 3255: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X + xOffset); ! 3256: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3257: OUTPW(DEST_X, pptDest->x); ! 3258: OUTPW(DEST_Y, pptDest->y + (iyBlits * 8)); ! 3259: ! 3260: OUTPW(CMD, Cmd); ! 3261: ! 3262: // If the the cxDest is wider than the cxHorzCache then fill in the ! 3263: // right side of the fill area. ! 3264: ! 3265: if (cx > 0) ! 3266: { ! 3267: FIFOWAIT(FIFO_1_EMPTY); ! 3268: OUTPW(RECT_WIDTH, COLOR_HORZ_EXPANSION_CACHE_CX - 1); ! 3269: ! 3270: for (j = 0; j < ixBlits; j++) ! 3271: { ! 3272: x = pptDest->x + cxLeft + (j * COLOR_HORZ_EXPANSION_CACHE_CX); ! 3273: ! 3274: ASSERTS3(((x + (COLOR_HORZ_EXPANSION_CACHE_CX - 1)) < (INT) ppdev->cxScreen), ! 3275: "S3.DLL!bColorHorzCacheToScreen - Blit Operation over right edge (5)\n"); ! 3276: ! 3277: FIFOWAIT(FIFO_5_EMPTY); ! 3278: ! 3279: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 3280: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3281: OUTPW(DEST_X, x); ! 3282: OUTPW(DEST_Y, pptDest->y + (iyBlits * 8)); ! 3283: ! 3284: OUTPW(CMD, Cmd); ! 3285: } ! 3286: ! 3287: if (cxRight != 0) ! 3288: { ! 3289: x = pptDest->x + cxLeft + (ixBlits * COLOR_HORZ_EXPANSION_CACHE_CX); ! 3290: ! 3291: ASSERTS3(((x + (cxRight - 1)) < (INT) ppdev->cxScreen), ! 3292: "S3.DLL!bColorHorzCacheToScreen - Blit Operation over right edge (6)\n"); ! 3293: ! 3294: FIFOWAIT(FIFO_6_EMPTY); ! 3295: ! 3296: OUTPW(RECT_WIDTH, cxRight - 1); ! 3297: ! 3298: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 3299: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3300: OUTPW(DEST_X, x); ! 3301: OUTPW(DEST_Y, pptDest->y + (iyBlits * 8)); ! 3302: ! 3303: OUTPW(CMD, Cmd); ! 3304: } ! 3305: } ! 3306: } ! 3307: ! 3308: return(TRUE); ! 3309: } ! 3310: ! 3311: /***************************************************************************** ! 3312: * Color expand the monochrome brush in the Hoizontal Cache to the screen. ! 3313: ****************************************************************************/ ! 3314: BOOL bColorExpandHorzCacheToScreen( ! 3315: PPDEV ppdev, ! 3316: PS3BRUSH ps3Brush, ! 3317: INT zHorz, ! 3318: PPOINT pptBrushOrg, ! 3319: PPOINT pptDest, ! 3320: PSIZE psizDest, ! 3321: WORD s3ForeRop, ! 3322: WORD s3BackRop) ! 3323: { ! 3324: WORD Cmd; ! 3325: INT xLeft, cxLeft, xMiddle, cxMiddle, xRight, cxRight, i, ! 3326: iyBlits, iyLast, ! 3327: xOffset, yOffset; ! 3328: ! 3329: DISPDBG((3, "S3.DLL!bColorExpandHorzCacheToScreen - Entry\n")); ! 3330: ! 3331: // Take into account the pptBrushOrg. ! 3332: ! 3333: xOffset = pptDest->x - pptBrushOrg->x; ! 3334: yOffset = pptDest->y - pptBrushOrg->y; ! 3335: ! 3336: if (xOffset < 0) ! 3337: xOffset = 8 - (-xOffset % 8); ! 3338: else ! 3339: xOffset %= 8; ! 3340: ! 3341: if (yOffset < 0) ! 3342: yOffset = 8 - (-yOffset % 8); ! 3343: else ! 3344: yOffset %= 8; ! 3345: ! 3346: // Color Expand the monochrome horizontal cache to the screen. ! 3347: // This is done in a loop to handle the general case ROPs. ! 3348: ! 3349: xLeft = pptDest->x; ! 3350: cxLeft = MONO_HORZ_EXPANSION_CACHE_CX - xOffset; ! 3351: ! 3352: if (psizDest->cx < cxLeft) ! 3353: { ! 3354: cxLeft = psizDest->cx; ! 3355: xRight = 0; ! 3356: cxRight = 0; ! 3357: } ! 3358: else ! 3359: { ! 3360: xRight = pptDest->x + cxLeft; ! 3361: cxRight = psizDest->cx - cxLeft; ! 3362: } ! 3363: ! 3364: // This little hack is for 1280 mode. ! 3365: // Really the correct solution is to use the H/W support. ! 3366: ! 3367: if (cxRight > MONO_HORZ_EXPANSION_CACHE_CX) ! 3368: { ! 3369: xMiddle = xRight; ! 3370: xRight += MONO_HORZ_EXPANSION_CACHE_CX; ! 3371: cxMiddle = MONO_HORZ_EXPANSION_CACHE_CX; ! 3372: cxRight -= MONO_HORZ_EXPANSION_CACHE_CX; ! 3373: } ! 3374: else ! 3375: { ! 3376: xMiddle = 0; ! 3377: cxMiddle = 0; ! 3378: } ! 3379: ! 3380: iyBlits = psizDest->cy / 8; ! 3381: iyLast = psizDest->cy % 8; ! 3382: ! 3383: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 3384: MULTIPLE_PIXELS| DRAWING_DIR_TBLRXM; ! 3385: ! 3386: FIFOWAIT(FIFO_7_EMPTY); ! 3387: ! 3388: TEST_AND_SET_RD_MASK(zHorz); ! 3389: ! 3390: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | s3ForeRop); ! 3391: TEST_AND_SET_FRGD_COLOR(LOWORD(ps3Brush->ulForeColor)); ! 3392: ! 3393: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | s3BackRop); ! 3394: SET_BKGD_COLOR(LOWORD(ps3Brush->ulBackColor)); ! 3395: ! 3396: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | DISPLAY_MEMORY)); ! 3397: ! 3398: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | 7)); ! 3399: ! 3400: for (i = 0; i < iyBlits; i++) ! 3401: { ! 3402: ASSERTS3(((pptDest->x + (cxLeft - 1)) < (INT) ppdev->cxScreen), ! 3403: "S3.DLL!bColorExpandHorzCacheToScreen - Blit Operation over right edge (1)\n"); ! 3404: ! 3405: FIFOWAIT(FIFO_6_EMPTY); ! 3406: ! 3407: OUTPW(RECT_WIDTH, cxLeft - 1); ! 3408: ! 3409: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X + xOffset); ! 3410: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3411: OUTPW(DEST_X, pptDest->x); ! 3412: OUTPW(DEST_Y, pptDest->y + (i * 8)); ! 3413: ! 3414: OUTPW(CMD, Cmd); ! 3415: ! 3416: if (cxMiddle != 0) ! 3417: { ! 3418: ASSERTS3(((xMiddle + (cxMiddle - 1)) < (INT) ppdev->cxScreen), ! 3419: "S3.DLL!bColorExpandHorzCacheToScreen - Blit Operation over right edge (2)\n"); ! 3420: ! 3421: FIFOWAIT(FIFO_6_EMPTY); ! 3422: ! 3423: OUTPW(RECT_WIDTH, cxMiddle - 1); ! 3424: ! 3425: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X); ! 3426: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3427: OUTPW(DEST_X, xMiddle); ! 3428: OUTPW(DEST_Y, pptDest->y + (i * 8)); ! 3429: ! 3430: OUTPW(CMD, Cmd); ! 3431: } ! 3432: ! 3433: // If the the cxDest is wider than the cxHorzCache then fill in the ! 3434: // right side of the fill area. ! 3435: ! 3436: if (cxRight != 0) ! 3437: { ! 3438: ASSERTS3(((xRight + (cxRight - 1)) < (INT) ppdev->cxScreen), ! 3439: "S3.DLL!bColorExpandHorzCacheToScreen - Blit Operation over right edge (3)\n"); ! 3440: ! 3441: FIFOWAIT(FIFO_6_EMPTY); ! 3442: ! 3443: OUTPW(RECT_WIDTH, cxRight - 1); ! 3444: ! 3445: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X); ! 3446: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3447: OUTPW(DEST_X, xRight); ! 3448: OUTPW(DEST_Y, pptDest->y + (i * 8)); ! 3449: ! 3450: OUTPW(CMD, Cmd); ! 3451: } ! 3452: } ! 3453: ! 3454: if (iyLast != 0) ! 3455: { ! 3456: ASSERTS3(((pptDest->x + (cxLeft - 1)) < (INT) ppdev->cxScreen), ! 3457: "S3.DLL!bColorExpandHorzCacheToScreen - Blit Operation over right edge (3)\n"); ! 3458: ! 3459: FIFOWAIT(FIFO_7_EMPTY); ! 3460: ! 3461: OUTPW(RECT_WIDTH, cxLeft - 1); ! 3462: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | iyLast - 1)); ! 3463: ! 3464: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X + xOffset); ! 3465: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3466: OUTPW(DEST_X, pptDest->x); ! 3467: OUTPW(DEST_Y, pptDest->y + (iyBlits * 8)); ! 3468: ! 3469: OUTPW(CMD, Cmd); ! 3470: ! 3471: if (cxMiddle != 0) ! 3472: { ! 3473: ASSERTS3(((xMiddle + (cxMiddle - 1)) < (INT) ppdev->cxScreen), ! 3474: "S3.DLL!bColorExpandHorzCacheToScreen - Blit Operation over right edge (4)\n"); ! 3475: ! 3476: FIFOWAIT(FIFO_6_EMPTY); ! 3477: ! 3478: OUTPW(RECT_WIDTH, cxMiddle - 1); ! 3479: ! 3480: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X); ! 3481: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3482: OUTPW(DEST_X, xMiddle); ! 3483: OUTPW(DEST_Y, pptDest->y + (iyBlits * 8)); ! 3484: ! 3485: OUTPW(CMD, Cmd); ! 3486: } ! 3487: ! 3488: // If the the cxDest is wider than the cxHorzCache then fill in the ! 3489: // right side of the fill area. ! 3490: ! 3491: if (cxRight != 0) ! 3492: { ! 3493: ASSERTS3(((xRight + (cxRight - 1)) < (INT) ppdev->cxScreen), ! 3494: "S3.DLL!bColorExpandHorzCacheToScreen - Blit Operation over right edge (4)\n"); ! 3495: ! 3496: FIFOWAIT(FIFO_6_EMPTY); ! 3497: ! 3498: OUTPW(RECT_WIDTH, cxRight - 1); ! 3499: ! 3500: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X); ! 3501: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3502: OUTPW(DEST_X, xRight); ! 3503: OUTPW(DEST_Y, pptDest->y + (iyBlits * 8)); ! 3504: ! 3505: OUTPW(CMD, Cmd); ! 3506: } ! 3507: } ! 3508: ! 3509: // Reset the Read Mask ! 3510: ! 3511: FIFOWAIT(FIFO_2_EMPTY); ! 3512: ! 3513: TEST_AND_SET_WRT_MASK(0xff); ! 3514: TEST_AND_SET_RD_MASK(0xff); ! 3515: ! 3516: return(TRUE); ! 3517: } ! 3518: ! 3519: ! 3520: /***************************************************************************** ! 3521: * Copy Optimized ! 3522: * Color brush in the Hoizontal Cache to the screen. ! 3523: ****************************************************************************/ ! 3524: BOOL bCpyColorHorzCacheToScreen( ! 3525: PPDEV ppdev, ! 3526: PS3BRUSH ps3Brush, ! 3527: PPOINT pptBrushOrg, ! 3528: PPOINT pptDest, ! 3529: PSIZE psizDest) ! 3530: { ! 3531: WORD Cmd; ! 3532: INT cx, cxLeft, ixBlits, ixLast, i, ! 3533: cy, x, xOffset, yOffset; ! 3534: ! 3535: DISPDBG((3, "S3.DLL!bCpyColorHorzCacheToScreen - Entry\n")); ! 3536: ! 3537: // Take into account the pptBrushOrg. ! 3538: ! 3539: xOffset = pptDest->x - pptBrushOrg->x; ! 3540: yOffset = pptDest->y - pptBrushOrg->y; ! 3541: ! 3542: if (xOffset < 0) ! 3543: xOffset = 8 - (-xOffset % 8); ! 3544: else ! 3545: xOffset %= 8; ! 3546: ! 3547: if (yOffset < 0) ! 3548: yOffset = 8 - (-yOffset % 8); ! 3549: else ! 3550: yOffset %= 8; ! 3551: ! 3552: // First Color Expand the monochrome horizontal cache to the screen. ! 3553: ! 3554: cxLeft = COLOR_HORZ_EXPANSION_CACHE_CX - xOffset; ! 3555: if (psizDest->cx < cxLeft) ! 3556: cxLeft = psizDest->cx; ! 3557: ! 3558: cy = 8; ! 3559: if (psizDest->cy < cy) ! 3560: cy = psizDest->cy; ! 3561: ! 3562: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 3563: MULTIPLE_PIXELS| DRAWING_DIR_TBLRXM; ! 3564: ! 3565: ASSERTS3(((pptDest->x + (cxLeft - 1)) < (INT) ppdev->cxScreen), ! 3566: "S3.DLL!bCpyColorHorzCacheToScreen - Blit Operation over right edge (1)\n"); ! 3567: ! 3568: FIFOWAIT(FIFO_2_EMPTY); ! 3569: ! 3570: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 3571: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 3572: ! 3573: FIFOWAIT(FIFO_7_EMPTY); ! 3574: ! 3575: OUTPW(RECT_WIDTH, cxLeft - 1); ! 3576: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | (cy - 1))); ! 3577: ! 3578: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X + xOffset); ! 3579: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3580: OUTPW(DEST_X, pptDest->x); ! 3581: OUTPW(DEST_Y, pptDest->y); ! 3582: ! 3583: OUTPW(CMD, Cmd); ! 3584: ! 3585: // If the the cxDest is wider than the cxHorzCache then fill in the ! 3586: // right side of the fill area. ! 3587: ! 3588: if ((cx = psizDest->cx - cxLeft) > 0) ! 3589: { ! 3590: ixBlits = cx / COLOR_HORZ_EXPANSION_CACHE_CX; ! 3591: ixLast = cx % COLOR_HORZ_EXPANSION_CACHE_CX; ! 3592: ! 3593: FIFOWAIT(FIFO_1_EMPTY); ! 3594: OUTPW(RECT_WIDTH, COLOR_HORZ_EXPANSION_CACHE_CX - 1); ! 3595: ! 3596: for (i = 0; i < ixBlits; i++) ! 3597: { ! 3598: x = pptDest->x + cxLeft + (i * COLOR_HORZ_EXPANSION_CACHE_CX); ! 3599: ! 3600: ASSERTS3(((x + (COLOR_HORZ_EXPANSION_CACHE_CX - 1)) < (INT) ppdev->cxScreen), ! 3601: "S3.DLL!bCpyColorHorzCacheToScreen - Blit Operation over right edge (2)\n"); ! 3602: ! 3603: FIFOWAIT(FIFO_5_EMPTY); ! 3604: ! 3605: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 3606: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3607: OUTPW(DEST_X, x); ! 3608: OUTPW(DEST_Y, pptDest->y); ! 3609: ! 3610: OUTPW(CMD, Cmd); ! 3611: } ! 3612: ! 3613: if (ixLast != 0) ! 3614: { ! 3615: x = pptDest->x + cxLeft + (ixBlits * COLOR_HORZ_EXPANSION_CACHE_CX); ! 3616: ! 3617: ASSERTS3(((x + (ixLast - 1)) < (INT) ppdev->cxScreen), ! 3618: "S3.DLL!bCpyColorHorzCacheToScreen - Blit Operation over right edge (3)\n"); ! 3619: ! 3620: FIFOWAIT(FIFO_6_EMPTY); ! 3621: ! 3622: OUTPW(RECT_WIDTH, ixLast - 1); ! 3623: ! 3624: OUTPW(CUR_X, COLOR_HORZ_EXPANSION_CACHE_X); ! 3625: OUTPW(CUR_Y, COLOR_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3626: OUTPW(DEST_X, x); ! 3627: OUTPW(DEST_Y, pptDest->y); ! 3628: ! 3629: OUTPW(CMD, Cmd); ! 3630: } ! 3631: } ! 3632: ! 3633: // If the cyDest is taller than 8 pels do a rolling blit to fill in ! 3634: // the bottom of the fill area. ! 3635: ! 3636: if (psizDest->cy > 8) ! 3637: { ! 3638: ASSERTS3(((pptDest->x + (psizDest->cx - 1)) < (INT) ppdev->cxScreen), ! 3639: "S3.DLL!bCpyColorHorzCacheToScreen - Blit Operation over right edge (4)\n"); ! 3640: ! 3641: FIFOWAIT(FIFO_7_EMPTY); ! 3642: ! 3643: OUTPW(RECT_WIDTH, psizDest->cx - 1); ! 3644: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | psizDest->cy - (cy + 1))); ! 3645: ! 3646: OUTPW(CUR_X, pptDest->x); ! 3647: OUTPW(CUR_Y, pptDest->y); ! 3648: OUTPW(DEST_X, pptDest->x); ! 3649: OUTPW(DEST_Y, pptDest->y + 8); ! 3650: ! 3651: OUTPW(CMD, Cmd); ! 3652: } ! 3653: ! 3654: return(TRUE); ! 3655: } ! 3656: ! 3657: /***************************************************************************** ! 3658: * Copy Optimized ! 3659: * Color expand the monochrome brush in the Hoizontal Cache to the screen. ! 3660: ****************************************************************************/ ! 3661: BOOL bCpyColorExpandHorzCacheToScreen( ! 3662: PPDEV ppdev, ! 3663: PS3BRUSH ps3Brush, ! 3664: INT zHorz, ! 3665: PPOINT pptBrushOrg, ! 3666: PPOINT pptDest, ! 3667: PSIZE psizDest) ! 3668: { ! 3669: WORD Cmd; ! 3670: INT cx, cxLeft, ixBlits, ixLast, i, ! 3671: cy, x, xOffset, yOffset; ! 3672: ! 3673: DISPDBG((3, "S3.DLL!bCpyColorExpandHorzCacheToScreen - Entry\n")); ! 3674: ! 3675: // Take into account the pptBrushOrg. ! 3676: ! 3677: xOffset = pptDest->x - pptBrushOrg->x; ! 3678: yOffset = pptDest->y - pptBrushOrg->y; ! 3679: ! 3680: if (xOffset < 0) ! 3681: xOffset = 8 - (-xOffset % 8); ! 3682: else ! 3683: xOffset %= 8; ! 3684: ! 3685: if (yOffset < 0) ! 3686: yOffset = 8 - (-yOffset % 8); ! 3687: else ! 3688: yOffset %= 8; ! 3689: ! 3690: // First Color Expand the monochrome horizontal cache to the screen. ! 3691: ! 3692: cxLeft = MONO_HORZ_EXPANSION_CACHE_CX - xOffset; ! 3693: if (psizDest->cx < cxLeft) ! 3694: cxLeft = psizDest->cx; ! 3695: ! 3696: cy = 8; ! 3697: if (psizDest->cy < cy) ! 3698: cy = psizDest->cy; ! 3699: ! 3700: Cmd = BITBLT | DRAW | DIR_TYPE_XY | WRITE | ! 3701: MULTIPLE_PIXELS| DRAWING_DIR_TBLRXM; ! 3702: ! 3703: ASSERTS3(((pptDest->x + (cxLeft - 1)) < (INT) ppdev->cxScreen), ! 3704: "S3.DLL!bCpyColorExpandHorzCacheToScreen - Blit Operation over right edge (1)\n"); ! 3705: ! 3706: FIFOWAIT(FIFO_6_EMPTY); ! 3707: ! 3708: TEST_AND_SET_RD_MASK(zHorz); ! 3709: ! 3710: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | OVERPAINT); ! 3711: TEST_AND_SET_FRGD_COLOR(LOWORD(ps3Brush->ulForeColor)); ! 3712: ! 3713: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | OVERPAINT); ! 3714: SET_BKGD_COLOR(LOWORD(ps3Brush->ulBackColor)); ! 3715: ! 3716: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | DISPLAY_MEMORY)); ! 3717: ! 3718: FIFOWAIT(FIFO_7_EMPTY); ! 3719: ! 3720: OUTPW(RECT_WIDTH, cxLeft - 1); ! 3721: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | (cy - 1))); ! 3722: ! 3723: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X + xOffset); ! 3724: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3725: OUTPW(DEST_X, pptDest->x); ! 3726: OUTPW(DEST_Y, pptDest->y); ! 3727: ! 3728: OUTPW(CMD, Cmd); ! 3729: ! 3730: // If the the cxDest is wider than the cxHorzCache then fill in the ! 3731: // right side of the fill area. ! 3732: ! 3733: if ((cx = psizDest->cx - cxLeft) > 0) ! 3734: { ! 3735: ixBlits = cx / MONO_HORZ_EXPANSION_CACHE_CX; ! 3736: ixLast = cx % MONO_HORZ_EXPANSION_CACHE_CX; ! 3737: ! 3738: FIFOWAIT(FIFO_1_EMPTY); ! 3739: OUTPW(RECT_WIDTH, MONO_HORZ_EXPANSION_CACHE_CX - 1); ! 3740: ! 3741: for (i = 0; i < ixBlits; i++) ! 3742: { ! 3743: x = pptDest->x + cxLeft + (i * MONO_HORZ_EXPANSION_CACHE_CX); ! 3744: ! 3745: ASSERTS3(((x + (COLOR_HORZ_EXPANSION_CACHE_CX - 1)) < (INT) ppdev->cxScreen), ! 3746: "S3.DLL!bCpyColorExpandHorzCacheToScreen - Blit Operation over right edge (2)\n"); ! 3747: ! 3748: FIFOWAIT(FIFO_5_EMPTY); ! 3749: ! 3750: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X); ! 3751: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3752: OUTPW(DEST_X, x); ! 3753: OUTPW(DEST_Y, pptDest->y); ! 3754: ! 3755: OUTPW(CMD, Cmd); ! 3756: } ! 3757: ! 3758: if (ixLast != 0) ! 3759: { ! 3760: x = pptDest->x + cxLeft + (ixBlits * MONO_HORZ_EXPANSION_CACHE_CX); ! 3761: ! 3762: ASSERTS3(((x + (ixLast - 1)) < (INT) ppdev->cxScreen), ! 3763: "S3.DLL!bCpyColorExpandHorzCacheToScreen - Blit Operation over right edge (3)\n"); ! 3764: ! 3765: FIFOWAIT(FIFO_6_EMPTY); ! 3766: ! 3767: OUTPW(RECT_WIDTH, ixLast - 1); ! 3768: ! 3769: OUTPW(CUR_X, MONO_HORZ_EXPANSION_CACHE_X); ! 3770: OUTPW(CUR_Y, MONO_HORZ_EXPANSION_CACHE_Y + yOffset); ! 3771: OUTPW(DEST_X, x); ! 3772: OUTPW(DEST_Y, pptDest->y); ! 3773: ! 3774: OUTPW(CMD, Cmd); ! 3775: } ! 3776: } ! 3777: ! 3778: // If the cyDest is taller than 8 pels do a rolling blit to fill in ! 3779: // the bottom of the fill area. ! 3780: ! 3781: if (psizDest->cy > 8) ! 3782: { ! 3783: ASSERTS3(((pptDest->x + (psizDest->cx - 1)) < (INT) ppdev->cxScreen), ! 3784: "S3.DLL!bCpyColorExpandHorzCacheToScreen - Blit Operation over right edge (4)\n"); ! 3785: ! 3786: FIFOWAIT(FIFO_2_EMPTY); ! 3787: ! 3788: TEST_AND_SET_RD_MASK(0xff); ! 3789: TEST_AND_SET_FRGD_MIX(SRC_DISPLAY_MEMORY | OVERPAINT); ! 3790: ! 3791: FIFOWAIT(FIFO_8_EMPTY); ! 3792: ! 3793: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 3794: ! 3795: OUTPW(RECT_WIDTH, psizDest->cx - 1); ! 3796: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | psizDest->cy - (cy + 1))); ! 3797: ! 3798: OUTPW(CUR_X, pptDest->x); ! 3799: OUTPW(CUR_Y, pptDest->y); ! 3800: OUTPW(DEST_X, pptDest->x); ! 3801: OUTPW(DEST_Y, pptDest->y + 8); ! 3802: ! 3803: OUTPW(CMD, Cmd); ! 3804: } ! 3805: ! 3806: // Reset the Read Mask ! 3807: ! 3808: FIFOWAIT(FIFO_2_EMPTY); ! 3809: ! 3810: TEST_AND_SET_WRT_MASK(0xff); ! 3811: TEST_AND_SET_RD_MASK(0xff); ! 3812: ! 3813: return(TRUE); ! 3814: } ! 3815: ! 3816: ! 3817: /***************************************************************************** ! 3818: * S3 Solid Pattern ! 3819: * ! 3820: * Returns TRUE if the blit was handled. ! 3821: ****************************************************************************/ ! 3822: BOOL bPatternSolid( ! 3823: SURFOBJ *psoTrg, ! 3824: SURFOBJ *psoSrc, ! 3825: SURFOBJ *psoMask, ! 3826: CLIPOBJ *pco, ! 3827: XLATEOBJ *pxlo, ! 3828: RECTL *prclTrg, ! 3829: POINTL *pptlSrc, ! 3830: POINTL *pptlMask, ! 3831: BRUSHOBJ *pbo, ! 3832: POINTL *pptlBrush, ! 3833: ROP4 s3Rop4) ! 3834: { ! 3835: INT width,height; ! 3836: WORD s3Mix; ! 3837: BOOL bMore; ! 3838: UINT i; ! 3839: ENUMRECTS8 EnumRects8; ! 3840: ! 3841: LONG rleft; // render coordinates ! 3842: LONG rtop; ! 3843: LONG rright; ! 3844: LONG rbottom; ! 3845: LONG cleft; // clip coorindates ! 3846: LONG ctop; ! 3847: LONG cright; ! 3848: LONG cbottom; ! 3849: LONG left; ! 3850: LONG top; ! 3851: RECTL rclBounds; ! 3852: BOOL bClipRequired, bDrawRequired; ! 3853: PPDEV ppdev; ! 3854: ! 3855: DISPDBG((3,"S3.DLL!bPatternSolid - Entry\n")); ! 3856: ! 3857: // Get the pdev. ! 3858: ! 3859: ppdev = (PPDEV) psoTrg->dhpdev; ! 3860: ! 3861: // Just use the for ground mix. ! 3862: ! 3863: s3Mix = (WORD) (s3Rop4 & 0xFF); ! 3864: ! 3865: // Dereference the target rectangle. ! 3866: ! 3867: rleft = prclTrg->left; ! 3868: rtop = prclTrg->top; ! 3869: rright = prclTrg->right; ! 3870: rbottom = prclTrg->bottom; ! 3871: ! 3872: // Use software clipping. It's faster than H/W clipping. ! 3873: ! 3874: if (pco->iDComplexity != DC_COMPLEX) ! 3875: { ! 3876: if (pco->iDComplexity == DC_TRIVIAL) ! 3877: { ! 3878: width = (rright - rleft) - 1; ! 3879: height = (rbottom - rtop) - 1; ! 3880: ! 3881: bDrawRequired = TRUE; ! 3882: } ! 3883: else ! 3884: { ! 3885: bDrawRequired = FALSE; ! 3886: ! 3887: rclBounds = pco->rclBounds; ! 3888: ! 3889: // First handle the trivial rejection. ! 3890: ! 3891: bClipRequired = bIntersectTest(prclTrg, &rclBounds); ! 3892: ! 3893: if (bClipRequired) ! 3894: { ! 3895: rleft = max (rleft, rclBounds.left); ! 3896: rtop = max (rtop, rclBounds.top); ! 3897: width = (min(rright, rclBounds.right) - rleft) - 1; ! 3898: height = (min(rbottom, rclBounds.bottom) - rtop) - 1; ! 3899: ! 3900: bDrawRequired = TRUE; ! 3901: } ! 3902: } ! 3903: ! 3904: if (bDrawRequired && width >= 0 && height >= 0) ! 3905: { ! 3906: vS3SolidPattern(ppdev, ! 3907: rleft, rtop, width, height, ! 3908: (pbo != NULL)? pbo->iSolidColor: 0, s3Mix); ! 3909: } ! 3910: } ! 3911: else ! 3912: { ! 3913: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0); ! 3914: ! 3915: do ! 3916: { ! 3917: bMore = CLIPOBJ_bEnum(pco, sizeof (ENUMRECTS8), ! 3918: (PULONG) &EnumRects8); ! 3919: for (i = 0; i < EnumRects8.c; i++) ! 3920: { ! 3921: // Do a trivial reject on Y. ! 3922: ! 3923: if (rtop > (cbottom = EnumRects8.arcl[i].bottom)) ! 3924: continue; ! 3925: if (rbottom < (ctop = EnumRects8.arcl[i].top)) ! 3926: continue; ! 3927: ! 3928: // Do a trivial reject on X. ! 3929: ! 3930: if (rleft > (cright = EnumRects8.arcl[i].right)) ! 3931: continue; ! 3932: if (rright < (cleft = EnumRects8.arcl[i].left)) ! 3933: continue; ! 3934: ! 3935: // It's not a trivial reject, so calculate the ! 3936: // minimal clip area. ! 3937: ! 3938: left = max (rleft, cleft); ! 3939: top = max (rtop, ctop); ! 3940: width = (min(rright, cright) - left) - 1; ! 3941: height = (min(rbottom, cbottom) - top) - 1; ! 3942: ! 3943: if (width < 0 || height < 0) ! 3944: continue; ! 3945: ! 3946: vS3SolidPattern(ppdev, ! 3947: left, top, ! 3948: width, height, ! 3949: (pbo != NULL)? pbo->iSolidColor: 0, s3Mix); ! 3950: } ! 3951: } while (bMore); ! 3952: } ! 3953: ! 3954: return (TRUE); ! 3955: } ! 3956: ! 3957: /***************************************************************************** ! 3958: * vS3SolidPattern ! 3959: ****************************************************************************/ ! 3960: VOID vS3SolidPattern( ! 3961: PPDEV ppdev, ! 3962: INT left, ! 3963: INT top, ! 3964: INT width, ! 3965: INT height, ! 3966: INT color, ! 3967: WORD s3Mix) ! 3968: { ! 3969: FIFOWAIT(FIFO_8_EMPTY); ! 3970: ! 3971: ASSERTS3 (((left + width) < (INT) ppdev->cxScreen), ! 3972: "S3.DLL!vS3SolidPattern - (left + width) > (ppdev->cxScreen - 1)\n"); ! 3973: ! 3974: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | s3Mix); ! 3975: TEST_AND_SET_FRGD_COLOR(color); ! 3976: ! 3977: OUTPW (MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 3978: ! 3979: OUTPW (CUR_X, left); ! 3980: OUTPW (CUR_Y, top); ! 3981: OUTPW (RECT_WIDTH, width); ! 3982: OUTPW (MULTIFUNC_CNTL, (RECT_HEIGHT | height)); ! 3983: ! 3984: OUTPW (CMD, RECTANGLE_FILL | DRAWING_DIR_TBLRXM | ! 3985: DRAW | DIR_TYPE_XY | ! 3986: LAST_PIXEL_ON | MULTIPLE_PIXELS | ! 3987: WRITE); ! 3988: } ! 3989: ! 3990: /***************************************************************************** ! 3991: * S3 8bpp Cached Managed Host to Screen Copy ! 3992: * ! 3993: * Returns TRUE if the blit was handled. ! 3994: ****************************************************************************/ ! 3995: BOOL b8BppHostToScrnCachedWithRop( ! 3996: SURFOBJ *psoTrg, ! 3997: SURFOBJ *psoSrc, ! 3998: CLIPOBJ *pco, ! 3999: XLATEOBJ *pxlo, ! 4000: RECTL *prclTrg, ! 4001: POINTL *pptlSrc, ! 4002: WORD s3Rop) ! 4003: { ! 4004: BOOL bRet; ! 4005: HSURF hsurf; ! 4006: PPDEV ppdev; ! 4007: POINTL ptlSrc; ! 4008: RECTL rclTrg; ! 4009: SIZEL sizlBitmap; ! 4010: ! 4011: PSAVEDSCRNBITSHDR pssbhInPdev; ! 4012: PSAVEDSCRNBITS pssbNewNode, pssbTemp; ! 4013: ! 4014: DISPDBG((3, "S3.DLL!b8BppHostToScrnCachedWithRop - entry\n")); ! 4015: ! 4016: n8BppBitmaps++; ! 4017: ! 4018: ppdev = (PPDEV) psoTrg->dhpdev; ! 4019: hsurf = psoSrc->hsurf; ! 4020: ! 4021: #if 0 ! 4022: DISPDBG((2, "\thsurf : %x\n", hsurf)); ! 4023: DISPDBG((2, "\tpsoSrc->iUniq : %x\n", psoSrc->iUniq)); ! 4024: DISPDBG((2, "\tpsoSrc->sizlBitmap.cx: %d\n", psoSrc->sizlBitmap.cx)); ! 4025: DISPDBG((2, "\tpsoSrc->sizlBitmap.cy: %d\n", psoSrc->sizlBitmap.cy)); ! 4026: #endif ! 4027: ! 4028: #if SRCBM_CACHE ! 4029: ! 4030: // Is this bitmap in the cache? ! 4031: ! 4032: if ((hsurf == ppdev->hsurfCachedBitmap) && ! 4033: (psoSrc->iUniq == ppdev->iUniqCachedBitmap)) ! 4034: { ! 4035: if ((((pxlo == NULL) || ! 4036: (pxlo->flXlate & XO_TRIVIAL)) && (ppdev->iUniqXlate == 1)) || ! 4037: (pxlo->iUniq == ppdev->iUniqXlate)) ! 4038: { ! 4039: // The bitmap is in the cache ! 4040: // Keep a cache hit count. ! 4041: ! 4042: n8BppBmCacheHits++; ! 4043: ! 4044: // Blt from the cache. ! 4045: ! 4046: ptlSrc.x = pptlSrc->x + OFF_SCREEN_BITMAP_X; ! 4047: ptlSrc.y = pptlSrc->y + OFF_SCREEN_BITMAP_Y; ! 4048: ! 4049: return(bScrnToScrnWithRop(psoTrg, psoTrg, pco, prclTrg, ! 4050: &ptlSrc, s3Rop)); ! 4051: } ! 4052: } ! 4053: ! 4054: // The bitmap is not in the cache. ! 4055: // Is it small enough to fit into the cache? ! 4056: ! 4057: sizlBitmap = psoSrc->sizlBitmap; ! 4058: ! 4059: if ((sizlBitmap.cx <= OFF_SCREEN_BITMAP_CX) && ! 4060: (sizlBitmap.cy <= OFF_SCREEN_BITMAP_CY)) ! 4061: { ! 4062: // It will fit in the cache. ! 4063: // If the cache is being used for some saved screen bits ! 4064: // move them to host memory. ! 4065: ! 4066: if (ppdev->SavedScreenBitsHeader.iUniq != -1) ! 4067: { ! 4068: nSsbMovedToHostFromSrcBmCache++; ! 4069: ! 4070: DISPDBG((1, "S3.DLL - Saved Screen Bits Moved to Host Memory from Source Bitmap Cache Manager \n")); ! 4071: ! 4072: // Move the actual bits to host memory. ! 4073: ! 4074: bRet = bMoveSaveScreenBitsToHost(ppdev, &pssbNewNode); ! 4075: ! 4076: if (bRet == FALSE) ! 4077: return(FALSE); ! 4078: ! 4079: // Connect this newNode to the beginning of the list of ! 4080: // save screen bits nodes. ! 4081: ! 4082: pssbhInPdev = &(ppdev->SavedScreenBitsHeader); ! 4083: ! 4084: pssbTemp = pssbhInPdev->pssbLink; ! 4085: pssbhInPdev->pssbLink = pssbNewNode; ! 4086: pssbNewNode->ssbh.pssbLink = pssbTemp; ! 4087: ! 4088: // Invalidate the Save Screen bits in off screen memory ! 4089: ! 4090: ppdev->SavedScreenBitsHeader.iUniq = (ULONG) -1; ! 4091: } ! 4092: ! 4093: ! 4094: // Set the cache tags. ! 4095: ! 4096: ppdev->hsurfCachedBitmap = hsurf; ! 4097: ppdev->iUniqCachedBitmap = psoSrc->iUniq; ! 4098: ! 4099: if ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)) ! 4100: { ! 4101: ppdev->iUniqXlate = 1; ! 4102: } ! 4103: else ! 4104: { ! 4105: ppdev->iUniqXlate = pxlo->iUniq; ! 4106: } ! 4107: ! 4108: // Put the entire bitmap into the cache. ! 4109: ! 4110: rclTrg.left = OFF_SCREEN_BITMAP_X; ! 4111: rclTrg.top = OFF_SCREEN_BITMAP_Y; ! 4112: rclTrg.right = OFF_SCREEN_BITMAP_X + sizlBitmap.cx; ! 4113: rclTrg.bottom = OFF_SCREEN_BITMAP_Y + sizlBitmap.cy; ! 4114: ! 4115: ptlSrc.x = 0; ! 4116: ptlSrc.y = 0; ! 4117: ! 4118: bRet = b8BppHostToScrnWithRop(psoTrg, psoSrc, ppdev->pcoFullRam, ! 4119: pxlo, &rclTrg, &ptlSrc, OVERPAINT); ! 4120: ! 4121: if (bRet == TRUE) ! 4122: { ! 4123: // Blt from the cache. ! 4124: ! 4125: ptlSrc.x = pptlSrc->x + OFF_SCREEN_BITMAP_X; ! 4126: ptlSrc.y = pptlSrc->y + OFF_SCREEN_BITMAP_Y; ! 4127: ! 4128: bRet = bScrnToScrnWithRop(psoTrg, psoTrg, pco, prclTrg, ! 4129: &ptlSrc, s3Rop); ! 4130: ! 4131: } ! 4132: } ! 4133: else ! 4134: { ! 4135: // The bitmap was too large to cache. ! 4136: // So, just blt it directly to the screen. ! 4137: ! 4138: bRet = b8BppHostToScrnWithRop(psoTrg, psoSrc, pco, pxlo, ! 4139: prclTrg, pptlSrc, s3Rop); ! 4140: } ! 4141: #else ! 4142: ! 4143: bRet = b8BppHostToScrnWithRop(psoTrg, psoSrc, pco, pxlo, ! 4144: prclTrg, pptlSrc, s3Rop); ! 4145: ! 4146: #endif ! 4147: ! 4148: return (bRet); ! 4149: } ! 4150: ! 4151: /***************************************************************************** ! 4152: * S3 8bpp Host to Screen Copy ! 4153: * ! 4154: * Returns TRUE if the blit was handled. ! 4155: ****************************************************************************/ ! 4156: BOOL b8BppHostToScrnWithRop( ! 4157: SURFOBJ *psoTrg, ! 4158: SURFOBJ *psoSrc, ! 4159: CLIPOBJ *pco, ! 4160: XLATEOBJ *pxlo, ! 4161: RECTL *prclTrg, ! 4162: POINTL *pptlSrc, ! 4163: WORD s3Rop) ! 4164: { ! 4165: LONG lSrcDelta; ! 4166: PWORD pwFirstWord; ! 4167: BOOL bMore; ! 4168: PPDEV ppdev; ! 4169: BYTE iDComplexity; ! 4170: RECTL rclTrg, rclBounds; ! 4171: POINT ptSrc; ! 4172: INT i; ! 4173: SIZE sizBlt; ! 4174: ! 4175: ENUMRECTS8 EnumRects8; ! 4176: ! 4177: DISPDBG((3, "S3.DLL!b8BppHostToScrnWithRop - entry\n")); ! 4178: ! 4179: ppdev = (PPDEV) psoTrg->dhpdev; ! 4180: ! 4181: // Pickup some convienent locals. ! 4182: ! 4183: lSrcDelta = psoSrc->lDelta; ! 4184: ! 4185: if ((iDComplexity = pco->iDComplexity) != DC_COMPLEX) ! 4186: { ! 4187: // Make a copy of the target, since we will have to change ! 4188: // it for clipping. ! 4189: ! 4190: rclTrg = *prclTrg; ! 4191: ! 4192: if (iDComplexity == DC_RECT) ! 4193: { ! 4194: rclBounds = pco->rclBounds; ! 4195: ! 4196: // Handle the trivial rejection and ! 4197: // define the clipped target rectangle. ! 4198: ! 4199: if (bIntersectTest(&rclTrg, &rclBounds)) ! 4200: { ! 4201: rclTrg.left = max (rclTrg.left, rclBounds.left); ! 4202: rclTrg.top = max (rclTrg.top, rclBounds.top); ! 4203: rclTrg.right = min (rclTrg.right, rclBounds.right); ! 4204: rclTrg.bottom = min (rclTrg.bottom, rclBounds.bottom); ! 4205: } ! 4206: else ! 4207: { ! 4208: // The destination rectangle is completely clipped out, ! 4209: // so just return. ! 4210: ! 4211: return (TRUE); ! 4212: } ! 4213: } ! 4214: ! 4215: // define the cx & cy for the blit. ! 4216: ! 4217: sizBlt.cx = rclTrg.right - rclTrg.left; ! 4218: sizBlt.cy = rclTrg.bottom - rclTrg.top; ! 4219: ! 4220: // calculate the cx & cy shift (due to clipping) for the source. ! 4221: // and define the upper left corner of the source. ! 4222: ! 4223: ptSrc.x = pptlSrc->x + (rclTrg.left - prclTrg->left); ! 4224: ptSrc.y = pptlSrc->y + (rclTrg.top - prclTrg->top); ! 4225: ! 4226: // Calculate the first word to blit ! 4227: ! 4228: pwFirstWord = (PWORD) (((PBYTE) psoSrc->pvScan0) ! 4229: + (ptSrc.y * lSrcDelta) + ptSrc.x); ! 4230: ! 4231: vLowLevel8BppHostToScrnWithRop(ppdev, (PPOINT) &rclTrg, &sizBlt, ! 4232: pwFirstWord, lSrcDelta, pxlo, s3Rop); ! 4233: ! 4234: } ! 4235: else ! 4236: { ! 4237: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0); ! 4238: ! 4239: do ! 4240: { ! 4241: bMore = CLIPOBJ_bEnum(pco, sizeof (ENUMRECTS8), (PULONG) &EnumRects8); ! 4242: ! 4243: for (i = 0; i < (INT) EnumRects8.c; i++) ! 4244: { ! 4245: rclTrg = *prclTrg; ! 4246: rclBounds = EnumRects8.arcl[i]; ! 4247: ! 4248: // Handle the trivial rejection and ! 4249: // define the clipped target rectangle. ! 4250: ! 4251: if (bIntersectTest(&rclTrg, &rclBounds)) ! 4252: { ! 4253: rclTrg.left = max (rclTrg.left, rclBounds.left); ! 4254: rclTrg.top = max (rclTrg.top, rclBounds.top); ! 4255: rclTrg.right = min (rclTrg.right, rclBounds.right); ! 4256: rclTrg.bottom = min (rclTrg.bottom, rclBounds.bottom); ! 4257: ! 4258: // define the cx & cy for the blit. ! 4259: ! 4260: sizBlt.cx = rclTrg.right - rclTrg.left; ! 4261: sizBlt.cy = rclTrg.bottom - rclTrg.top; ! 4262: ! 4263: // calculate the cx & cy shift (due to clipping) for the source. ! 4264: // and define the upper left corner of the source. ! 4265: ! 4266: ptSrc.x = pptlSrc->x + (rclTrg.left - prclTrg->left); ! 4267: ptSrc.y = pptlSrc->y + (rclTrg.top - prclTrg->top); ! 4268: ! 4269: // Calculate the first word to blit ! 4270: ! 4271: pwFirstWord = (PWORD) (((PBYTE) psoSrc->pvScan0) ! 4272: + (ptSrc.y * lSrcDelta) + ptSrc.x); ! 4273: ! 4274: vLowLevel8BppHostToScrnWithRop(ppdev, ! 4275: (PPOINT) &rclTrg, ! 4276: &sizBlt, ! 4277: pwFirstWord, ! 4278: lSrcDelta, ! 4279: pxlo, ! 4280: s3Rop); ! 4281: } ! 4282: } ! 4283: } while (bMore); ! 4284: } ! 4285: ! 4286: return (TRUE); ! 4287: } ! 4288: ! 4289: ! 4290: ! 4291: /***************************************************************************** ! 4292: * Low Level 8bpp host to screen copy. ! 4293: ****************************************************************************/ ! 4294: VOID vLowLevel8BppHostToScrnWithRop( ! 4295: PPDEV ppdev, ! 4296: PPOINT pptTrg, ! 4297: PSIZE psizBlt, ! 4298: PWORD pwFirstWord, ! 4299: INT lSrcDelta, ! 4300: XLATEOBJ *pxlo, ! 4301: WORD s3Rop) ! 4302: { ! 4303: PWORD pw; ! 4304: INT i, j; ! 4305: WORD Cmd; ! 4306: PBYTE pbSrc; ! 4307: INT nSrc; ! 4308: PULONG pulXlate; ! 4309: INT cy, wpl; ! 4310: BYTE LineBuff[DRIVERS_MAX_CX]; ! 4311: ! 4312: // Setup the S3 chip. ! 4313: ! 4314: cy = psizBlt->cy; ! 4315: ! 4316: Cmd = RECTANGLE_FILL | BYTE_SWAP | BUS_SIZE_16 | WAIT | ! 4317: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 4318: LAST_PIXEL_ON | SINGLE_PIXEL | WRITE; ! 4319: ! 4320: FIFOWAIT(FIFO_7_EMPTY); ! 4321: ! 4322: TEST_AND_SET_FRGD_MIX(SRC_CPU_DATA | s3Rop); ! 4323: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 4324: ! 4325: OUTPW(CUR_X, pptTrg->x); ! 4326: OUTPW(CUR_Y, pptTrg->y); ! 4327: OUTPW(RECT_WIDTH, psizBlt->cx - 1); ! 4328: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cy - 1)); ! 4329: ! 4330: GPWAIT(); ! 4331: ! 4332: OUTPW(CMD, Cmd); ! 4333: ! 4334: CHECK_DATA_READY; ! 4335: ! 4336: wpl = (psizBlt->cx + 1) >> 1; ! 4337: ! 4338: // We may have to do some color translation. ! 4339: ! 4340: if ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)) ! 4341: { ! 4342: // Now transfer the data. ! 4343: ! 4344: // Note: It would nice to do the entire bitmap in one ! 4345: // fell swoop, but there is no gaurantee source will ! 4346: // wrap on a bitmap boundary. ! 4347: ! 4348: pw = pwFirstWord; ! 4349: for (i = 0; i < cy; i++) ! 4350: { ! 4351: vDataPortOut(ppdev, (PWORD) pw, wpl); ! 4352: ((PBYTE) pw) += lSrcDelta; ! 4353: } ! 4354: } ! 4355: else ! 4356: { ! 4357: if (pxlo->flXlate & XO_TABLE) ! 4358: { ! 4359: pulXlate = pxlo->pulXlate; ! 4360: } ! 4361: else ! 4362: { ! 4363: pulXlate = XLATEOBJ_piVector(pxlo); ! 4364: } ! 4365: ! 4366: pbSrc = (PBYTE) pwFirstWord; ! 4367: nSrc = wpl * 2; ! 4368: ! 4369: for (i = 0; i < cy; i++) ! 4370: { ! 4371: for (j = 0; j < nSrc; j++) ! 4372: { ! 4373: LineBuff[j] = LOBYTE(pulXlate[pbSrc[j]]); ! 4374: } ! 4375: ! 4376: vDataPortOut(ppdev, (PWORD) LineBuff, wpl); ! 4377: pbSrc += lSrcDelta; ! 4378: } ! 4379: } ! 4380: ! 4381: CHECK_DATA_COMPLETE; ! 4382: ! 4383: return; ! 4384: ! 4385: } ! 4386: ! 4387: ! 4388: /***************************************************************************** ! 4389: * S3 1bpp Cached Managed Host to Screen With Rop ! 4390: * ! 4391: * Returns TRUE if the blit was handled. ! 4392: ****************************************************************************/ ! 4393: BOOL b1BppHostToScrnCachedWithRop( ! 4394: SURFOBJ *psoTrg, ! 4395: SURFOBJ *psoSrc, ! 4396: CLIPOBJ *pco, ! 4397: XLATEOBJ *pxlo, ! 4398: RECTL *prclTrg, ! 4399: POINTL *pptlSrc, ! 4400: WORD s3Rop) ! 4401: { ! 4402: BOOL bRet; ! 4403: HSURF hsurf; ! 4404: PPDEV ppdev; ! 4405: POINTL ptlSrc; ! 4406: RECTL rclTrg; ! 4407: SIZEL sizlBitmap; ! 4408: ! 4409: PSAVEDSCRNBITSHDR pssbhInPdev; ! 4410: PSAVEDSCRNBITS pssbNewNode, pssbTemp; ! 4411: ! 4412: DISPDBG((3, "S3.DLL!b1BppHostToScrnCachedWithRop - entry\n")); ! 4413: ! 4414: n1BppBitmaps++; ! 4415: ! 4416: ppdev = (PPDEV) psoTrg->dhpdev; ! 4417: hsurf = psoSrc->hsurf; ! 4418: ! 4419: #if 1 ! 4420: DISPDBG((2, "\thsurf : %x\n", hsurf)); ! 4421: DISPDBG((2, "\tpsoSrc->iUniq : %x\n", psoSrc->iUniq)); ! 4422: DISPDBG((2, "\tpsoSrc->sizlBitmap.cx: %d\n", psoSrc->sizlBitmap.cx)); ! 4423: DISPDBG((2, "\tpsoSrc->sizlBitmap.cy: %d\n", psoSrc->sizlBitmap.cy)); ! 4424: #endif ! 4425: ! 4426: #if SRCBM_CACHE ! 4427: ! 4428: // Is this bitmap in the cache? ! 4429: ! 4430: if ((hsurf == ppdev->hsurfCachedBitmap) && ! 4431: (psoSrc->iUniq == ppdev->iUniqCachedBitmap)) ! 4432: { ! 4433: if ((((pxlo == NULL) || ! 4434: (pxlo->flXlate & XO_TRIVIAL)) && (ppdev->iUniqXlate == 1)) || ! 4435: (pxlo->iUniq == ppdev->iUniqXlate)) ! 4436: { ! 4437: // The bitmap is in the cache ! 4438: // Keep a cache hit count. ! 4439: ! 4440: n1BppBmCacheHits++; ! 4441: ! 4442: // Blt from the cache. ! 4443: ! 4444: ptlSrc.x = pptlSrc->x + OFF_SCREEN_BITMAP_X; ! 4445: ptlSrc.y = pptlSrc->y + OFF_SCREEN_BITMAP_Y; ! 4446: ! 4447: return(bScrnToScrnWithRop(psoTrg, psoTrg, pco, prclTrg, ! 4448: &ptlSrc, s3Rop)); ! 4449: } ! 4450: } ! 4451: ! 4452: // The bitmap is not in the cache. ! 4453: // Is it small enough to fit into the cache? ! 4454: ! 4455: sizlBitmap = psoSrc->sizlBitmap; ! 4456: ! 4457: if ((sizlBitmap.cx <= OFF_SCREEN_BITMAP_CX) && ! 4458: (sizlBitmap.cy <= OFF_SCREEN_BITMAP_CY)) ! 4459: { ! 4460: // It will fit in the cache. ! 4461: // If the cache is being used for some saved screen bits ! 4462: // move them to host memory. ! 4463: ! 4464: if (ppdev->SavedScreenBitsHeader.iUniq != -1) ! 4465: { ! 4466: nSsbMovedToHostFromSrcBmCache++; ! 4467: ! 4468: DISPDBG((1, "S3.DLL - Saved Screen Bits Moved to Host Memory from Source Bitmap Cache Manager \n")); ! 4469: ! 4470: // Move the actual bits to host memory. ! 4471: ! 4472: bRet = bMoveSaveScreenBitsToHost(ppdev, &pssbNewNode); ! 4473: ! 4474: if (bRet == FALSE) ! 4475: return(FALSE); ! 4476: ! 4477: // Connect this newNode to the beginning of the list of ! 4478: // save screen bits nodes. ! 4479: ! 4480: pssbhInPdev = &(ppdev->SavedScreenBitsHeader); ! 4481: ! 4482: pssbTemp = pssbhInPdev->pssbLink; ! 4483: pssbhInPdev->pssbLink = pssbNewNode; ! 4484: pssbNewNode->ssbh.pssbLink = pssbTemp; ! 4485: ! 4486: // Invalidate the Save Screen bits in off screen memory ! 4487: ! 4488: ppdev->SavedScreenBitsHeader.iUniq = (ULONG) -1; ! 4489: } ! 4490: ! 4491: ! 4492: // Set the cache tags. ! 4493: ! 4494: ppdev->hsurfCachedBitmap = hsurf; ! 4495: ppdev->iUniqCachedBitmap = psoSrc->iUniq; ! 4496: ! 4497: if ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)) ! 4498: { ! 4499: ppdev->iUniqXlate = 1; ! 4500: } ! 4501: else ! 4502: { ! 4503: ppdev->iUniqXlate = pxlo->iUniq; ! 4504: } ! 4505: ! 4506: // Put the entire bitmap into the cache. ! 4507: ! 4508: rclTrg.left = OFF_SCREEN_BITMAP_X; ! 4509: rclTrg.top = OFF_SCREEN_BITMAP_Y; ! 4510: rclTrg.right = OFF_SCREEN_BITMAP_X + sizlBitmap.cx; ! 4511: rclTrg.bottom = OFF_SCREEN_BITMAP_Y + sizlBitmap.cy; ! 4512: ! 4513: ptlSrc.x = 0; ! 4514: ptlSrc.y = 0; ! 4515: ! 4516: bRet = b1BppHostToScrnWithRop(psoTrg, psoSrc, ppdev->pcoFullRam, ! 4517: pxlo, &rclTrg, &ptlSrc, OVERPAINT); ! 4518: ! 4519: if (bRet == TRUE) ! 4520: { ! 4521: // Blt from the cache. ! 4522: ! 4523: ptlSrc.x = pptlSrc->x + OFF_SCREEN_BITMAP_X; ! 4524: ptlSrc.y = pptlSrc->y + OFF_SCREEN_BITMAP_Y; ! 4525: ! 4526: bRet = bScrnToScrnWithRop(psoTrg, psoTrg, pco, prclTrg, ! 4527: &ptlSrc, s3Rop); ! 4528: ! 4529: } ! 4530: } ! 4531: else ! 4532: { ! 4533: // The bitmap was too large to cache. ! 4534: // So, just blt it directly to the screen. ! 4535: ! 4536: bRet = b1BppHostToScrnWithRop(psoTrg, psoSrc, pco, pxlo, ! 4537: prclTrg, pptlSrc, s3Rop); ! 4538: } ! 4539: #else ! 4540: ! 4541: bRet = b1BppHostToScrnWithRop(psoTrg, psoSrc, pco, pxlo, ! 4542: prclTrg, pptlSrc, s3Rop); ! 4543: ! 4544: #endif ! 4545: ! 4546: return (bRet); ! 4547: } ! 4548: ! 4549: ! 4550: ! 4551: ! 4552: ! 4553: /***************************************************************************** ! 4554: * S3 1bpp Host to Screen With ROP ! 4555: * ! 4556: * Returns TRUE if the blit was handled. ! 4557: ****************************************************************************/ ! 4558: BOOL b1BppHostToScrnWithRop( ! 4559: SURFOBJ *psoTrg, ! 4560: SURFOBJ *psoSrc, ! 4561: CLIPOBJ *pco, ! 4562: XLATEOBJ *pxlo, ! 4563: RECTL *prclTrg, ! 4564: POINTL *pptlSrc, ! 4565: WORD s3Rop) ! 4566: { ! 4567: LONG lSrcDelta; ! 4568: PWORD pwFirstWord; ! 4569: BOOL bMore; ! 4570: PPDEV ppdev; ! 4571: BYTE iDComplexity; ! 4572: RECTL rclTrg, rclBounds; ! 4573: POINT ptSrc; ! 4574: INT i; ! 4575: SIZE sizBlt; ! 4576: ! 4577: ENUMRECTS8 EnumRects8; ! 4578: ! 4579: DISPDBG((3, "S3.DLL!b1BppHostToScrnWithRop - entry\n")); ! 4580: ! 4581: ppdev = (PPDEV) psoTrg->dhpdev; ! 4582: ! 4583: // Pickup some convienent locals. ! 4584: ! 4585: lSrcDelta = psoSrc->lDelta; ! 4586: ! 4587: if ((iDComplexity = pco->iDComplexity) != DC_COMPLEX) ! 4588: { ! 4589: // Make a copy of the target, since we will have to change ! 4590: // it for clipping. ! 4591: ! 4592: rclTrg = *prclTrg; ! 4593: ! 4594: if (iDComplexity == DC_RECT) ! 4595: { ! 4596: rclBounds = pco->rclBounds; ! 4597: ! 4598: // Handle the trivial rejection and ! 4599: // define the clipped target rectangle. ! 4600: ! 4601: if (bIntersectTest(&rclTrg, &rclBounds)) ! 4602: { ! 4603: rclTrg.left = max (rclTrg.left, rclBounds.left); ! 4604: rclTrg.top = max (rclTrg.top, rclBounds.top); ! 4605: rclTrg.right = min (rclTrg.right, rclBounds.right); ! 4606: rclTrg.bottom = min (rclTrg.bottom, rclBounds.bottom); ! 4607: } ! 4608: else ! 4609: { ! 4610: // The destination rectangle is completely clipped out, ! 4611: // so just return. ! 4612: ! 4613: return (TRUE); ! 4614: } ! 4615: } ! 4616: ! 4617: // define the cx & cy for the blit. ! 4618: ! 4619: sizBlt.cx = rclTrg.right - rclTrg.left; ! 4620: sizBlt.cy = rclTrg.bottom - rclTrg.top; ! 4621: ! 4622: // calculate the cx & cy shift (due to clipping) for the source. ! 4623: // and define the upper left corner of the source. ! 4624: ! 4625: ptSrc.x = pptlSrc->x + (rclTrg.left - prclTrg->left); ! 4626: ptSrc.y = pptlSrc->y + (rclTrg.top - prclTrg->top); ! 4627: ! 4628: // Calculate the first word to blit ! 4629: ! 4630: pwFirstWord = (PWORD) (((PBYTE) psoSrc->pvScan0) ! 4631: + (ptSrc.y * lSrcDelta) + (ptSrc.x / 8)); ! 4632: ! 4633: vSetS3ClipRect(ppdev, &rclTrg); ! 4634: vLowLevel1BppHostToScrnWithRop(ppdev, ! 4635: (PPOINT) &rclTrg, ! 4636: &sizBlt, ! 4637: ptSrc.x, ! 4638: pwFirstWord, ! 4639: lSrcDelta, ! 4640: pxlo, ! 4641: s3Rop); ! 4642: ! 4643: } ! 4644: else ! 4645: { ! 4646: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0); ! 4647: ! 4648: do ! 4649: { ! 4650: bMore = CLIPOBJ_bEnum(pco, sizeof (ENUMRECTS8), (PULONG) &EnumRects8); ! 4651: ! 4652: for (i = 0; i < (INT) EnumRects8.c; i++) ! 4653: { ! 4654: rclTrg = *prclTrg; ! 4655: rclBounds = EnumRects8.arcl[i]; ! 4656: ! 4657: // Handle the trivial rejection and ! 4658: // define the clipped target rectangle. ! 4659: ! 4660: if (bIntersectTest(&rclTrg, &rclBounds)) ! 4661: { ! 4662: rclTrg.left = max (rclTrg.left, rclBounds.left); ! 4663: rclTrg.top = max (rclTrg.top, rclBounds.top); ! 4664: rclTrg.right = min (rclTrg.right, rclBounds.right); ! 4665: rclTrg.bottom = min (rclTrg.bottom, rclBounds.bottom); ! 4666: ! 4667: // define the cx & cy for the blit. ! 4668: ! 4669: sizBlt.cx = rclTrg.right - rclTrg.left; ! 4670: sizBlt.cy = rclTrg.bottom - rclTrg.top; ! 4671: ! 4672: // calculate the cx & cy shift (due to clipping) for the source. ! 4673: // and define the upper left corner of the source. ! 4674: ! 4675: ptSrc.x = pptlSrc->x + (rclTrg.left - prclTrg->left); ! 4676: ptSrc.y = pptlSrc->y + (rclTrg.top - prclTrg->top); ! 4677: ! 4678: // Calculate the first word to blit ! 4679: ! 4680: pwFirstWord = (PWORD) (((PBYTE) psoSrc->pvScan0) ! 4681: + (ptSrc.y * lSrcDelta) + (ptSrc.x / 8)); ! 4682: ! 4683: vSetS3ClipRect(ppdev, &rclTrg); ! 4684: vLowLevel1BppHostToScrnWithRop(ppdev, ! 4685: (PPOINT) &rclTrg, ! 4686: &sizBlt, ! 4687: ptSrc.x, ! 4688: pwFirstWord, ! 4689: lSrcDelta, ! 4690: pxlo, ! 4691: s3Rop); ! 4692: } ! 4693: } ! 4694: } while (bMore); ! 4695: } ! 4696: ! 4697: vResetS3Clipping(ppdev); ! 4698: ! 4699: return (TRUE); ! 4700: } ! 4701: ! 4702: ! 4703: /***************************************************************************** ! 4704: * Low Level 1bpp host to screen copy. ! 4705: * ! 4706: * Note: This routine should be modified to handle separate foreground ! 4707: * and background mix modes. ! 4708: ****************************************************************************/ ! 4709: VOID vLowLevel1BppHostToScrnWithRop( ! 4710: PPDEV ppdev, ! 4711: PPOINT pptTrg, ! 4712: PSIZE psizBlt, ! 4713: INT xSrc, ! 4714: PWORD pwFirstWord, ! 4715: INT lSrcDelta, ! 4716: XLATEOBJ *pxlo, ! 4717: WORD s3Rop) ! 4718: { ! 4719: PBYTE pb1bpp; ! 4720: INT i, x, cx, cy, nSrcBytes, xClip; ! 4721: WORD Cmd; ! 4722: PULONG pulXlate; ! 4723: ! 4724: if (pxlo->flXlate & XO_TABLE) ! 4725: { ! 4726: pulXlate = pxlo->pulXlate; ! 4727: } ! 4728: else ! 4729: { ! 4730: pulXlate = XLATEOBJ_piVector(pxlo); ! 4731: } ! 4732: ! 4733: ! 4734: x = pptTrg->x; ! 4735: cx = psizBlt->cx; ! 4736: ! 4737: // Take care of the non-byte aligned source case. ! 4738: ! 4739: if (xSrc & 0x7) ! 4740: { ! 4741: xClip = x; ! 4742: x -= (xSrc & 0x7); ! 4743: cx += (xSrc & 0x7); ! 4744: ! 4745: FIFOWAIT(FIFO_1_EMPTY); ! 4746: outpw (MULTIFUNC_CNTL, (CLIP_LEFT | xClip)); ! 4747: } ! 4748: ! 4749: Cmd = RECTANGLE_FILL | BUS_SIZE_8 | WAIT | ! 4750: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 4751: LAST_PIXEL_ON | MULTIPLE_PIXELS | WRITE; ! 4752: ! 4753: // Setup the S3 chip. ! 4754: ! 4755: cy = psizBlt->cy; ! 4756: ! 4757: FIFOWAIT(FIFO_4_EMPTY); ! 4758: ! 4759: TEST_AND_SET_FRGD_MIX(FOREGROUND_COLOR | s3Rop); ! 4760: TEST_AND_SET_FRGD_COLOR(LOWORD(pulXlate[1])); ! 4761: TEST_AND_SET_BKGD_MIX(BACKGROUND_COLOR | s3Rop); ! 4762: SET_BKGD_COLOR(LOWORD(pulXlate[0])); ! 4763: ! 4764: FIFOWAIT(FIFO_5_EMPTY); ! 4765: ! 4766: OUTPW(MULTIFUNC_CNTL, (DATA_EXTENSION | CPU_DATA)); ! 4767: ! 4768: OUTPW(CUR_X, x); ! 4769: OUTPW(CUR_Y, pptTrg->y); ! 4770: OUTPW(RECT_WIDTH, cx - 1); ! 4771: OUTPW(MULTIFUNC_CNTL, (RECT_HEIGHT | cy - 1)); ! 4772: ! 4773: GPWAIT(); ! 4774: ! 4775: OUTPW(CMD, Cmd); ! 4776: ! 4777: CHECK_DATA_READY; ! 4778: ! 4779: pb1bpp = (PBYTE) pwFirstWord; ! 4780: nSrcBytes = (cx + 7) / 8; ! 4781: ! 4782: for (i = 0; i < cy; i++) ! 4783: { ! 4784: vDataPortOutB(ppdev, pb1bpp, nSrcBytes); ! 4785: pb1bpp += lSrcDelta; ! 4786: } ! 4787: ! 4788: CHECK_DATA_COMPLETE; ! 4789: ! 4790: return; ! 4791: ! 4792: } ! 4793: ! 4794: ! 4795: /***************************************************************************** ! 4796: * S3 4bpp Host to Screen Copy ! 4797: * ! 4798: * Returns TRUE if the blit was handled. ! 4799: ****************************************************************************/ ! 4800: BOOL b4BppHostToScrnWithRop( ! 4801: SURFOBJ *psoTrg, ! 4802: SURFOBJ *psoSrc, ! 4803: CLIPOBJ *pco, ! 4804: XLATEOBJ *pxlo, ! 4805: RECTL *prclTrg, ! 4806: POINTL *pptlSrc, ! 4807: WORD s3Rop) ! 4808: { ! 4809: LONG lSrcDelta; ! 4810: PWORD pwFirstWord; ! 4811: BOOL bMore; ! 4812: PPDEV ppdev; ! 4813: BYTE iDComplexity; ! 4814: RECTL rclTrg, rclBounds; ! 4815: POINT ptSrc; ! 4816: INT i; ! 4817: SIZE sizBlt; ! 4818: ! 4819: ENUMRECTS8 EnumRects8; ! 4820: ! 4821: DISPDBG((2, "S3.DLL!b4BppHostToScrnWithRop - entry\n")); ! 4822: ! 4823: ppdev = (PPDEV) psoTrg->dhpdev; ! 4824: ! 4825: // Pickup some convienent locals. ! 4826: ! 4827: lSrcDelta = psoSrc->lDelta; ! 4828: ! 4829: if ((iDComplexity = pco->iDComplexity) != DC_COMPLEX) ! 4830: { ! 4831: // Make a copy of the target, since we will have to change ! 4832: // it for clipping. ! 4833: ! 4834: rclTrg = *prclTrg; ! 4835: ! 4836: if (iDComplexity == DC_RECT) ! 4837: { ! 4838: rclBounds = pco->rclBounds; ! 4839: ! 4840: // Handle the trivial rejection and ! 4841: // define the clipped target rectangle. ! 4842: ! 4843: if (bIntersectTest(&rclTrg, &rclBounds)) ! 4844: { ! 4845: rclTrg.left = max (rclTrg.left, rclBounds.left); ! 4846: rclTrg.top = max (rclTrg.top, rclBounds.top); ! 4847: rclTrg.right = min (rclTrg.right, rclBounds.right); ! 4848: rclTrg.bottom = min (rclTrg.bottom, rclBounds.bottom); ! 4849: } ! 4850: else ! 4851: { ! 4852: // The destination rectangle is completely clipped out, ! 4853: // so just return. ! 4854: ! 4855: return (TRUE); ! 4856: } ! 4857: } ! 4858: ! 4859: // define the cx & cy for the blit. ! 4860: ! 4861: sizBlt.cx = rclTrg.right - rclTrg.left; ! 4862: sizBlt.cy = rclTrg.bottom - rclTrg.top; ! 4863: ! 4864: // calculate the cx & cy shift (due to clipping) for the source. ! 4865: // and define the upper left corner of the source. ! 4866: ! 4867: ptSrc.x = pptlSrc->x + (rclTrg.left - prclTrg->left); ! 4868: ptSrc.y = pptlSrc->y + (rclTrg.top - prclTrg->top); ! 4869: ! 4870: // Calculate the first word to blit ! 4871: ! 4872: pwFirstWord = (PWORD) (((PBYTE) psoSrc->pvScan0) ! 4873: + (ptSrc.y * lSrcDelta) + (ptSrc.x / 2)); ! 4874: ! 4875: vSetS3ClipRect(ppdev, &rclTrg); ! 4876: vLowLevel4BppHostToScrnWithRop(ppdev, (PPOINT) &rclTrg, &sizBlt, ! 4877: ptSrc.x, ! 4878: pwFirstWord, lSrcDelta, pxlo, s3Rop); ! 4879: ! 4880: } ! 4881: else ! 4882: { ! 4883: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0); ! 4884: ! 4885: do ! 4886: { ! 4887: bMore = CLIPOBJ_bEnum(pco, sizeof (ENUMRECTS8), (PULONG) &EnumRects8); ! 4888: ! 4889: for (i = 0; i < (INT) EnumRects8.c; i++) ! 4890: { ! 4891: rclTrg = *prclTrg; ! 4892: rclBounds = EnumRects8.arcl[i]; ! 4893: ! 4894: // Handle the trivial rejection and ! 4895: // define the clipped target rectangle. ! 4896: ! 4897: if (bIntersectTest(&rclTrg, &rclBounds)) ! 4898: { ! 4899: rclTrg.left = max (rclTrg.left, rclBounds.left); ! 4900: rclTrg.top = max (rclTrg.top, rclBounds.top); ! 4901: rclTrg.right = min (rclTrg.right, rclBounds.right); ! 4902: rclTrg.bottom = min (rclTrg.bottom, rclBounds.bottom); ! 4903: ! 4904: // define the cx & cy for the blit. ! 4905: ! 4906: sizBlt.cx = rclTrg.right - rclTrg.left; ! 4907: sizBlt.cy = rclTrg.bottom - rclTrg.top; ! 4908: ! 4909: // calculate the cx & cy shift (due to clipping) for the source. ! 4910: // and define the upper left corner of the source. ! 4911: ! 4912: ptSrc.x = pptlSrc->x + (rclTrg.left - prclTrg->left); ! 4913: ptSrc.y = pptlSrc->y + (rclTrg.top - prclTrg->top); ! 4914: ! 4915: // Calculate the first word to blit ! 4916: ! 4917: pwFirstWord = (PWORD) (((PBYTE) psoSrc->pvScan0) ! 4918: + (ptSrc.y * lSrcDelta) + (ptSrc.x / 2)); ! 4919: ! 4920: vSetS3ClipRect(ppdev, &rclTrg); ! 4921: vLowLevel4BppHostToScrnWithRop(ppdev, (PPOINT) &rclTrg, &sizBlt, ! 4922: ptSrc.x, ! 4923: pwFirstWord, lSrcDelta, pxlo, s3Rop); ! 4924: } ! 4925: } ! 4926: } while (bMore); ! 4927: } ! 4928: ! 4929: vResetS3Clipping(ppdev); ! 4930: ! 4931: return (TRUE); ! 4932: ! 4933: } ! 4934: ! 4935: ! 4936: ! 4937: ! 4938: /***************************************************************************** ! 4939: * Low Level 4bpp host to screen copy. ! 4940: ****************************************************************************/ ! 4941: VOID vLowLevel4BppHostToScrnWithRop( ! 4942: PPDEV ppdev, ! 4943: PPOINT pptTrg, ! 4944: PSIZE psizBlt, ! 4945: INT xSrc, ! 4946: PWORD pwFirstWord, ! 4947: INT lSrcDelta, ! 4948: XLATEOBJ *pxlo, ! 4949: WORD s3Rop) ! 4950: { ! 4951: PBYTE pb4Bpp; ! 4952: INT i, j, k, x, cx, cy, nSrcBytes, xClip; ! 4953: WORD Cmd; ! 4954: PULONG pulXlate; ! 4955: ! 4956: BYTE LineBuff8Bpp[DRIVERS_MAX_CX]; ! 4957: ! 4958: if (pxlo->flXlate & XO_TABLE) ! 4959: { ! 4960: pulXlate = pxlo->pulXlate; ! 4961: } ! 4962: else ! 4963: { ! 4964: pulXlate = XLATEOBJ_piVector(pxlo); ! 4965: } ! 4966: ! 4967: pb4Bpp = (PBYTE) pwFirstWord; ! 4968: ! 4969: x = pptTrg->x; ! 4970: cx = psizBlt->cx; ! 4971: cy = psizBlt->cy; ! 4972: ! 4973: // Take care of the non-byte aligned source case. ! 4974: ! 4975: if (xSrc & 0x1) ! 4976: { ! 4977: xClip = x; ! 4978: x--; ! 4979: cx++; ! 4980: ! 4981: FIFOWAIT(FIFO_1_EMPTY); ! 4982: outpw (MULTIFUNC_CNTL, (CLIP_LEFT | xClip)); ! 4983: } ! 4984: ! 4985: nSrcBytes = (cx + 1) / 2; ! 4986: ! 4987: // Setup the S3 chip. ! 4988: ! 4989: Cmd = RECTANGLE_FILL | BYTE_SWAP | BUS_SIZE_16 | WAIT | ! 4990: DRAW | DRAWING_DIR_TBLRXM | DIR_TYPE_XY | ! 4991: LAST_PIXEL_ON | SINGLE_PIXEL | WRITE; ! 4992: ! 4993: FIFOWAIT(FIFO_7_EMPTY); ! 4994: ! 4995: TEST_AND_SET_FRGD_MIX(SRC_CPU_DATA | s3Rop); ! 4996: outpw(MULTIFUNC_CNTL, (DATA_EXTENSION | ALL_ONES)); ! 4997: ! 4998: outpw(CUR_X, x); ! 4999: outpw(CUR_Y, pptTrg->y); ! 5000: outpw(RECT_WIDTH, cx - 1); ! 5001: outpw(MULTIFUNC_CNTL, (RECT_HEIGHT | cy - 1)); ! 5002: ! 5003: GPWAIT(); ! 5004: ! 5005: outpw(CMD, Cmd); ! 5006: ! 5007: CHECK_DATA_READY; ! 5008: ! 5009: // Now transfer the data. ! 5010: ! 5011: for (i = 0; i < cy; i++) ! 5012: { ! 5013: for (k = 0, j = 0; j < nSrcBytes; j++) ! 5014: { ! 5015: LineBuff8Bpp[k++] = (BYTE) pulXlate[(pb4Bpp[j] & 0xF0) >> 4]; ! 5016: LineBuff8Bpp[k++] = (BYTE) pulXlate[pb4Bpp[j] & 0x0F]; ! 5017: } ! 5018: ! 5019: vDataPortOut(ppdev, (PWORD) LineBuff8Bpp, nSrcBytes); ! 5020: pb4Bpp += lSrcDelta; ! 5021: } ! 5022: ! 5023: CHECK_DATA_COMPLETE; ! 5024: ! 5025: return; ! 5026: ! 5027: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.