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); } }