static Bool
xa_update_composite(struct xa_composite *comp, PixmapPtr pSrc,
PixmapPtr pMask, PixmapPtr pDst)
{
comp->dst->srf = msm_get_pixmap_surf(pDst);
EXA_FAIL_IF(!comp->dst->srf);
if (pSrc) {
comp->src->srf = msm_get_pixmap_surf(pSrc);
EXA_FAIL_IF(!comp->src->srf);
} else {
comp->src->srf = NULL;
}
if (comp->mask) {
if (pMask) {
comp->mask->srf = msm_get_pixmap_surf(pMask);
EXA_FAIL_IF(!comp->mask->srf);
} else {
comp->mask->srf = NULL;
}
}
return TRUE;
}
/**
* PrepareCopy() sets up the driver for doing a copy within video
* memory.
*
* @param pSrcPixmap source pixmap
* @param pDstPixmap destination pixmap
* @param dx X copy direction
* @param dy Y copy direction
* @param alu raster operation
* @param planemask write mask for the fill
*
* This call should set up the driver for doing a series of copies from the
* the pSrcPixmap to the pDstPixmap. The dx flag will be positive if the
* hardware should do the copy from the left to the right, and dy will be
* positive if the copy should be done from the top to the bottom. This
* is to deal with self-overlapping copies when pSrcPixmap == pDstPixmap.
* If your hardware can only support blits that are (left to right, top to
* bottom) or (right to left, bottom to top), then you should set
* #EXA_TWO_BITBLT_DIRECTIONS, and EXA will break down Copy operations to
* ones that meet those requirements. The alu raster op is one of the GX*
* graphics functions listed in X.h, and typically maps to a similar
* single-byte "ROP" setting in all hardware. The planemask controls which
* bits of the destination should be affected, and will only represent the
* bits up to the depth of pPixmap.
*
* Note that many drivers will need to store some of the data in the driver
* private record, for sending to the hardware with each drawing command.
*
* The PrepareCopy() call is required of all drivers, but it may fail for any
* reason. Failure results in a fallback to software rendering.
*/
static Bool
XAPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int dx, int dy,
int alu, Pixel planemask)
{
MSM_LOCALS(pDstPixmap);
struct xa_surface *src = msm_get_pixmap_surf(pSrcPixmap);
struct xa_surface *dst = msm_get_pixmap_surf(pDstPixmap);
if (!(src && dst))
return FALSE;
return xa_copy_prepare(exa->ctx, dst, src) == XA_ERR_NONE;
}
static Bool
XAPixmapIsOffscreen(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
struct xa_surface *surf = msm_get_pixmap_surf(pPixmap);
if ((pScreen->GetScreenPixmap(pScreen) == pPixmap)) {
return TRUE;
}
if (!surf) {
/* because we are pretending to handle unaccel (1bpp, etc)
* pixmaps too..
* this is pretty lame, revisit using EXA_MIXED_PIXMAPS
*/
struct msm_pixmap_priv *priv =
exaGetPixmapDriverPrivate(pPixmap);
if (priv && priv->ptr) {
return TRUE;
}
}
if (surf)
return TRUE;
return FALSE;
}
/**
* PrepareSolid() sets up the driver for doing a solid fill.
* @param pPixmap Destination pixmap
* @param alu raster operation
* @param planemask write mask for the fill
* @param fg "foreground" color for the fill
*
* This call should set up the driver for doing a series of solid fills
* through the Solid() call. The alu raster op is one of the GX*
* graphics functions listed in X.h, and typically maps to a similar
* single-byte "ROP" setting in all hardware. The planemask controls
* which bits of the destination should be affected, and will only represent
* the bits up to the depth of pPixmap. The fg is the pixel value of the
* foreground color referred to in ROP descriptions.
*
* Note that many drivers will need to store some of the data in the driver
* private record, for sending to the hardware with each drawing command.
*
* The PrepareSolid() call is required of all drivers, but it may fail for any
* reason. Failure results in a fallback to software rendering.
*/
static Bool
XAPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planemask, Pixel fg)
{
MSM_LOCALS(pPixmap);
struct xa_surface *dst = msm_get_pixmap_surf(pPixmap);
if (!dst)
return FALSE;
return xa_solid_prepare(exa->ctx, dst, fg) == XA_ERR_NONE;
}