1234 lines
42 KiB
C
1234 lines
42 KiB
C
|
/******************************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* ppdev;
|
||
|
|
|
||
|
|
if (psoDst->dhsurf != NULL)
|
||
|
|
ppdev = (PDEV*) psoDst->dhpdev;
|
||
|
|
else
|
||
|
|
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 != ppdev->iBitmapFormat)) ||
|
||
|
|
((psoDst->dhsurf == NULL) &&
|
||
|
|
(psoDst->iBitmapFormat != 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);
|
||
|
|
}
|