static void
imxCrtcShadowDestroy(xf86CrtcPtr crtc, PixmapPtr pPixmap, void* data)
{
/**
* Destroy shadow pixmap
*/
/* Access the associated screen info. */
ScrnInfoPtr pScrn = crtc->scrn;
/* Access driver private screen data */
ImxPtr imxPtr = IMXPTR(pScrn);
/* Access driver private screen display data */
ImxDisplayPtr fPtr = IMXDISPLAYPTR(imxPtr);
/* Mark the shadow memory as being available */
if (imxPtr->fbMemoryStart2 == data) {
fPtr->fbShadowAllocated = FALSE;
}
/* Release the pixmap */
if (NULL != pPixmap) {
FreeScratchPixmapHeader(pPixmap);
}
}
static void
drmmode_crtc_shadow_destroy(xf86CrtcPtr crtc, PixmapPtr rotate_pixmap, void *data)
{
ScrnInfoPtr scrn = crtc->scrn;
intel_screen_private *intel = intel_get_screen_private(scrn);
drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private;
drmmode_ptr drmmode = drmmode_crtc->drmmode;
if (rotate_pixmap) {
intel_set_pixmap_bo(rotate_pixmap, NULL);
FreeScratchPixmapHeader(rotate_pixmap);
}
if (data) {
/* Be sure to sync acceleration before the memory gets
* unbound. */
drmModeRmFB(drmmode->fd, drmmode_crtc->rotate_fb_id);
drmmode_crtc->rotate_fb_id = 0;
dri_bo_unreference(drmmode_crtc->rotate_bo);
drmmode_crtc->rotate_bo = NULL;
}
intel->shadow_present = intel->use_shadow;
}
/* Do ordinary copy */
static void MaliDRI2CopyRegion_copy(DrawablePtr pDraw,
RegionPtr pRegion,
DRI2BufferPtr pDstBuffer,
DRI2BufferPtr pSrcBuffer)
{
GCPtr pGC;
RegionPtr copyRegion;
ScreenPtr pScreen = pDraw->pScreen;
MaliDRI2BufferPrivatePtr privates;
PixmapPtr pScratchPixmap;
privates = (MaliDRI2BufferPrivatePtr)pSrcBuffer->driverPrivate;
// DebugMsg("Enter MaliDRI2CopyRegion buf_name:%d\n",pSrcBuffer->name);
/*
#ifdef HAVE_LIBUMP_CACHE_CONTROL
if (privates->handle != UMP_INVALID_MEMORY_HANDLE) {
// That's a normal UMP allocation, not a wrapped framebuffer
ump_cache_operations_control(UMP_CACHE_OP_START);
ump_switch_hw_usage_secure_id(pSrcBuffer->name, UMP_USED_BY_CPU);
ump_cache_operations_control(UMP_CACHE_OP_FINISH);
}
#endif
*/
pGC = GetScratchGC(pDraw->depth, pScreen);
pScratchPixmap = GetScratchPixmapHeader(pScreen,
privates->width, privates->height,
privates->depth, pSrcBuffer->cpp * 8,
pSrcBuffer->pitch,
privates->addr + pSrcBuffer->flags);
copyRegion = REGION_CREATE(pScreen, NULL, 0);
REGION_COPY(pScreen, copyRegion, pRegion);
(*pGC->funcs->ChangeClip)(pGC, CT_REGION, copyRegion, 0);
ValidateGC(pDraw, pGC);
(*pGC->ops->CopyArea)((DrawablePtr)pScratchPixmap, pDraw, pGC, 0, 0,
pDraw->width, pDraw->height, 0, 0);
FreeScratchPixmapHeader(pScratchPixmap);
FreeScratchGC(pGC);
/*
#ifdef HAVE_LIBUMP_CACHE_CONTROL
if (privates->handle != UMP_INVALID_MEMORY_HANDLE) {
// That's a normal UMP allocation, not a wrapped framebuffer
ump_cache_operations_control(UMP_CACHE_OP_START);
ump_switch_hw_usage_secure_id(pSrcBuffer->name, UMP_USED_BY_MALI);
ump_cache_operations_control(UMP_CACHE_OP_FINISH);
}
#endif
*/
}
/*
* If the given request doesn't exactly match PutImage's constraints,
* wrap the image in a scratch pixmap header and let CopyArea sort it out.
*/
static void
doShmPutImage(DrawablePtr dst, GCPtr pGC,
int depth, unsigned int format,
int w, int h, int sx, int sy, int sw, int sh, int dx, int dy,
char *data)
{
PixmapPtr pPixmap;
if (format == ZPixmap || (format == XYPixmap && depth == 1)) {
pPixmap = GetScratchPixmapHeader(dst->pScreen, w, h, depth,
BitsPerPixel(depth),
PixmapBytePad(w, depth), data);
if (!pPixmap)
return;
pGC->ops->CopyArea((DrawablePtr) pPixmap, dst, pGC, sx, sy, sw, sh, dx,
dy);
FreeScratchPixmapHeader(pPixmap);
}
else {
GCPtr putGC = GetScratchGC(depth, dst->pScreen);
if (!putGC)
return;
pPixmap = (*dst->pScreen->CreatePixmap) (dst->pScreen, sw, sh, depth,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pPixmap) {
FreeScratchGC(putGC);
return;
}
ValidateGC(&pPixmap->drawable, putGC);
(*putGC->ops->PutImage) (&pPixmap->drawable, putGC, depth, -sx, -sy, w,
h, 0,
(format == XYPixmap) ? XYPixmap : ZPixmap,
data);
FreeScratchGC(putGC);
if (format == XYBitmap)
(void) (*pGC->ops->CopyPlane) (&pPixmap->drawable, dst, pGC, 0, 0,
sw, sh, dx, dy, 1L);
else
(void) (*pGC->ops->CopyArea) (&pPixmap->drawable, dst, pGC, 0, 0,
sw, sh, dx, dy);
(*pPixmap->drawable.pScreen->DestroyPixmap) (pPixmap);
}
}
static void
SMI_CrtcShadowDestroy (xf86CrtcPtr crtc, PixmapPtr pPixmap, void *data)
{
ScrnInfoPtr pScrn = crtc->scrn;
SMIPtr pSmi = SMIPTR(pScrn);
SMICrtcPrivatePtr crtcPriv = SMICRTC(crtc);
ENTER();
if (pSmi->useEXA && pPixmap)
FreeScratchPixmapHeader(pPixmap);
if (crtcPriv->shadowArea) {
SMI_FreeMemory(pScrn, crtcPriv->shadowArea);
crtcPriv->shadowArea = NULL;
}
LEAVE();
}
static void
ARMSOCDRI2CopyRegion(DrawablePtr pDraw, RegionPtr pRegion,
DRI2BufferPtr pDstBuffer, DRI2BufferPtr pSrcBuffer)
{
ScreenPtr pScreen = pDraw->pScreen;
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
RegionPtr pCopyClip;
GCPtr pGC;
PixmapPtr pScratchPixmap;
struct ARMSOCDRI2BufferRec *src = ARMSOCBUF(pSrcBuffer);
DEBUG_MSG("pDraw=%p, pDstBuffer=%p pSrcBuffer=%p",
pDraw, pDstBuffer, pSrcBuffer);
pGC = GetScratchGC(pDraw->depth, pScreen);
if (!pGC)
return;
pCopyClip = REGION_CREATE(pScreen, NULL, 0);
RegionCopy(pCopyClip, pRegion);
(*pGC->funcs->ChangeClip) (pGC, CT_REGION, pCopyClip, 0);
ValidateGC(pDraw, pGC);
/* If the dst is the framebuffer, and we had a way to
* schedule a deferred blit synchronized w/ vsync, that
* would be a nice thing to do utilize here to avoid
* tearing.. when we have sync object support for GEM
* buffers, I think we could do something more clever
* here.
*/
pScratchPixmap = GetScratchPixmapHeader(pScreen,
armsoc_bo_width(src->bo), armsoc_bo_height(src->bo),
armsoc_bo_depth(src->bo), armsoc_bo_bpp(src->bo),
armsoc_bo_pitch(src->bo), armsoc_bo_map(src->bo));
pGC->ops->CopyArea((DrawablePtr) pScratchPixmap, pDraw, pGC,
0, 0, pDraw->width, pDraw->height, 0, 0);
FreeScratchPixmapHeader(pScratchPixmap);
FreeScratchGC(pGC);
}
static void MaliDRI2CopyRegion(DrawablePtr pDraw,
RegionPtr pRegion,
DRI2BufferPtr pDstBuffer,
DRI2BufferPtr pSrcBuffer)
{
GCPtr pGC;
RegionPtr copyRegion;
ScreenPtr pScreen = pDraw->pScreen;
MaliDRI2BufferPrivatePtr privates;
PixmapPtr pScratchPixmap;
privates = (MaliDRI2BufferPrivatePtr)pSrcBuffer->driverPrivate;
if (privates->depth != pDraw->depth) {
ErrorF("MaliDRI2CopyRegion: privates->depth != pDraw->depth (%d vs. %d)\n",
privates->depth, pDraw->depth);
return;
}
//ErrorF("MaliDRI2CopyRegion dstbuf=%p srcbuf=%p, depth=%d\n", pDstBuffer, pSrcBuffer, privates->depth);
ump_cache_operations_control(UMP_CACHE_OP_START);
ump_switch_hw_usage_secure_id(pSrcBuffer->name, UMP_USED_BY_CPU);
ump_cache_operations_control(UMP_CACHE_OP_FINISH);
pGC = GetScratchGC(pDraw->depth, pScreen);
pScratchPixmap = GetScratchPixmapHeader(pScreen, privates->width, privates->height,
privates->depth, pSrcBuffer->cpp * 8,
pSrcBuffer->pitch, privates->addr);
copyRegion = REGION_CREATE(pScreen, NULL, 0);
REGION_COPY(pScreen, copyRegion, pRegion);
(*pGC->funcs->ChangeClip)(pGC, CT_REGION, copyRegion, 0);
ValidateGC(pDraw, pGC);
(*pGC->ops->CopyArea)(pScratchPixmap, pDraw, pGC, 0, 0,
pDraw->width, pDraw->height, 0, 0);
FreeScratchPixmapHeader(pScratchPixmap);
FreeScratchGC(pGC);
ump_cache_operations_control(UMP_CACHE_OP_START);
ump_switch_hw_usage_secure_id(pSrcBuffer->name, UMP_USED_BY_MALI);
ump_cache_operations_control(UMP_CACHE_OP_FINISH);
}
static Bool
xf86_dga_get_drawable_and_gc (ScrnInfoPtr scrn, DrawablePtr *ppDrawable, GCPtr *ppGC)
{
ScreenPtr pScreen = scrn->pScreen;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
PixmapPtr pPixmap;
GCPtr pGC;
pPixmap = GetScratchPixmapHeader (pScreen, xf86_config->dga_width, xf86_config->dga_height,
scrn->depth, scrn->bitsPerPixel, xf86_config->dga_stride,
(char *) scrn->memPhysBase + scrn->fbOffset);
if (!pPixmap)
return FALSE;
pGC = GetScratchGC (scrn->depth, pScreen);
if (!pGC)
{
FreeScratchPixmapHeader (pPixmap);
return FALSE;
}
*ppDrawable = &pPixmap->drawable;
*ppGC = pGC;
return TRUE;
}
/* XaceCensorImage
*
* Called after pScreen->GetImage to prevent pieces or trusted windows from
* being returned in image data from an untrusted window.
*
* Arguments:
* client is the client doing the GetImage.
* pVisibleRegion is the visible region of the window.
* widthBytesLine is the width in bytes of one horizontal line in pBuf.
* pDraw is the source window.
* x, y, w, h is the rectangle of image data from pDraw in pBuf.
* format is the format of the image data in pBuf: ZPixmap or XYPixmap.
* pBuf is the image data.
*
* Returns: nothing.
*
* Side Effects:
* Any part of the rectangle (x, y, w, h) that is outside the visible
* region of the window will be destroyed (overwritten) in pBuf.
*/
void
XaceCensorImage(
ClientPtr client,
RegionPtr pVisibleRegion,
long widthBytesLine,
DrawablePtr pDraw,
int x, int y, int w, int h,
unsigned int format,
char *pBuf)
{
ScreenPtr pScreen;
RegionRec imageRegion; /* region representing x,y,w,h */
RegionRec censorRegion; /* region to obliterate */
BoxRec imageBox;
int nRects;
pScreen = pDraw->pScreen;
imageBox.x1 = x;
imageBox.y1 = y;
imageBox.x2 = x + w;
imageBox.y2 = y + h;
REGION_INIT(pScreen, &imageRegion, &imageBox, 1);
REGION_NULL(pScreen, &censorRegion);
/* censorRegion = imageRegion - visibleRegion */
REGION_SUBTRACT(pScreen, &censorRegion, &imageRegion, pVisibleRegion);
nRects = REGION_NUM_RECTS(&censorRegion);
if (nRects > 0)
{ /* we have something to censor */
GCPtr pScratchGC = NULL;
PixmapPtr pPix = NULL;
xRectangle *pRects = NULL;
Bool failed = FALSE;
int depth = 1;
int bitsPerPixel = 1;
int i;
BoxPtr pBox;
/* convert region to list-of-rectangles for PolyFillRect */
pRects = xalloc(nRects * sizeof(xRectangle));
if (!pRects)
{
failed = TRUE;
goto failSafe;
}
for (pBox = REGION_RECTS(&censorRegion), i = 0;
i < nRects;
i++, pBox++)
{
pRects[i].x = pBox->x1;
pRects[i].y = pBox->y1 - imageBox.y1;
pRects[i].width = pBox->x2 - pBox->x1;
pRects[i].height = pBox->y2 - pBox->y1;
}
/* use pBuf as a fake pixmap */
if (format == ZPixmap)
{
depth = pDraw->depth;
bitsPerPixel = pDraw->bitsPerPixel;
}
pPix = GetScratchPixmapHeader(pDraw->pScreen, w, h,
depth, bitsPerPixel,
widthBytesLine, (pointer)pBuf);
if (!pPix)
{
failed = TRUE;
goto failSafe;
}
pScratchGC = GetScratchGC(depth, pPix->drawable.pScreen);
if (!pScratchGC)
{
failed = TRUE;
goto failSafe;
}
ValidateGC(&pPix->drawable, pScratchGC);
(* pScratchGC->ops->PolyFillRect)(&pPix->drawable,
pScratchGC, nRects, pRects);
failSafe:
if (failed)
{
/* Censoring was not completed above. To be safe, wipe out
* all the image data so that nothing trusted gets out.
*/
bzero(pBuf, (int)(widthBytesLine * h));
}
if (pRects) xfree(pRects);
if (pScratchGC) FreeScratchGC(pScratchGC);
if (pPix) FreeScratchPixmapHeader(pPix);
}
REGION_UNINIT(pScreen, &imageRegion);
REGION_UNINIT(pScreen, &censorRegion);
} /* XaceCensorImage */
static void
xf86_dga_release_drawable_and_gc (ScrnInfoPtr scrn, DrawablePtr pDrawable, GCPtr pGC)
{
FreeScratchGC (pGC);
FreeScratchPixmapHeader ((PixmapPtr) pDrawable);
}
void
FreeScratchPixmapsForScreen(int scrnum)
{
FreeScratchPixmapHeader(screenInfo.screens[scrnum]->pScratchPixmap);
}
/* Entry point for hook functions. Called by Xserver.
*/
int XaceHook(int hook, ...)
{
pointer calldata; /* data passed to callback */
int *prv = NULL; /* points to return value from callback */
va_list ap; /* argument list */
va_start(ap, hook);
/* Marshal arguments for passing to callback.
* Each callback has its own case, which sets up a structure to hold
* the arguments and integer return parameter, or in some cases just
* sets calldata directly to a single argument (with no return result)
*/
switch (hook)
{
case XACE_RESOURCE_ACCESS: {
XaceResourceAccessRec rec = {
va_arg(ap, ClientPtr),
va_arg(ap, XID),
va_arg(ap, RESTYPE),
va_arg(ap, pointer),
va_arg(ap, RESTYPE),
va_arg(ap, pointer),
va_arg(ap, Mask),
Success /* default allow */
};
calldata = &rec;
prv = &rec.status;
break;
}
case XACE_DEVICE_ACCESS: {
XaceDeviceAccessRec rec = {
va_arg(ap, ClientPtr),
va_arg(ap, DeviceIntPtr),
va_arg(ap, Mask),
Success /* default allow */
};
calldata = &rec;
prv = &rec.status;
break;
}
case XACE_SEND_ACCESS: {
XaceSendAccessRec rec = {
va_arg(ap, ClientPtr),
va_arg(ap, DeviceIntPtr),
va_arg(ap, WindowPtr),
va_arg(ap, xEventPtr),
va_arg(ap, int),
Success /* default allow */
};
calldata = &rec;
prv = &rec.status;
break;
}
case XACE_RECEIVE_ACCESS: {
XaceReceiveAccessRec rec = {
va_arg(ap, ClientPtr),
va_arg(ap, WindowPtr),
va_arg(ap, xEventPtr),
va_arg(ap, int),
Success /* default allow */
};
calldata = &rec;
prv = &rec.status;
break;
}
case XACE_CLIENT_ACCESS: {
XaceClientAccessRec rec = {
va_arg(ap, ClientPtr),
va_arg(ap, ClientPtr),
va_arg(ap, Mask),
Success /* default allow */
};
calldata = &rec;
prv = &rec.status;
break;
}
case XACE_EXT_ACCESS: {
XaceExtAccessRec rec = {
va_arg(ap, ClientPtr),
va_arg(ap, ExtensionEntry*),
DixGetAttrAccess,
Success /* default allow */
};
calldata = &rec;
prv = &rec.status;
break;
}
case XACE_SERVER_ACCESS: {
XaceServerAccessRec rec = {
va_arg(ap, ClientPtr),
va_arg(ap, Mask),
Success /* default allow */
};
calldata = &rec;
prv = &rec.status;
break;
}
case XACE_SCREEN_ACCESS:
case XACE_SCREENSAVER_ACCESS: {
XaceScreenAccessRec rec = {
va_arg(ap, ClientPtr),
va_arg(ap, ScreenPtr),
va_arg(ap, Mask),
Success /* default allow */
};
calldata = &rec;
prv = &rec.status;
break;
}
case XACE_AUTH_AVAIL: {
XaceAuthAvailRec rec = {
va_arg(ap, ClientPtr),
va_arg(ap, XID)
};
calldata = &rec;
break;
}
case XACE_KEY_AVAIL: {
XaceKeyAvailRec rec = {
va_arg(ap, xEventPtr),
va_arg(ap, DeviceIntPtr),
va_arg(ap, int)
};
calldata = &rec;
break;
}
default: {
va_end(ap);
return 0; /* unimplemented hook number */
}
}
va_end(ap);
/* call callbacks and return result, if any. */
CallCallbacks(&XaceHooks[hook], calldata);
return prv ? *prv : Success;
}
/* XaceCensorImage
*
* Called after pScreen->GetImage to prevent pieces or trusted windows from
* being returned in image data from an untrusted window.
*
* Arguments:
* client is the client doing the GetImage.
* pVisibleRegion is the visible region of the window.
* widthBytesLine is the width in bytes of one horizontal line in pBuf.
* pDraw is the source window.
* x, y, w, h is the rectangle of image data from pDraw in pBuf.
* format is the format of the image data in pBuf: ZPixmap or XYPixmap.
* pBuf is the image data.
*
* Returns: nothing.
*
* Side Effects:
* Any part of the rectangle (x, y, w, h) that is outside the visible
* region of the window will be destroyed (overwritten) in pBuf.
*/
void
XaceCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
format, pBuf)
ClientPtr client;
RegionPtr pVisibleRegion;
long widthBytesLine;
DrawablePtr pDraw;
int x, y, w, h;
unsigned int format;
char * pBuf;
{
ScreenPtr pScreen;
RegionRec imageRegion; /* region representing x,y,w,h */
RegionRec censorRegion; /* region to obliterate */
BoxRec imageBox;
int nRects;
pScreen = pDraw->pScreen;
imageBox.x1 = x;
imageBox.y1 = y;
imageBox.x2 = x + w;
imageBox.y2 = y + h;
REGION_INIT(pScreen, &imageRegion, &imageBox, 1);
REGION_NULL(pScreen, &censorRegion);
/* censorRegion = imageRegion - visibleRegion */
REGION_SUBTRACT(pScreen, &censorRegion, &imageRegion, pVisibleRegion);
nRects = REGION_NUM_RECTS(&censorRegion);
if (nRects > 0)
{ /* we have something to censor */
GCPtr pScratchGC = NULL;
PixmapPtr pPix = NULL;
xRectangle *pRects = NULL;
Bool failed = FALSE;
int depth = 1;
int bitsPerPixel = 1;
int i;
BoxPtr pBox;
/* convert region to list-of-rectangles for PolyFillRect */
pRects = (xRectangle *)xalloc(nRects * sizeof(xRectangle));
if (!pRects)
{
failed = TRUE;
goto failSafe;
}
for (pBox = REGION_RECTS(&censorRegion), i = 0;
i < nRects;
i++, pBox++)
{
pRects[i].x = pBox->x1;
pRects[i].y = pBox->y1 - imageBox.y1;
pRects[i].width = pBox->x2 - pBox->x1;
pRects[i].height = pBox->y2 - pBox->y1;
}
/* use pBuf as a fake pixmap */
if (format == ZPixmap)
{
depth = pDraw->depth;
bitsPerPixel = pDraw->bitsPerPixel;
}
pPix = GetScratchPixmapHeader(pDraw->pScreen, w, h,
depth, bitsPerPixel,
widthBytesLine, (pointer)pBuf);
if (!pPix)
{
failed = TRUE;
goto failSafe;
}
pScratchGC = GetScratchGC(depth, pPix->drawable.pScreen);
if (!pScratchGC)
{
failed = TRUE;
goto failSafe;
}
ValidateGC(&pPix->drawable, pScratchGC);
(* pScratchGC->ops->PolyFillRect)(&pPix->drawable,
pScratchGC, nRects, pRects);
failSafe:
if (failed)
{
/* Censoring was not completed above. To be safe, wipe out
* all the image data so that nothing trusted gets out.
*/
bzero(pBuf, (int)(widthBytesLine * h));
}
if (pRects) xfree(pRects);
if (pScratchGC) FreeScratchGC(pScratchGC);
if (pPix) FreeScratchPixmapHeader(pPix);
}
REGION_UNINIT(pScreen, &imageRegion);
REGION_UNINIT(pScreen, &censorRegion);
} /* XaceCensorImage */
static void
uxa_check_glyphs(CARD8 op,
PicturePtr src,
PicturePtr dst,
PictFormatPtr maskFormat,
INT16 xSrc,
INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
{
pixman_image_t *image;
PixmapPtr scratch;
PicturePtr mask, mask_src = NULL, mask_dst = NULL, white = NULL;
int width = 0, height = 0;
int x, y, n;
int xDst = list->xOff, yDst = list->yOff;
BoxRec extents = { 0, 0, 0, 0 };
CARD8 mask_op = 0;
if (maskFormat) {
pixman_format_code_t format;
CARD32 component_alpha;
xRenderColor color;
int error;
uxa_glyph_extents(nlist, list, glyphs, &extents);
if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
return;
width = extents.x2 - extents.x1;
height = extents.y2 - extents.y1;
format = maskFormat->format |
(BitsPerPixel(maskFormat->depth) << 24);
image =
pixman_image_create_bits(format, width, height, NULL, 0);
if (!image)
return;
scratch = GetScratchPixmapHeader(dst->pDrawable->pScreen, width, height,
PIXMAN_FORMAT_DEPTH(format),
PIXMAN_FORMAT_BPP(format),
pixman_image_get_stride(image),
pixman_image_get_data(image));
if (!scratch) {
pixman_image_unref(image);
return;
}
component_alpha = NeedsComponent(maskFormat->format);
mask = CreatePicture(0, &scratch->drawable,
maskFormat, CPComponentAlpha,
&component_alpha, serverClient, &error);
if (!mask) {
FreeScratchPixmapHeader(scratch);
pixman_image_unref(image);
return;
}
ValidatePicture(mask);
x = -extents.x1;
y = -extents.y1;
color.red = color.green = color.blue = color.alpha = 0xffff;
white = CreateSolidPicture(0, &color, &error);
mask_op = op;
op = PictOpAdd;
mask_src = src;
src = white;
mask_dst = dst;
dst = mask;
} else {
mask = dst;
x = 0;
y = 0;
}
while (nlist--) {
x += list->xOff;
y += list->yOff;
n = list->len;
while (n--) {
GlyphPtr glyph = *glyphs++;
PicturePtr g = GetGlyphPicture(glyph, dst->pDrawable->pScreen);
if (g) {
CompositePicture(op, src, g, dst,
xSrc + (x - glyph->info.x) - xDst,
ySrc + (y - glyph->info.y) - yDst,
0, 0,
x - glyph->info.x,
y - glyph->info.y,
glyph->info.width,
glyph->info.height);
}
x += glyph->info.xOff;
y += glyph->info.yOff;
}
list++;
}
if (white)
FreePicture(white, 0);
if (maskFormat) {
x = extents.x1;
y = extents.y1;
CompositePicture(mask_op, mask_src, mask, mask_dst,
xSrc + x - xDst,
ySrc + y - yDst,
0, 0,
x, y,
width, height);
FreePicture(mask, 0);
FreeScratchPixmapHeader(scratch);
pixman_image_unref(image);
}
}
void
xglShmPutImage (DrawablePtr pDrawable,
GCPtr pGC,
int depth,
unsigned int format,
int w,
int h,
int sx,
int sy,
int sw,
int sh,
int dx,
int dy,
char *data)
{
ScreenPtr pScreen = pDrawable->pScreen;
PixmapPtr pPixmapHeader = NULL;
PixmapPtr pPixmap;
int saveTarget;
XGL_DRAWABLE_PIXMAP_PRIV (pDrawable);
if ((format == ZPixmap) || (depth == 1))
{
pPixmap = pPixmapHeader =
GetScratchPixmapHeader (pScreen, w, h, depth,
BitsPerPixel (depth),
PixmapBytePad (w, depth),
(pointer) data);
/* disable any possible acceleration of this pixmap */
if (pPixmap)
xglSetPixmapVisual (pPixmap, 0);
}
else
{
pPixmap = (*pScreen->CreatePixmap) (pScreen, sw, sh, depth);
if (pPixmap)
{
GCPtr pScratchGC;
if (!xglAllocatePixmapBits (pPixmap,
XGL_PIXMAP_USAGE_HINT_DEFAULT))
{
(*pScreen->DestroyPixmap) (pPixmap);
return;
}
xglSetPixmapVisual (pPixmap, 0);
pScratchGC = GetScratchGC (depth, pScreen);
if (!pScratchGC)
{
(*pScreen->DestroyPixmap) (pPixmap);
return;
}
ValidateGC ((DrawablePtr) pPixmap, pScratchGC);
(*pGC->ops->PutImage) ((DrawablePtr) pPixmap, pScratchGC, depth,
-sx, -sy, w, h, 0,
(format == XYPixmap) ? XYPixmap : ZPixmap,
data);
FreeScratchGC (pScratchGC);
sx = sy = 0;
}
}
if (!pPixmap)
return;
/* CopyArea should always be done in software */
saveTarget = pPixmapPriv->target;
pPixmapPriv->target = xglPixmapTargetNo;
if (format == XYBitmap)
(*pGC->ops->CopyPlane) ((DrawablePtr) pPixmap, pDrawable, pGC,
sx, sy, sw, sh, dx, dy, 1L);
else
(*pGC->ops->CopyArea) ((DrawablePtr) pPixmap, pDrawable, pGC,
sx, sy, sw, sh, dx, dy);
pPixmapPriv->target = saveTarget;
if (pPixmapHeader)
FreeScratchPixmapHeader (pPixmapHeader);
else
(*pScreen->DestroyPixmap) (pPixmap);
}
void
miGlyphs (CARD8 op,
PicturePtr pSrc,
PicturePtr pDst,
PictFormatPtr maskFormat,
INT16 xSrc,
INT16 ySrc,
int nlist,
GlyphListPtr list,
GlyphPtr *glyphs)
{
PixmapPtr pPixmap = 0;
PicturePtr pPicture;
PixmapPtr pMaskPixmap = 0;
PicturePtr pMask;
ScreenPtr pScreen = pDst->pDrawable->pScreen;
int width = 0, height = 0;
int x, y;
int xDst = list->xOff, yDst = list->yOff;
int n;
GlyphPtr glyph;
int error;
BoxRec extents;
CARD32 component_alpha;
if (maskFormat)
{
GCPtr pGC;
xRectangle rect;
miGlyphExtents (nlist, list, glyphs, &extents);
if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
return;
width = extents.x2 - extents.x1;
height = extents.y2 - extents.y1;
pMaskPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, maskFormat->depth);
if (!pMaskPixmap)
return;
component_alpha = NeedsComponent(maskFormat->format);
pMask = CreatePicture (0, &pMaskPixmap->drawable,
maskFormat, CPComponentAlpha, &component_alpha,
serverClient, &error);
if (!pMask)
{
(*pScreen->DestroyPixmap) (pMaskPixmap);
return;
}
pGC = GetScratchGC (pMaskPixmap->drawable.depth, pScreen);
ValidateGC (&pMaskPixmap->drawable, pGC);
rect.x = 0;
rect.y = 0;
rect.width = width;
rect.height = height;
(*pGC->ops->PolyFillRect) (&pMaskPixmap->drawable, pGC, 1, &rect);
FreeScratchGC (pGC);
x = -extents.x1;
y = -extents.y1;
}
else
{
pMask = pDst;
x = 0;
y = 0;
}
pPicture = 0;
while (nlist--)
{
x += list->xOff;
y += list->yOff;
n = list->len;
while (n--)
{
glyph = *glyphs++;
if (!pPicture)
{
pPixmap = GetScratchPixmapHeader (pScreen, glyph->info.width, glyph->info.height,
list->format->depth,
list->format->depth,
0, (pointer) (glyph + 1));
if (!pPixmap)
return;
component_alpha = NeedsComponent(list->format->format);
pPicture = CreatePicture (0, &pPixmap->drawable, list->format,
CPComponentAlpha, &component_alpha,
serverClient, &error);
if (!pPicture)
{
FreeScratchPixmapHeader (pPixmap);
return;
}
}
(*pScreen->ModifyPixmapHeader) (pPixmap,
glyph->info.width, glyph->info.height,
0, 0, -1, (pointer) (glyph + 1));
pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
if (maskFormat)
{
CompositePicture (PictOpAdd,
pPicture,
None,
pMask,
0, 0,
0, 0,
x - glyph->info.x,
y - glyph->info.y,
glyph->info.width,
glyph->info.height);
}
else
{
CompositePicture (op,
pSrc,
pPicture,
pDst,
xSrc + (x - glyph->info.x) - xDst,
ySrc + (y - glyph->info.y) - yDst,
0, 0,
x - glyph->info.x,
y - glyph->info.y,
glyph->info.width,
glyph->info.height);
}
x += glyph->info.xOff;
y += glyph->info.yOff;
}
list++;
if (pPicture)
{
FreeScratchPixmapHeader (pPixmap);
FreePicture ((pointer) pPicture, 0);
pPicture = 0;
pPixmap = 0;
}
}
if (maskFormat)
{
x = extents.x1;
y = extents.y1;
CompositePicture (op,
pSrc,
pMask,
pDst,
xSrc + x - xDst,
ySrc + y - yDst,
0, 0,
x, y,
width, height);
FreePicture ((pointer) pMask, (XID) 0);
(*pScreen->DestroyPixmap) (pMaskPixmap);
}
}
