|
|
/******************************Public*Routine******************************\
* bbddi.cxx** This contains the bitblt simulations code.** Copyright (c) 1993-1999 Microsoft Corporation\**************************************************************************/
#include "precomp.hxx"
/******************************Public*Routine******************************\
* EngBitBlt** DDI entry point. Blts to a engine managed surface.** History:* 16-Feb-1991 -by- Patrick Haluptzok patrickh* Wrote it.\**************************************************************************/
BOOLEngBitBlt( SURFOBJ *psoDst, // Target surface
SURFOBJ *psoSrc, // Source surface
SURFOBJ *psoMask, // Mask
CLIPOBJ *pco, // Clip through this
XLATEOBJ *pxlo, // Color translation
RECTL *prclDst, // Target offset and extent
POINTL *pptlSrc, // Source offset
POINTL *pptlMask, // Mask offset
BRUSHOBJ *pdbrush, // Brush data (from cbRealizeBrush)
POINTL *pptlBrush, // Brush offset (origin)
ROP4 rop4 // Raster operation
){
//
// Validate the ROP
//
ASSERTGDI(psoDst != (SURFOBJ *) NULL, "NULL target passed in\n"); ASSERTGDI(prclDst != (PRECTL) NULL, "Target range\n"); ASSERTGDI(prclDst->left <= prclDst->right, "ERROR Target width not ordered\n"); ASSERTGDI(prclDst->top <= prclDst->bottom, "ERROR Target height not ordered\n"); ASSERTGDI(!(ROP4NEEDPAT(rop4) && (pdbrush == (BRUSHOBJ *) NULL)), "EngBitBlt: Pattern\n"); ASSERTGDI(!(ROP4NEEDPAT(rop4) && (pdbrush->iSolidColor == 0xFFFFFFFF) && (pptlBrush == (PPOINTL) NULL)), "EngBitBlt: Pattern offset\n"); ASSERTGDI(!((psoSrc == (SURFOBJ *) NULL) && ROP4NEEDSRC(rop4)), "EngBitBlt: Source\n"); ASSERTGDI(!((pptlSrc == (PPOINTL) NULL) && ROP4NEEDSRC(rop4)), "EngBitBlt: Source offset\n");
PSURFACE pSurfDst = SURFOBJ_TO_SURFACE_NOT_NULL(psoDst); PSURFACE pSurfSrc = SURFOBJ_TO_SURFACE(psoSrc); PSURFACE pSurfMask = SURFOBJ_TO_SURFACE(psoMask);
RECTL rclSrc;
ASSERTGDI(pSurfDst->iFormat() != BMF_JPEG, "EngBitBlt: dst BMF_JPEG not supported\n"); ASSERTGDI(pSurfDst->iFormat() != BMF_PNG, "EngBitBlt: dst BMF_PNG not supported\n"); ASSERTGDI(!(ROP4NEEDSRC(rop4) && (pSurfSrc->iFormat() == BMF_JPEG)), "EngBitBlt: src BMF_JPEG not supported\n"); ASSERTGDI(!(ROP4NEEDSRC(rop4) && (pSurfSrc->iFormat() == BMF_PNG)), "EngBitBlt: src BMF_PNG not supported\n");
if (psoDst->iType == STYPE_BITMAP) { //
// For profiling purposes, set a flag in the PDEV to indicate that the
// driver punted this call.
//
{ PDEVOBJ po(pSurfDst->hdev()); if (po.bValid()) { po.vDriverPuntedCall(TRUE); } }
//
// Synchronize with the device driver before touching the device surface.
//
{ PDEVOBJ po(pSurfDst->hdev()); po.vSync(psoDst,NULL, 0); }
//
// inc surface uniq for all cases
//
INC_SURF_UNIQ(pSurfDst);
//
// Quick check for dst and pattern rops, and source copy
//
switch(rop4) { case 0x00000000: // DDx (BLACKNESS)
case 0x0000FFFF: // DDxn (WHITENESS)
vDIBSolidBlt(pSurfDst, prclDst, pco, ((rop4 != 0) ? ~0 : 0), 0); return(TRUE);
case 0x0000F0F0: // P (PATCOPY)
case 0x00000F0F: // Pn (NOTPATCOPY)
if (pdbrush->iSolidColor != 0xFFFFFFFF) { vDIBSolidBlt(pSurfDst, prclDst, pco, (rop4 & 0x00000001) ? ~(pdbrush->iSolidColor) : pdbrush->iSolidColor, 0);
return(TRUE); }
if ((pSurfDst->iFormat() == BMF_8BPP) && (rop4 == 0x0000F0F0)) {
//
// We only support 8x8 DIB8 patterns with SRCCOPY right now
//
if (pvGetEngRbrush(pdbrush)) // Can we use this brush?
{ if ((((EBRUSHOBJ *) pdbrush)->pengbrush()->cxPat == 8) && (((EBRUSHOBJ *) pdbrush)->pengbrush()->cyPat == 8))
{ vDIBPatBltSrccopy8x8(pSurfDst, pco, prclDst, pdbrush, pptlBrush, vPatCpyRect8_8x8);
return(TRUE); } } }
if (pSurfDst->iFormat() >= BMF_8BPP) { if (pvGetEngRbrush(pdbrush)) // Can we use this brush?
{ if (((EBRUSHOBJ *) pdbrush)->pengbrush()->cxPat >= 4) { vDIBPatBlt(pSurfDst, pco, prclDst, pdbrush, pptlBrush, (rop4 == 0x0000F0F0) ? DPA_PATCOPY : DPA_PATNOT);
return(TRUE); } } } else if ((pSurfDst->iFormat() == BMF_4BPP) && (rop4 == 0x0000F0F0)) {
//
// We only support 8x8 DIB4 patterns with SRCCOPY right now
//
if (pvGetEngRbrush(pdbrush)) // Can we use this brush?
{ if ((((EBRUSHOBJ *) pdbrush)->pengbrush()->cxPat == 8) && (((EBRUSHOBJ *) pdbrush)->pengbrush()->cyPat == 8)) { ASSERTGDI(((EBRUSHOBJ *) pdbrush)->pengbrush()->lDeltaPat == 4, "BBDDI.CXX: lDeltaPat != 4");
vDIBPatBltSrccopy8x8(pSurfDst, pco, prclDst, pdbrush, pptlBrush, vPatCpyRect4_8x8);
return(TRUE); } } } else if ((pSurfDst->iFormat() == BMF_1BPP) && (rop4 == 0x0000F0F0)) { //
// We support 8x8 and 6x6 DIB1 patterns with SRCCOPY
//
if (pvGetEngRbrush(pdbrush)) // Can we use this brush?
{ //
// Look for 8x8 patterns
//
if ((((EBRUSHOBJ *) pdbrush)->pengbrush()->cxPat == 8) && (((EBRUSHOBJ *) pdbrush)->pengbrush()->cyPat == 8) ) { ASSERTGDI(((EBRUSHOBJ *) pdbrush)->pengbrush()->lDeltaPat == 4, "BBDDI.CXX: lDeltaPat != 4");
vDIBPatBltSrccopy8x8(pSurfDst, pco, prclDst, pdbrush, pptlBrush, vPatCpyRect1_8x8 );
return(TRUE); }
//
// Look for 6x6 patterns
//
if ((((EBRUSHOBJ *)pdbrush)->pengbrush()->cxPat == 6) && (((EBRUSHOBJ *)pdbrush)->pengbrush()->cyPat == 6) ) {
ASSERTGDI(((EBRUSHOBJ *) pdbrush)->pengbrush()->lDeltaPat == 8, "BBDDI.CXX: lDeltaPat != 8");
vDIBnPatBltSrccopy6x6(pSurfDst, pco, prclDst, pdbrush, pptlBrush, vPatCpyRect1_6x6 );
return(TRUE); } } }
break;
case 0x00005A5A: // DPx
if (pdbrush->iSolidColor != 0xFFFFFFFF) { vDIBSolidBlt(pSurfDst, prclDst, pco, pdbrush->iSolidColor, 1);
return(TRUE); }
if (pSurfDst->iFormat() >= BMF_8BPP) { if (pvGetEngRbrush(pdbrush)) // Can we use this brush?
{ if (((EBRUSHOBJ *) pdbrush)->pengbrush()->cxPat >= 4) { vDIBPatBlt(pSurfDst, pco, prclDst, pdbrush, pptlBrush, DPA_PATXOR);
return(TRUE); } } }
break;
//
// Dn degenerates to DPx with a pattern of all ones (0xFFFFFFFF)
//
case 0x00005555: // Dn (DSTINVERT)
vDIBSolidBlt(pSurfDst, prclDst, pco, (ULONG)~0, 1); return(TRUE);
//
// 0xCCAA with a mask surface of NULL really means EngTransparentBlt
// or EngDrawStream.
// We do this as an optimization; see the tops of EngTransparentBlt
// and EngDrawStream for details.
//
case 0x0000CCAA: // Transparent blt or DrawStream
if (psoMask == NULL) { if(pdbrush->pvRbrush == NULL) { rclSrc.left = pptlSrc->x; rclSrc.right = pptlSrc->x + (prclDst->right - prclDst->left); rclSrc.top = pptlSrc->y; rclSrc.bottom = pptlSrc->y + (prclDst->bottom - prclDst->top); return(EngTransparentBlt(psoDst, psoSrc, pco, pxlo, prclDst, &rclSrc, pdbrush->iSolidColor, TRUE)); } else { PDRAWSTREAMINFO pdsi = (PDRAWSTREAMINFO) pdbrush->pvRbrush;
pdsi->bCalledFromBitBlt = TRUE;
return(EngDrawStream(psoDst, psoSrc, pco, pxlo, prclDst, pdsi->pptlDstOffset, pdsi->ulStreamLength, pdsi->pvStream, (DSSTATE*) pdsi)); } } break;
//
// We special case source copy since it must be one of the two following cases:
// a) DIB to DIB, which will just call EngCopyBits.
// b) Device format to DIB, which will just call DrvCopyBits.
//
// We also expect source copy to occur A LOT!
//
case 0x0000CCCC:
if (pSurfSrc->iType() == STYPE_BITMAP) { return(EngCopyBits(psoDst, psoSrc, pco, pxlo, prclDst, pptlSrc)); } else { PDEVOBJ pdoSrc(pSurfSrc->hdev());
return((*PPFNDRV(pdoSrc,CopyBits)) (psoDst, psoSrc, pco, pxlo, prclDst, pptlSrc)); } }
//
// Synchronize with the device driver before touching the device surface.
//
if ((psoSrc != (SURFOBJ *) NULL)) { PDEVOBJ po(pSurfSrc->hdev()); po.vSync(psoSrc, NULL, 0); }
//
// We have to create an empty DIB incase DrvCopyBits needs to be performed.
// We also have to have a POINTL for the final blt for use as the source org.
//
SURFMEM SurfDimo;
//
// Handle the Device ==> DIB conversion if required
//
if (ROP4NEEDSRC(rop4) && (pSurfSrc->iType() != STYPE_BITMAP)) { PDEVOBJ pdoSrc(pSurfSrc->hdev());
//
// Allocate an intermediate DIB for a source.
//
ERECTL erclTmp(0L, 0L, prclDst->right - prclDst->left, prclDst->bottom - prclDst->top);
DEVBITMAPINFO dbmi; dbmi.iFormat = pSurfDst->iFormat(); dbmi.cxBitmap = erclTmp.right; dbmi.cyBitmap = erclTmp.bottom; dbmi.hpal = 0; dbmi.fl = pSurfSrc->bUMPD() ? UMPD_SURFACE : 0;
if (!SurfDimo.bCreateDIB(&dbmi, NULL)) { WARNING("bCreateDIB failed in EngBitBlt\n"); return(FALSE); }
(*PPFNDRV(pdoSrc,CopyBits)) ( (SURFOBJ *) SurfDimo.pSurfobj(), psoSrc, (CLIPOBJ *) NULL, pxlo, (PRECTL) &erclTmp, pptlSrc);
//
// Make psoSrc and pptlSrc point to the correct thing.
//
pptlSrc = (POINTL *) &gptl00; pSurfSrc = SurfDimo.ps;
//
// Color translation has already been performed, so make
// the XLATE an identity.
//
pxlo = &xloIdent; }
//
// Call BltLnk to perform the ROP
//
if (!BltLnk(pSurfDst, pSurfSrc, pSurfMask, (ECLIPOBJ *) pco, (XLATE *) pxlo, prclDst, pptlSrc, pptlMask, pdbrush, pptlBrush, rop4) ) { WARNING1("BltLnk Returns FALSE\n"); } } else {
//
// We have to do simulations on a device surface
//
return(SimBitBlt(psoDst,psoSrc,psoMask, pco,pxlo, prclDst,pptlSrc,pptlMask, pdbrush,pptlBrush,rop4, NULL)); }
return(TRUE);}
/******************************Public*Routine******************************\
* EngEraseSurface** Asks GDI to erase the surface. The rcl will be filled with* iColor.** History:* 02-May-1991 -by- Patrick Haluptzok patrickh* Wrote it.\**************************************************************************/
BOOLEngEraseSurface( SURFOBJ *pso, PRECTL prcl, ULONG iColor ){
PSURFACE pSurf = (SURFACE *)(SURFOBJ_TO_SURFACE(pso));
if(pSurf == 0) return FALSE;
ASSERTGDI(prcl != (PRECTL) NULL, "ERROR EngEraseSurface1"); ASSERTGDI(prcl->left >= 0, "ERROR EngEraseSurface2"); ASSERTGDI(prcl->top >= 0, "ERROR EngEraseSurface3"); ASSERTGDI(prcl->right <= pSurf->sizl().cx, "ERROR EngEraseSurface4"); ASSERTGDI(prcl->bottom <= pSurf->sizl().cy, "ERROR EngEraseSurface5");
//
// Synchronize with the device driver before touching the device surface.
//
{ PDEVOBJ po(pSurf->hdev()); po.vSync(pso,NULL, 0); }
vDIBSolidBlt(pSurf, prcl, (CLIPOBJ *) NULL, iColor, 0); return(TRUE);}
/******************************Public*Routine******************************\
* SimBitBlt** The engine sends EngBitBlt here if a DEVICE surface is passed as psoTrg** History:* 23-Feb-1994 -by- Eric Kutter [erick]* Made it callable from other functions - allow device to device blts.** 09-Sep-1992 -by- Donald Sidoroff [donalds]* Made it callable from EngBitBlt only.** 07-Sep-1991 -by- Patrick Haluptzok patrickh* Wrote it.\**************************************************************************/
BOOLSimBitBlt( SURFOBJ *psoDst, // Target surface
SURFOBJ *psoSrc, // Source surface
SURFOBJ *psoMask, // Mask
CLIPOBJ *pco, // Clip through this
XLATEOBJ *pxlo, // Color translation
RECTL *prclDst, // Target offset and extent
POINTL *pptlSrc, // Source offset
POINTL *pptlMask, // Mask offset
BRUSHOBJ *pdbrush, // Brush data (from cbRealizeBrush)
POINTL *pptlBrush, // Brush offset (origin)
ROP4 rop4, // Raster operation
PVOID pdlo // for unlock if necessary
){ BOOL bNeedSrc = ROP4NEEDSRC(rop4);
PSURFACE pSurfDst = (SURFACE *)(SURFOBJ_TO_SURFACE(psoDst)); PSURFACE pSurfSrc = (SURFACE *)(SURFOBJ_TO_SURFACE(psoSrc));
PDEVOBJ pdoDst(pSurfDst->hdev());
ASSERTGDI(pdoDst.bValid(), "EngPuntBlt poDst.bValid");
//
// if source and destination are both engine managed
// bitmaps, then BitBlt directly
//
if ( (pSurfDst->iType() == STYPE_BITMAP) && ((!bNeedSrc) || (pSurfSrc->iType() == STYPE_BITMAP)) && (psoMask == NULL) ) { BOOL bReturn;
if (!pdoDst.bUMPD()) { bReturn = (*(pSurfDst->pfnBitBlt())) ( psoDst, psoSrc, psoMask, pco, pxlo, prclDst, pptlSrc, pptlMask, pdbrush, pptlBrush, rop4); } else { bReturn = EngBitBlt( psoDst, psoSrc, psoMask, pco, pxlo, prclDst, pptlSrc, pptlMask, pdbrush, pptlBrush, rop4); } return(bReturn); }
//
// For profiling purposes, set a flag in the PDEV to indicate that the
// driver punted this call.
//
{ PDEVOBJ po(pSurfDst->hdev()); if (po.bValid()) { po.vDriverPuntedCall(TRUE); } }
// Get the bounds of the destination rectangle
RECTL rclDstBounds;
if( pSurfDst->iType() == STYPE_DEVICE && pdoDst.bValid() && pdoDst.bMetaDriver()) { rclDstBounds.left = pdoDst.pptlOrigin()->x; rclDstBounds.top = pdoDst.pptlOrigin()->y; rclDstBounds.right = pdoDst.pptlOrigin()->x + pSurfDst->sizl().cx; rclDstBounds.bottom = pdoDst.pptlOrigin()->y + pSurfDst->sizl().cy; } else { rclDstBounds.left = 0; rclDstBounds.top = 0; rclDstBounds.right = pSurfDst->sizl().cx; rclDstBounds.bottom = pSurfDst->sizl().cy; }
//
// Set up new rectangle clipped to destination surface. Clip source
// pointl and mask pointl accordingly.
//
RECTL rclReduced = *prclDst; POINTL ptlSrc; POINTL ptlMask;
if (bNeedSrc) { ptlSrc = *pptlSrc; }
if (psoMask != NULL) { ptlMask = *pptlMask; }
if (rclReduced.top < rclDstBounds.top) { ptlSrc.y += (rclDstBounds.top-rclReduced.top); ptlMask.y += (rclDstBounds.top-rclReduced.top); rclReduced.top = rclDstBounds.top; }
if (rclReduced.left < rclDstBounds.left) { ptlSrc.x += (rclDstBounds.left-rclReduced.left); ptlMask.x += (rclDstBounds.left-rclReduced.left); rclReduced.left = rclDstBounds.left; }
if (rclReduced.bottom > rclDstBounds.bottom) { rclReduced.bottom = rclDstBounds.bottom; }
if (rclReduced.right > rclDstBounds.right) { rclReduced.right = rclDstBounds.right; }
if( rclReduced.top >= rclReduced.bottom || rclReduced.left >= rclReduced.right ) { // Destination rectangle is outside of the
// destination surface
return TRUE; }
//
// Ok we clipped everything to our reduced rectangle, now use the clipped offsets.
//
prclDst = &rclReduced; pptlSrc = &ptlSrc; pptlMask = &ptlMask;
//
// Set up our temporary DIB rectangle to blt to.
//
ERECTL erclDst(0, 0, prclDst->right - prclDst->left, prclDst->bottom - prclDst->top);
//
// iDitherFormat must match destination format
//
if (pSurfDst->iFormat() != pdoDst.iDitherFormat()) { WARNING("SimBitBlt: pSurfDst->iFormat != pdoDst.iDitherFormat\n"); return(FALSE); }
//
// We have to create an empty DIB incase DrvCopyBits needs to be performed.
// We also have to have a POINTL for the final blt for use as the source org.
//
SURFMEM SurfDimoSrc;
//
// Handle the Device ==> DIB conversion if required
//
if (bNeedSrc && (pSurfSrc->iType() != STYPE_BITMAP)) {
PDEVOBJ pdoSrc(pSurfSrc->hdev());
//
// Allocate an intermediate DIB for a source.
//
DEVBITMAPINFO dbmiSrc; dbmiSrc.iFormat = pdoDst.iDitherFormat(); dbmiSrc.cxBitmap = erclDst.right; dbmiSrc.cyBitmap = erclDst.bottom; dbmiSrc.hpal = 0; dbmiSrc.fl = pSurfSrc->bUMPD() ? UMPD_SURFACE : 0;
if (!SurfDimoSrc.bCreateDIB(&dbmiSrc, NULL)) { WARNING("Failed dimoSrc memory alloc in EngPuntBlt\n"); return(FALSE); }
(*PPFNGET(pdoSrc,CopyBits,pSurfSrc->flags())) (SurfDimoSrc.pSurfobj(), psoSrc, (CLIPOBJ *) NULL, pxlo, (PRECTL) &erclDst, pptlSrc);
//
// Make psoSrc and pptlSrc point to the correct thing.
//
pptlSrc = &gptl00; psoSrc = SurfDimoSrc.pSurfobj();
//
// Color translation has already been performed, so make
// the XLATEOBJ an identity.
//
pxlo = &xloIdent; }
DEVBITMAPINFO dbmiDst; dbmiDst.iFormat = pdoDst.iDitherFormat(); dbmiDst.cxBitmap = erclDst.right; dbmiDst.cyBitmap = erclDst.bottom; dbmiDst.hpal = 0; dbmiDst.fl = pSurfDst->bUMPD() ? UMPD_SURFACE : 0;
SURFMEM SurfDimoDst;
SurfDimoDst.bCreateDIB(&dbmiDst, NULL);
if (!SurfDimoDst.bValid()) { return(FALSE); }
POINTL ptlDst; ptlDst.x = prclDst->left; ptlDst.y = prclDst->top;
POINTL ptlBrush;
if (pptlBrush != (POINTL *) NULL) { ptlBrush.x = pptlBrush->x - prclDst->left; ptlBrush.y = pptlBrush->y - prclDst->top; }
//
// if we are going out to the user mode printer driver
// unlock the DEVLOCKBLTOBJ. Only the src might be locked
// and from here we are only going to deal with the temp src dib
// so it's safe to unlock here.
//
if (pdoDst.bPrinter() && pdlo) { ((DEVLOCKBLTOBJ *)pdlo)->vUnLock(); }
// WINBUG #206475 bhouse 10-18-2000 Old potential perf bug
// We should only copy the destination if the ROP requires
// destination data.
(*PPFNGET(pdoDst,CopyBits,pSurfDst->flags())) (SurfDimoDst.pSurfobj(), psoDst, (CLIPOBJ *) NULL, &xloIdent, &erclDst, &ptlDst);
ASSERTGDI(SurfDimoDst.ps->iType() == STYPE_BITMAP, "ERROR dimoDst.iType 1");
//
// Call off to BitBlt, if it fails who cares.
//
EngBitBlt(SurfDimoDst.pSurfobj(), psoSrc, psoMask, (ECLIPOBJ *) NULL, pxlo, &erclDst, pptlSrc, pptlMask, pdbrush, &ptlBrush, rop4);
//
// Inc output surface uniqueness
//
INC_SURF_UNIQ(pSurfDst);
return((*PPFNGET(pdoDst,CopyBits,pSurfDst->flags())) ( psoDst, SurfDimoDst.pSurfobj(), pco, &xloIdent, prclDst, &gptl00));}
|
