|
|
/******************************Module*Header*******************************\
** ******************** * GDI SAMPLE CODE ** ********************* Module Name: bitblt.c** Contains the high-level DrvBitBlt and DrvCopyBits functions. The low-* level stuff lives in the 'blt??.c' files.** Note: The way we've implemented device-bitmaps has changed in NT5, with* the advent of 'EngModifySurface' and 'DrvDeriveSurface'. Now,* off-screen bitmaps will always have an iType of STYPE_BITMAP * (meaning that GDI can draw directly on the bits if it needs to).* Additionally, former off-screen bitmaps that have been converted* by us to system-memory DIBs will still have an iType of STYPE_BITMAP.** Copyright (c) 1992-1998 Microsoft Corporation\**************************************************************************/
#include "precomp.h"
/******************************Public*Routine******************************\
* VOID vXferNativeSrccopy** Does a SRCCOPY transfer of a bitmap to the screen using the frame* buffer, because with USWC write-combining it's significantly faster* than using the data transfer register.*\**************************************************************************/
VOID vXferNativeSrccopy( // Type FNXFER
PDEV* ppdev,LONG c, // Count of rectangles, can't be zero
RECTL* prcl, // List of destination rectangles, in relative
// coordinates
ULONG rop4, // Not used
SURFOBJ* psoSrc, // Source surface
POINTL* pptlSrc, // Original unclipped source point
RECTL* prclDst, // Original unclipped destination rectangle
XLATEOBJ* pxlo) // Not used
{ LONG xOffset; LONG yOffset; LONG dx; LONG dy; RECTL rclDst; POINTL ptlSrc;
ASSERTDD((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL), "Can handle trivial xlate only"); ASSERTDD(psoSrc->iBitmapFormat == ppdev->iBitmapFormat, "Source must be same colour depth as screen"); ASSERTDD(c > 0, "Can't handle zero rectangles"); ASSERTDD(rop4 == 0xcccc, "Must be a SRCCOPY rop");
xOffset = ppdev->xOffset; yOffset = ppdev->yOffset;
dx = pptlSrc->x - prclDst->left; dy = pptlSrc->y - prclDst->top; // Add to destination to get source
while (TRUE) { ptlSrc.x = prcl->left + dx; ptlSrc.y = prcl->top + dy;
// 'vPutBits' takes only absolute coordinates, so add in the
// off-screen bitmap offset here:
rclDst.left = prcl->left + xOffset; rclDst.right = prcl->right + xOffset; rclDst.top = prcl->top + yOffset; rclDst.bottom = prcl->bottom + yOffset;
vPutBits(ppdev, psoSrc, &rclDst, &ptlSrc);
if (--c == 0) return;
prcl++; }}
/******************************Public*Routine******************************\
* VOID vReadNativeSrccopy** Does a SRCCOPY read from the screen to a system-memory bitmap. The only* reason we do this here instead of punting to GDI is to ensure that we* do dword reads that are aligned to the video-memory source and not the* system-memory destination.*\**************************************************************************/
VOID vReadNativeSrccopy( // Type FNXFER
PDEV* ppdev,LONG c, // Count of rectangles, can't be zero
RECTL* prcl, // List of destination rectangles, in relative
// coordinates
ULONG rop4, // Not used
SURFOBJ* psoDst, // Destination surface
POINTL* pptlSrc, // Original unclipped source point
RECTL* prclDst, // Original unclipped destination rectangle
XLATEOBJ* pxlo) // Not used
{ LONG xOffset; LONG yOffset; LONG dx; LONG dy; RECTL rclDst; POINTL ptlSrc;
ASSERTDD((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL), "Can handle trivial xlate only"); ASSERTDD(psoDst->iBitmapFormat == ppdev->iBitmapFormat, "Source must be same colour depth as screen"); ASSERTDD(c > 0, "Can't handle zero rectangles"); ASSERTDD(rop4 == 0xcccc, "Must be a SRCCOPY rop");
xOffset = ppdev->xOffset; yOffset = ppdev->yOffset;
dx = pptlSrc->x - prclDst->left; dy = pptlSrc->y - prclDst->top; // Add to destination to get source
while (TRUE) { // 'vGetBits' takes only absolute coordinates, so add in the
// off-screen bitmap offset here:
ptlSrc.x = prcl->left + dx + xOffset; ptlSrc.y = prcl->top + dy + yOffset;
vGetBits(ppdev, psoDst, prcl, &ptlSrc);
if (--c == 0) return;
prcl++; }}
/******************************Public*Routine******************************\
* BOOL bPuntBlt** Has GDI do any drawing operations that we don't specifically handle* in the driver.*\**************************************************************************/
BOOL bPuntBlt(SURFOBJ* psoDst,SURFOBJ* psoSrc,SURFOBJ* psoMsk,CLIPOBJ* pco,XLATEOBJ* pxlo,RECTL* prclDst,POINTL* pptlSrc,POINTL* pptlMsk,BRUSHOBJ* pbo,POINTL* pptlBrush,ROP4 rop4){ PDEV* ppdev;
if (psoDst->dhsurf != NULL) ppdev = (PDEV*) psoDst->dhpdev; else ppdev = (PDEV*) psoSrc->dhpdev;
#if DBG
{ //////////////////////////////////////////////////////////////////////
// Diagnostics
//
// Since calling the engine to do any drawing can be rather painful,
// particularly when the source is an off-screen DFB (since GDI will
// have to allocate a DIB and call us to make a temporary copy before
// it can even start drawing), we'll try to avoid it as much as
// possible.
//
// Here we simply spew out information describing the blt whenever
// this routine gets called (checked builds only, of course):
ULONG ulClip; PDEV* dbg_ppdev;
if (psoDst->dhsurf != NULL) dbg_ppdev = (PDEV*) psoDst->dhpdev; else dbg_ppdev = (PDEV*) psoSrc->dhpdev;
ulClip = (pco == NULL) ? DC_TRIVIAL : pco->iDComplexity;
DISPDBG((2, ">> Punt << Dst format: %li Dst type: %li Clip: %li Rop: %lx", psoDst->iBitmapFormat, psoDst->iType, ulClip, rop4));
if (psoSrc != NULL) { DISPDBG((2, " << Src format: %li Src type: %li", psoSrc->iBitmapFormat, psoSrc->iType));
if (psoSrc->iBitmapFormat == BMF_1BPP) { DISPDBG((2, " << Foreground: %lx Background: %lx", pxlo->pulXlate[1], pxlo->pulXlate[0])); } }
if ((pxlo != NULL) && !(pxlo->flXlate & XO_TRIVIAL) && (psoSrc != NULL)) { if (((psoSrc->dhsurf == NULL) && (psoSrc->iBitmapFormat != dbg_ppdev->iBitmapFormat)) || ((psoDst->dhsurf == NULL) && (psoDst->iBitmapFormat != dbg_ppdev->iBitmapFormat))) { // Don't bother printing the 'xlate' message when the source
// is a different bitmap format from the destination -- in
// those cases we know there always has to be a translate.
} else { DISPDBG((2, " << With xlate")); } }
// If the rop4 requires a pattern, and it's a non-solid brush...
if (((((rop4 >> 4) ^ (rop4)) & 0x0f0f) != 0) && (pbo->iSolidColor == -1)) { if (pbo->pvRbrush == NULL) DISPDBG((2, " << With brush -- Not created")); else DISPDBG((2, " << With brush -- Created Ok")); } } #endif
if (DIRECT_ACCESS(ppdev)) { //////////////////////////////////////////////////////////////////////
// Banked Framebuffer bPuntBlt
//
// This section of code handles a PuntBlt when GDI can directly draw
// on the framebuffer, but the drawing has to be done in banks:
BANK bnk; BOOL b; HSURF hsurfTmp; SURFOBJ* psoTmp; SIZEL sizl; POINTL ptlSrc; RECTL rclTmp; RECTL rclDst; DSURF* pdsurfDst; DSURF* pdsurfSrc;
// We copy the original destination rectangle, and use that in every
// GDI call-back instead of the original because sometimes GDI is
// sneaky and points 'prclDst' to '&pco->rclBounds'. Because we
// modify 'rclBounds', that would affect 'prclDst', which we don't
// want to happen:
rclDst = *prclDst;
pdsurfDst = (DSURF*) psoDst->dhsurf; pdsurfSrc = (psoSrc == NULL) ? NULL : (DSURF*) psoSrc->dhsurf;
if ((pdsurfSrc == NULL) || (pdsurfSrc->dt & DT_DIB)) { // Do a memory-to-screen blt:
vBankStart(ppdev, &rclDst, pco, &bnk);
b = TRUE; do { b &= EngBitBlt(bnk.pso, psoSrc, psoMsk, bnk.pco, pxlo, &rclDst, pptlSrc, pptlMsk, pbo, pptlBrush, rop4);
} while (bBankEnum(&bnk)); } else { b = FALSE; // Assume failure
// The screen is the source (it may be the destination too...)
ptlSrc.x = pptlSrc->x + ppdev->xOffset; ptlSrc.y = pptlSrc->y + ppdev->yOffset;
if ((pco != NULL) && (pco->iDComplexity != DC_TRIVIAL)) { // We have to intersect the destination rectangle with
// the clip bounds if there is one (consider the case
// where the app asked to blt a really, really big
// rectangle from the screen -- prclDst would be really,
// really big but pco->rclBounds would be the actual
// area of interest):
rclDst.left = max(rclDst.left, pco->rclBounds.left); rclDst.top = max(rclDst.top, pco->rclBounds.top); rclDst.right = min(rclDst.right, pco->rclBounds.right); rclDst.bottom = min(rclDst.bottom, pco->rclBounds.bottom);
// Correspondingly, we have to offset the source point:
ptlSrc.x += (rclDst.left - prclDst->left); ptlSrc.y += (rclDst.top - prclDst->top); }
// We're now either going to do a screen-to-screen or screen-to-DIB
// blt. In either case, we're going to create a temporary copy of
// the source. (Why do we do this when GDI could do it for us?
// GDI would create a temporary copy of the DIB for every bank
// call-back!)
sizl.cx = rclDst.right - rclDst.left; sizl.cy = rclDst.bottom - rclDst.top;
// Don't forget to convert from relative to absolute coordinates
// on the source! (vBankStart takes care of that for the
// destination.)
rclTmp.right = sizl.cx; rclTmp.bottom = sizl.cy; rclTmp.left = 0; rclTmp.top = 0;
// GDI does guarantee us that the blt extents have already been
// clipped to the surface boundaries (we don't have to worry
// here about trying to read where there isn't video memory).
// Let's just assert to make sure:
ASSERTDD((ptlSrc.x >= 0) && (ptlSrc.y >= 0) && (ptlSrc.x + sizl.cx <= ppdev->cxMemory) && (ptlSrc.y + sizl.cy <= ppdev->cyMemory), "Source rectangle out of bounds!");
hsurfTmp = (HSURF) EngCreateBitmap(sizl, 0, // Let GDI choose ulWidth
ppdev->iBitmapFormat, 0, // Don't need any options
NULL);// Let GDI allocate
if (hsurfTmp != 0) { psoTmp = EngLockSurface(hsurfTmp);
if (psoTmp != NULL) { vGetBits(ppdev, psoTmp, &rclTmp, &ptlSrc);
if ((pdsurfDst == NULL) || (pdsurfDst->dt & DT_DIB)) { // It was a Screen-to-DIB blt; now it's a DIB-to-DIB
// blt. Note that the source point is (0, 0) in our
// temporary surface:
b = EngBitBlt(psoDst, psoTmp, psoMsk, pco, pxlo, &rclDst, (POINTL*) &rclTmp, pptlMsk, pbo, pptlBrush, rop4); } else { // It was a Screen-to-Screen blt; now it's a DIB-to-
// screen blt. Note that the source point is (0, 0)
// in our temporary surface:
vBankStart(ppdev, &rclDst, pco, &bnk);
b = TRUE; do { b &= EngBitBlt(bnk.pso, psoTmp, psoMsk, bnk.pco, pxlo, &rclDst, (POINTL*) &rclTmp, pptlMsk, pbo, pptlBrush, rop4);
} while (bBankEnum(&bnk)); }
EngUnlockSurface(psoTmp); }
EngDeleteSurface(hsurfTmp); } }
return(b); }
#if !defined(_X86_)
else { //////////////////////////////////////////////////////////////////////
// Really Slow bPuntBlt
//
// Here we handle a PuntBlt when GDI can't draw directly on the
// framebuffer (as on the Alpha, which can't do it because of its
// 32 bit bus). If you thought the banked version was slow, just
// look at this one. Guaranteed, there will be at least one bitmap
// allocation and extra copy involved; there could be two if it's a
// screen-to-screen operation.
POINTL ptlSrc; RECTL rclDst; SIZEL sizl; BOOL bSrcIsScreen; HSURF hsurfSrc; RECTL rclTmp; BOOL b; LONG lDelta; BYTE* pjBits; BYTE* pjScan0; HSURF hsurfDst; RECTL rclScreen;
b = FALSE; // For error cases, assume we'll fail
rclDst = *prclDst; if (pptlSrc != NULL) ptlSrc = *pptlSrc;
if ((pco != NULL) && (pco->iDComplexity != DC_TRIVIAL)) { // We have to intersect the destination rectangle with
// the clip bounds if there is one (consider the case
// where the app asked to blt a really, really big
// rectangle from the screen -- prclDst would be really,
// really big but pco->rclBounds would be the actual
// area of interest):
rclDst.left = max(rclDst.left, pco->rclBounds.left); rclDst.top = max(rclDst.top, pco->rclBounds.top); rclDst.right = min(rclDst.right, pco->rclBounds.right); rclDst.bottom = min(rclDst.bottom, pco->rclBounds.bottom);
ptlSrc.x += (rclDst.left - prclDst->left); ptlSrc.y += (rclDst.top - prclDst->top); }
sizl.cx = rclDst.right - rclDst.left; sizl.cy = rclDst.bottom - rclDst.top;
// We only need to make a copy from the screen if the source is
// the screen, and the source is involved in the rop. Note that
// we have to check the rop before dereferencing 'psoSrc'
// (because 'psoSrc' may be NULL if the source isn't involved):
bSrcIsScreen = (((((rop4 >> 2) ^ (rop4)) & 0x3333) != 0) && (psoSrc->dhsurf != NULL));
if (bSrcIsScreen) { // We need to create a copy of the source rectangle:
hsurfSrc = (HSURF) EngCreateBitmap(sizl, 0, ppdev->iBitmapFormat, 0, NULL); if (hsurfSrc == 0) goto Error_0;
psoSrc = EngLockSurface(hsurfSrc); if (psoSrc == NULL) goto Error_1;
rclTmp.left = 0; rclTmp.top = 0; rclTmp.right = sizl.cx; rclTmp.bottom = sizl.cy;
// vGetBits takes absolute coordinates for the source point:
ptlSrc.x += ppdev->xOffset; ptlSrc.y += ppdev->yOffset;
vGetBits(ppdev, psoSrc, &rclTmp, &ptlSrc);
// The source will now come from (0, 0) of our temporary source
// surface:
ptlSrc.x = 0; ptlSrc.y = 0; }
if (psoDst->dhsurf == NULL) { b = EngBitBlt(psoDst, psoSrc, psoMsk, pco, pxlo, &rclDst, &ptlSrc, pptlMsk, pbo, pptlBrush, rop4); } else { // We need to create a temporary work buffer. We have to do
// some fudging with the offsets so that the upper-left corner
// of the (relative coordinates) clip object bounds passed to
// GDI will be transformed to the upper-left corner of our
// temporary bitmap.
// The alignment doesn't have to be as tight as this at 16bpp
// and 32bpp, but it won't hurt:
lDelta = CONVERT_TO_BYTES((((rclDst.right + 3) & ~3L) - (rclDst.left & ~3L)), ppdev);
// We're actually only allocating a bitmap that is 'sizl.cx' x
// 'sizl.cy' in size:
pjBits = EngAllocMem(0, lDelta * sizl.cy, ALLOC_TAG); if (pjBits == NULL) goto Error_2;
// We now adjust the surface's 'pvScan0' so that when GDI thinks
// it's writing to pixel (rclDst.top, rclDst.left), it will
// actually be writing to the upper-left pixel of our temporary
// bitmap:
pjScan0 = pjBits - (rclDst.top * lDelta) - CONVERT_TO_BYTES((rclDst.left & ~3L), ppdev);
ASSERTDD((((ULONG_PTR) pjScan0) & 3) == 0, "pvScan0 must be dword aligned!");
// The checked build of GDI sometimes checks on blts that
// prclDst->right <= pso->sizl.cx, so we lie to it about
// the size of our bitmap:
sizl.cx = rclDst.right; sizl.cy = rclDst.bottom;
hsurfDst = (HSURF) EngCreateBitmap( sizl, // Bitmap covers rectangle
lDelta, // Use this delta
ppdev->iBitmapFormat, // Same colour depth
BMF_TOPDOWN, // Must have a positive delta
pjScan0); // Where (0, 0) would be
if ((hsurfDst == 0) || (!EngAssociateSurface(hsurfDst, ppdev->hdevEng, 0))) goto Error_3;
psoDst = EngLockSurface(hsurfDst); if (psoDst == NULL) goto Error_4;
// Make sure that the rectangle we Get/Put from/to the screen
// is in absolute coordinates:
rclScreen.left = rclDst.left + ppdev->xOffset; rclScreen.right = rclDst.right + ppdev->xOffset; rclScreen.top = rclDst.top + ppdev->yOffset; rclScreen.bottom = rclDst.bottom + ppdev->yOffset;
// It would be nice to get a copy of the destination rectangle
// only when the ROP involves the destination (or when the source
// is an RLE), but we can't do that. If the brush is truly NULL,
// GDI will immediately return TRUE from EngBitBlt, without
// modifying the temporary bitmap -- and we would proceed to
// copy the uninitialized temporary bitmap back to the screen.
vGetBits(ppdev, psoDst, &rclDst, (POINTL*) &rclScreen);
b = EngBitBlt(psoDst, psoSrc, psoMsk, pco, pxlo, &rclDst, &ptlSrc, pptlMsk, pbo, pptlBrush, rop4);
vPutBits(ppdev, psoDst, &rclScreen, (POINTL*) &rclDst);
EngUnlockSurface(psoDst);
Error_4:
EngDeleteSurface(hsurfDst);
Error_3:
EngFreeMem(pjBits); }
Error_2:
if (bSrcIsScreen) { EngUnlockSurface(psoSrc);
Error_1:
EngDeleteSurface(hsurfSrc); }
Error_0:
return(b); }
#endif
}
/******************************Public*Routine******************************\
* BOOL DrvBitBlt** Implements the workhorse routine of a display driver.*\**************************************************************************/
BOOL DrvBitBlt(SURFOBJ* psoDst,SURFOBJ* psoSrc,SURFOBJ* psoMsk,CLIPOBJ* pco,XLATEOBJ* pxlo,RECTL* prclDst,POINTL* pptlSrc,POINTL* pptlMsk,BRUSHOBJ* pbo,POINTL* pptlBrush,ROP4 rop4){ PDEV* ppdev; DSURF* pdsurfDst; DSURF* pdsurfSrc; POINTL ptlSrc; BOOL bMore; CLIPENUM ce; LONG c; RECTL rcl; BYTE rop3; FNFILL* pfnFill; RBRUSH_COLOR rbc; // Realized brush or solid colour
FNXFER* pfnXfer; ULONG iSrcBitmapFormat; ULONG iDir; BOOL bRet;
bRet = TRUE; // Assume success
pdsurfDst = (DSURF*) psoDst->dhsurf; // May be NULL
if (psoSrc == NULL) { pdsurfSrc = NULL;
if (!(pdsurfDst->dt & DT_DIB)) { ///////////////////////////////////////////////////////////////////
// Fills
///////////////////////////////////////////////////////////////////
// Fills are this function's "raison d'etre", so we handle them
// as quickly as possible:
ppdev = (PDEV*) psoDst->dhpdev;
ppdev->xOffset = pdsurfDst->x; ppdev->yOffset = pdsurfDst->y;
// Make sure it doesn't involve a mask (i.e., it's really a
// Rop3):
rop3 = (BYTE) rop4;
if ((BYTE) (rop4 >> 8) == rop3) { // Since 'psoSrc' is NULL, the rop3 had better not indicate
// that we need a source.
ASSERTDD((((rop4 >> 2) ^ (rop4)) & 0x33) == 0, "Need source but GDI gave us a NULL 'psoSrc'");
Fill_It:
pfnFill = ppdev->pfnFillSolid; // Default to solid fill
if ((((rop3 >> 4) ^ (rop3)) & 0xf) != 0) { // The rop says that a pattern is truly required
// (blackness, for instance, doesn't need one):
rbc.iSolidColor = pbo->iSolidColor; if (rbc.iSolidColor == -1) { // Try and realize the pattern brush; by doing
// this call-back, GDI will eventually call us
// again through DrvRealizeBrush:
rbc.prb = pbo->pvRbrush; if (rbc.prb == NULL) { rbc.prb = BRUSHOBJ_pvGetRbrush(pbo); if (rbc.prb == NULL) { // If we couldn't realize the brush, punt
// the call (it may have been a non 8x8
// brush or something, which we can't be
// bothered to handle, so let GDI do the
// drawing):
goto Punt_It; } }
if ((ppdev->iBitmapFormat == BMF_24BPP) && ((BYTE) (rop4 >> 8) != rop3)) { goto Punt_It; } pfnFill = ppdev->pfnFillPat; } }
// Note that these 2 'if's are more efficient than
// a switch statement:
if ((pco == NULL) || (pco->iDComplexity == DC_TRIVIAL)) { pfnFill(ppdev, 1, prclDst, rop4, rbc, pptlBrush); goto All_Done; } else if (pco->iDComplexity == DC_RECT) { if (bIntersect(prclDst, &pco->rclBounds, &rcl)) pfnFill(ppdev, 1, &rcl, rop4, rbc, pptlBrush); goto All_Done; } else { CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0);
do { bMore = CLIPOBJ_bEnum(pco, sizeof(ce), (ULONG*) &ce);
c = cIntersect(prclDst, ce.arcl, ce.c);
if (c != 0) pfnFill(ppdev, c, ce.arcl, rop4, rbc, pptlBrush);
} while (bMore); goto All_Done; } } } else { // Thanks to EngModifySurface, the destination is really a
// plane old DIB, so we can forget about our DSURF structure
// (this will simplify checks later in this routine):
pdsurfDst = NULL; } } else { pdsurfDst = (DSURF*) psoDst->dhsurf; if ((pdsurfDst != NULL) && (pdsurfDst->dt & DT_DIB)) { // The destination is really a plane old DIB.
pdsurfDst = NULL; }
pdsurfSrc = (DSURF*) psoSrc->dhsurf; if ((pdsurfSrc != NULL) && (pdsurfSrc->dt & DT_DIB)) { // Here we consider putting a DIB DFB back into off-screen
// memory. If there's a translate, it's probably not worth
// moving since we won't be able to use the hardware to do
// the blt (a similar argument could be made for weird rops
// and stuff that we'll only end up having GDI simulate, but
// those should happen infrequently enough that I don't care).
//
// This is only worth doing if the destination is in off-
// screen memory, though!
if ((pdsurfDst != NULL) && ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL))) { ppdev = pdsurfSrc->ppdev;
// See 'DrvCopyBits' for some more comments on how this
// moving-it-back-into-off-screen-memory thing works:
if (pdsurfSrc->iUniq == ppdev->iHeapUniq) { if (--pdsurfSrc->cBlt == 0) { if (bMoveDibToOffscreenDfbIfRoom(ppdev, pdsurfSrc)) goto Continue_It; } } else { // Some space was freed up in off-screen memory,
// so reset the counter for this DFB:
pdsurfSrc->iUniq = ppdev->iHeapUniq; pdsurfSrc->cBlt = HEAP_COUNT_DOWN; } }
// The source is really a plane old DIB.
pdsurfSrc = NULL; } }
Continue_It: ASSERTDD((pdsurfSrc == NULL) || !(pdsurfSrc->dt & DT_DIB), "pdsurfSrc should be non-NULL only if in off-screen memory"); ASSERTDD((pdsurfDst == NULL) || !(pdsurfDst->dt & DT_DIB), "pdsurfDst should be non-NULL only if in off-screen memory");
if (pdsurfDst != NULL) { // The destination is in video memory.
if (pdsurfSrc != NULL) { // The source is also in video memory. This is effectively
// a screen-to-screen blt, so adjust the source point:
ptlSrc.x = pptlSrc->x - (pdsurfDst->x - pdsurfSrc->x); ptlSrc.y = pptlSrc->y - (pdsurfDst->y - pdsurfSrc->y); pptlSrc = &ptlSrc; }
ppdev = pdsurfDst->ppdev;
ppdev->xOffset = pdsurfDst->x; ppdev->yOffset = pdsurfDst->y; } else { // The destination is a DIB.
if (pdsurfSrc == NULL) { // The source is a DIB, too. Let GDI handle it.
goto EngBitBlt_It; }
ppdev = pdsurfSrc->ppdev;
ppdev->xOffset = pdsurfSrc->x; ppdev->yOffset = pdsurfSrc->y; }
if (((rop4 >> 8) & 0xff) == (rop4 & 0xff)) { // Since we've already handled the cases where the ROP4 is really
// a ROP3 and no source is required, we can assert...
ASSERTDD((psoSrc != NULL) && (pptlSrc != NULL), "Expected no-source case to already have been handled");
///////////////////////////////////////////////////////////////////
// Bitmap transfers
///////////////////////////////////////////////////////////////////
// Since the foreground and background ROPs are the same, we
// don't have to worry about no stinking masks (it's a simple
// Rop3).
rop3 = (BYTE) rop4; // Make it into a Rop3 (we keep the rop4
// around in case we decide to punt)
if (pdsurfDst != NULL) { // The destination is the screen. See if the ROP3 requires a
// pattern:
if ((rop3 >> 4) == (rop3 & 0xf)) { // Nope, the ROP3 doesn't require a pattern.
if (pdsurfSrc == NULL) { //////////////////////////////////////////////////
// DIB-to-screen blt
iSrcBitmapFormat = psoSrc->iBitmapFormat; if (iSrcBitmapFormat == BMF_1BPP) { pfnXfer = ppdev->pfnXfer1bpp; goto Xfer_It; } else if ((iSrcBitmapFormat == ppdev->iBitmapFormat) && ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL))) { if ((rop3 & 0xf) != 0xc) { pfnXfer = ppdev->pfnXferNative; } else { // Thanks to USWC write-combining, for SRCCOPY
// blts it will be much stupendously faster to copy
// directly to the frame buffer than to use the
// transfer register. Note that this is true for
// almost any video adapter (including yours).
pfnXfer = vXferNativeSrccopy; } goto Xfer_It; }
// Expansions from 4bpp are pretty frequent with a ROP, and
// should really be done for all color depths, not just 4bpp.
//
// Note, though, that USWC means it's faster to punt to GDI
// for all SRCCOPY cases.
else if ((iSrcBitmapFormat == BMF_4BPP) && (ppdev->iBitmapFormat == BMF_8BPP) && (rop4 != 0xcccc)) { pfnXfer = ppdev->pfnXfer4bpp; goto Xfer_It; } } else // pdsurfSrc != NULL
{ if ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)) { //////////////////////////////////////////////////
// Screen-to-screen blt with no translate
if ((pco == NULL) || (pco->iDComplexity == DC_TRIVIAL)) { (ppdev->pfnCopyBlt)(ppdev, 1, prclDst, rop4, pptlSrc, prclDst); goto All_Done; } else if (pco->iDComplexity == DC_RECT) { if (bIntersect(prclDst, &pco->rclBounds, &rcl)) { (ppdev->pfnCopyBlt)(ppdev, 1, &rcl, rop4, pptlSrc, prclDst); } goto All_Done; } else { // Don't forget that we'll have to draw the
// rectangles in the correct direction:
if (pptlSrc->y >= prclDst->top) { if (pptlSrc->x >= prclDst->left) iDir = CD_RIGHTDOWN; else iDir = CD_LEFTDOWN; } else { if (pptlSrc->x >= prclDst->left) iDir = CD_RIGHTUP; else iDir = CD_LEFTUP; }
CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, iDir, 0);
do { bMore = CLIPOBJ_bEnum(pco, sizeof(ce), (ULONG*) &ce);
c = cIntersect(prclDst, ce.arcl, ce.c);
if (c != 0) { (ppdev->pfnCopyBlt)(ppdev, c, ce.arcl, rop4, pptlSrc, prclDst); }
} while (bMore); goto All_Done; } } } } } else if (((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)) && (rop4 == 0xcccc) && (psoDst->iBitmapFormat == ppdev->iBitmapFormat)) { //////////////////////////////////////////////////
// Screen-to-DIB SRCCOPY blt with no translate
//
// The only way to read bits from video memory on the S3 is to
// have the CPU read directly from the frame-buffer. Unfortunately,
// reads from video memory are pathetically slow.
//
// Have you ever benchmarked reads? On a Pentium II with USWC
// enabled, consecutive writes to the frame buffer via PCI on a
// typical video card is typically on the order of 80 to 100 MB/s.
// Dword reads max out at 6 MB/s! Byte reads (or worse, unaligned
// Dword reads) max out at a very small 1.5 MB/s!
//
// The problem is that if we just punt to GDI, GDI doesn't realize
// that the source is video-memory and the destination is system-
// memory. It will proceed to align its copy to the destination,
// which means that it may do misaligned dword reads from video
// memory. So we just dropped our throughput by a factor of 4!
//
// So the net-result is that we special-case reads here simply so
// that we can do aligned dword reads from video memory.
pfnXfer = vReadNativeSrccopy;
// The Xfer_It routine expects the system-memory surface to come
// in as 'psoSrc'.
psoSrc = psoDst;
// It might also be a thought to convert an off-screen DFB to a
// DIB at this point.
goto Xfer_It; } }
else if ((psoMsk == NULL) && (rop4 == 0xaaf0)) { // The only time GDI will ask us to do a true rop4 using the brush
// mask is when the brush is 1bpp, and the background rop is AA
// (meaning it's a NOP):
rop3 = (BYTE) rop4; goto Fill_It; }
// Just fall through to Punt_It...
Punt_It:
bRet = bPuntBlt(psoDst, psoSrc, psoMsk, pco, pxlo, prclDst, pptlSrc, pptlMsk, pbo, pptlBrush, rop4); goto All_Done;
//////////////////////////////////////////////////////////////////////
// Common bitmap transfer
Xfer_It: if ((pco == NULL) || (pco->iDComplexity == DC_TRIVIAL)) { pfnXfer(ppdev, 1, prclDst, rop4, psoSrc, pptlSrc, prclDst, pxlo); goto All_Done; } else if (pco->iDComplexity == DC_RECT) { if (bIntersect(prclDst, &pco->rclBounds, &rcl)) pfnXfer(ppdev, 1, &rcl, rop4, psoSrc, pptlSrc, prclDst, pxlo); goto All_Done; } else { CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0);
do { bMore = CLIPOBJ_bEnum(pco, sizeof(ce), (ULONG*) &ce);
c = cIntersect(prclDst, ce.arcl, ce.c);
if (c != 0) { pfnXfer(ppdev, c, ce.arcl, rop4, psoSrc, pptlSrc, prclDst, pxlo); }
} while (bMore); goto All_Done; }
////////////////////////////////////////////////////////////////////////
// Common DIB blt
EngBitBlt_It:
// Our driver doesn't handle any blt's between two DIBs. Normally
// a driver doesn't have to worry about this, but we do because
// we have DFBs that may get moved from off-screen memory to a DIB,
// where we have GDI do all the drawing. GDI does DIB drawing at
// a reasonable speed (unless one of the surfaces is a device-
// managed surface...)
//
// If either the source or destination surface in an EngBitBlt
// call-back is a device-managed surface (meaning it's not a DIB
// that GDI can draw with), GDI will automatically allocate memory
// and call the driver's DrvCopyBits routine to create a DIB copy
// that it can use. So this means that this could handle all 'punts',
// and we could conceivably get rid of bPuntBlt. But this would have
// a bad performance impact because of the extra memory allocations
// and bitmap copies -- you really don't want to do this unless you
// have to (or your surface was created such that GDI can draw
// directly onto it) -- I've been burned by this because it's not
// obvious that the performance impact is so bad.
//
// That being said, we only call EngBitBlt when all the surfaces
// are DIBs:
bRet = EngBitBlt(psoDst, psoSrc, psoMsk, pco, pxlo, prclDst, pptlSrc, pptlMsk, pbo, pptlBrush, rop4);
All_Done: return(bRet);}
/******************************Public*Routine******************************\
* BOOL DrvCopyBits** Do fast bitmap copies.** DrvCopyBits is just a special-case of DrvBitBlt. Since DrvBitBlt is* plenty fast, we let DrvBitBlt handle all the cases.** (I used to have a bunch of extra code here to optimize the SRCCOPY* cases, but the performance win was immeasurable. There's no point in* the adding code complexity or the working set hit.)*\**************************************************************************/
BOOL DrvCopyBits(SURFOBJ* psoDst,SURFOBJ* psoSrc,CLIPOBJ* pco,XLATEOBJ* pxlo,RECTL* prclDst,POINTL* pptlSrc){ return(DrvBitBlt(psoDst, psoSrc, NULL, pco, pxlo, prclDst, pptlSrc, NULL, NULL, NULL, 0x0000CCCC));}
/******************************Public*Routine******************************\
* BOOL DrvTransparentBlt** Do blt using a source color-key.*\**************************************************************************/
BOOL DrvTransparentBlt(SURFOBJ* psoDst,SURFOBJ* psoSrc,CLIPOBJ* pco,XLATEOBJ* pxlo,RECTL* prclDst,RECTL* prclSrc,ULONG iTransparentColor,ULONG ulReserved){ DSURF* pdsurfSrc; DSURF* pdsurfDst; PDEV* ppdev; ULONG c; BOOL bMore; POINTL ptlSrc; RECTL rcl; CLIPENUM ce;
pdsurfSrc = (DSURF*) psoSrc->dhsurf; pdsurfDst = (DSURF*) psoDst->dhsurf;
// We only handle the case when both surfaces are in video memory
// and when no stretching is involved. (GDI using USWC write-
// combining is perfectly fast for the case where the source is
// a DIB and the destination is video memory.)
if (((pdsurfSrc == NULL) || (pdsurfSrc->dt & DT_DIB)) || ((pdsurfDst == NULL) || (pdsurfDst->dt & DT_DIB)) || ((pxlo != NULL) && !(pxlo->flXlate & XO_TRIVIAL)) || ((prclSrc->right - prclSrc->left) != (prclDst->right - prclDst->left)) || ((prclSrc->bottom - prclSrc->top) != (prclDst->bottom - prclDst->top))) { return(EngTransparentBlt(psoDst, psoSrc, pco, pxlo, prclDst, prclSrc, iTransparentColor, ulReserved)); }
ppdev = (PDEV*) psoDst->dhpdev;
ppdev->xOffset = pdsurfDst->x; ppdev->yOffset = pdsurfDst->y;
ptlSrc.x = prclSrc->left - (pdsurfDst->x - pdsurfSrc->x); ptlSrc.y = prclSrc->top - (pdsurfDst->y - pdsurfSrc->y);
if ((pco == NULL) || (pco->iDComplexity == DC_TRIVIAL)) { ppdev->pfnCopyTransparent(ppdev, 1, prclDst, &ptlSrc, prclDst, iTransparentColor); } else if (pco->iDComplexity == DC_RECT) { if (bIntersect(prclDst, &pco->rclBounds, &rcl)) ppdev->pfnCopyTransparent(ppdev, 1, &rcl, &ptlSrc, prclDst, iTransparentColor); } else { CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, 0);
do { bMore = CLIPOBJ_bEnum(pco, sizeof(ce), (ULONG*) &ce);
c = cIntersect(prclDst, ce.arcl, ce.c);
if (c != 0) { ppdev->pfnCopyTransparent(ppdev, c, ce.arcl, &ptlSrc, prclDst, iTransparentColor); }
} while (bMore); }
return(TRUE);}
|
