/* * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina. * * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation on the rights to use, copy, modify, merge, * publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial * portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * Authors: * Kevin E. Martin <kem@redhat.com> * */ /** \file * Provide support for the RENDER extension (version 0.8). */ #ifdef HAVE_DMX_CONFIG_H #include <dmx-config.h> #endif #include "dmx.h" #include "dmxsync.h" #include "dmxpict.h" #include "dmxwindow.h" #include "dmxpixmap.h" #include "fb.h" #include "pixmapstr.h" #include "dixstruct.h" #include <X11/extensions/render.h> #include <X11/extensions/renderproto.h> #include "picture.h" #include "picturestr.h" #include "mipict.h" #include "fbpict.h" extern int RenderErrBase; extern int (*ProcRenderVector[RenderNumberRequests])(ClientPtr); static int (*dmxSaveRenderVector[RenderNumberRequests])(ClientPtr); static int dmxProcRenderCreateGlyphSet(ClientPtr client); static int dmxProcRenderFreeGlyphSet(ClientPtr client); static int dmxProcRenderAddGlyphs(ClientPtr client); static int dmxProcRenderFreeGlyphs(ClientPtr client); static int dmxProcRenderCompositeGlyphs(ClientPtr client); static int dmxProcRenderSetPictureTransform(ClientPtr client); static int dmxProcRenderSetPictureFilter(ClientPtr client); #if 0 /* FIXME: Not (yet) supported */ static int dmxProcRenderCreateCursor(ClientPtr client); static int dmxProcRenderCreateAnimCursor(ClientPtr client); #endif /** Catch errors that might occur when allocating Glyph Sets. Errors * are saved in dmxGlyphLastError for later handling. */ static int dmxGlyphLastError; static int dmxGlyphErrorHandler(Display *dpy, XErrorEvent *ev) { dmxGlyphLastError = ev->error_code; return 0; } /** Initialize the Proc Vector for the RENDER extension. The functions * here cannot be handled by the mi layer RENDER hooks either because * the required information is no longer available when it reaches the * mi layer or no mi layer hooks exist. This function is called from * InitOutput() since it should be initialized only once per server * generation. */ void dmxInitRender(void) { int i; for (i = 0; i < RenderNumberRequests; i++) dmxSaveRenderVector[i] = ProcRenderVector[i]; ProcRenderVector[X_RenderCreateGlyphSet] = dmxProcRenderCreateGlyphSet; ProcRenderVector[X_RenderFreeGlyphSet] = dmxProcRenderFreeGlyphSet; ProcRenderVector[X_RenderAddGlyphs] = dmxProcRenderAddGlyphs; ProcRenderVector[X_RenderFreeGlyphs] = dmxProcRenderFreeGlyphs; ProcRenderVector[X_RenderCompositeGlyphs8] = dmxProcRenderCompositeGlyphs; ProcRenderVector[X_RenderCompositeGlyphs16] = dmxProcRenderCompositeGlyphs; ProcRenderVector[X_RenderCompositeGlyphs32] = dmxProcRenderCompositeGlyphs; ProcRenderVector[X_RenderSetPictureTransform] = dmxProcRenderSetPictureTransform; ProcRenderVector[X_RenderSetPictureFilter] = dmxProcRenderSetPictureFilter; } /** Reset the Proc Vector for the RENDER extension back to the original * functions. This function is called from dmxCloseScreen() during the * server reset (only for screen #0). */ void dmxResetRender(void) { int i; for (i = 0; i < RenderNumberRequests; i++) ProcRenderVector[i] = dmxSaveRenderVector[i]; } /** Initialize the RENDER extension, allocate the picture privates and * wrap mi function hooks. If the shadow frame buffer is used, then * call the appropriate fb initialization function. */ Bool dmxPictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats) { DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps; /* The shadow framebuffer only relies on FB to be initialized */ if (dmxShadowFB) return fbPictureInit(pScreen, formats, nformats); if (!miPictureInit(pScreen, formats, nformats)) return FALSE; if (!dixRequestPrivate(dmxPictPrivateKey, sizeof(dmxPictPrivRec))) return FALSE; ps = GetPictureScreen(pScreen); DMX_WRAP(CreatePicture, dmxCreatePicture, dmxScreen, ps); DMX_WRAP(DestroyPicture, dmxDestroyPicture, dmxScreen, ps); DMX_WRAP(ChangePictureClip, dmxChangePictureClip, dmxScreen, ps); DMX_WRAP(DestroyPictureClip, dmxDestroyPictureClip, dmxScreen, ps); DMX_WRAP(ChangePicture, dmxChangePicture, dmxScreen, ps); DMX_WRAP(ValidatePicture, dmxValidatePicture, dmxScreen, ps); DMX_WRAP(Composite, dmxComposite, dmxScreen, ps); DMX_WRAP(Glyphs, dmxGlyphs, dmxScreen, ps); DMX_WRAP(CompositeRects, dmxCompositeRects, dmxScreen, ps); DMX_WRAP(Trapezoids, dmxTrapezoids, dmxScreen, ps); DMX_WRAP(Triangles, dmxTriangles, dmxScreen, ps); DMX_WRAP(TriStrip, dmxTriStrip, dmxScreen, ps); DMX_WRAP(TriFan, dmxTriFan, dmxScreen, ps); return TRUE; } /** Find the appropriate format on the requested screen given the * internal format requested. The list of formats is searched * sequentially as the XRenderFindFormat() function does not always * find the appropriate format when a specific format is requested. */ static XRenderPictFormat *dmxFindFormat(DMXScreenInfo *dmxScreen, PictFormatPtr pFmt) { XRenderPictFormat *pFormat = NULL; int i = 0; if (!pFmt || !dmxScreen->beDisplay) return pFormat; while (1) { pFormat = XRenderFindFormat(dmxScreen->beDisplay, 0, 0, i++); if (!pFormat) break; if (pFormat->type != pFmt->type) continue; if (pFormat->depth != pFmt->depth) continue; if (pFormat->direct.red != pFmt->direct.red) continue; if (pFormat->direct.redMask != pFmt->direct.redMask) continue; if (pFormat->direct.green != pFmt->direct.green) continue; if (pFormat->direct.greenMask != pFmt->direct.greenMask) continue; if (pFormat->direct.blue != pFmt->direct.blue) continue; if (pFormat->direct.blueMask != pFmt->direct.blueMask) continue; if (pFormat->direct.alpha != pFmt->direct.alpha) continue; if (pFormat->direct.alphaMask != pFmt->direct.alphaMask) continue; /* We have a match! */ break; } return pFormat; } /** Free \a glyphSet on back-end screen number \a idx. */ Bool dmxBEFreeGlyphSet(ScreenPtr pScreen, GlyphSetPtr glyphSet) { dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet); int idx = pScreen->myNum; DMXScreenInfo *dmxScreen = &dmxScreens[idx]; if (glyphPriv->glyphSets[idx]) { XRenderFreeGlyphSet(dmxScreen->beDisplay, glyphPriv->glyphSets[idx]); glyphPriv->glyphSets[idx] = (GlyphSet)0; return TRUE; } return FALSE; } /** Create \a glyphSet on the backend screen number \a idx. */ int dmxBECreateGlyphSet(int idx, GlyphSetPtr glyphSet) { XRenderPictFormat *pFormat; DMXScreenInfo *dmxScreen = &dmxScreens[idx]; dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet); PictFormatPtr pFmt = glyphSet->format; int (*oldErrorHandler)(Display *, XErrorEvent *); pFormat = dmxFindFormat(dmxScreen, pFmt); if (!pFormat) { return BadMatch; } dmxGlyphLastError = 0; oldErrorHandler = XSetErrorHandler(dmxGlyphErrorHandler); /* Catch when this fails */ glyphPriv->glyphSets[idx] = XRenderCreateGlyphSet(dmxScreen->beDisplay, pFormat); XSetErrorHandler(oldErrorHandler); if (dmxGlyphLastError) { return dmxGlyphLastError; } return Success; } /** Create a Glyph Set on each screen. Save the glyphset ID from each * screen in the Glyph Set's private structure. Fail if the format * requested is not available or if the Glyph Set cannot be created on * the screen. */ static int dmxProcRenderCreateGlyphSet(ClientPtr client) { int ret; REQUEST(xRenderCreateGlyphSetReq); ret = dmxSaveRenderVector[stuff->renderReqType](client); if (ret == Success) { GlyphSetPtr glyphSet; dmxGlyphPrivPtr glyphPriv; int i; /* Look up glyphSet that was just created ???? */ /* Store glyphsets from backends in glyphSet->devPrivate ????? */ /* Make sure we handle all errors here!! */ glyphSet = SecurityLookupIDByType(client, stuff->gsid, GlyphSetType, DixDestroyAccess); glyphPriv = xalloc(sizeof(dmxGlyphPrivRec)); if (!glyphPriv) return BadAlloc; glyphPriv->glyphSets = NULL; MAXSCREENSALLOC_RETURN(glyphPriv->glyphSets, BadAlloc); DMX_SET_GLYPH_PRIV(glyphSet, glyphPriv); for (i = 0; i < dmxNumScreens; i++) { DMXScreenInfo *dmxScreen = &dmxScreens[i]; int beret; if (!dmxScreen->beDisplay) { glyphPriv->glyphSets[i] = 0; continue; } if ((beret = dmxBECreateGlyphSet(i, glyphSet)) != Success) { int j; /* Free the glyph sets we've allocated thus far */ for (j = 0; j < i; j++) dmxBEFreeGlyphSet(screenInfo.screens[j], glyphSet); /* Free the resource created by render */ FreeResource(stuff->gsid, RT_NONE); return beret; } } } return ret; } /** Free the previously allocated Glyph Sets for each screen. */ static int dmxProcRenderFreeGlyphSet(ClientPtr client) { GlyphSetPtr glyphSet; REQUEST(xRenderFreeGlyphSetReq); REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq); glyphSet = SecurityLookupIDByType(client, stuff->glyphset, GlyphSetType, DixDestroyAccess); if (glyphSet && glyphSet->refcnt == 1) { dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet); int i; for (i = 0; i < dmxNumScreens; i++) { DMXScreenInfo *dmxScreen = &dmxScreens[i]; if (dmxScreen->beDisplay) { if (dmxBEFreeGlyphSet(screenInfo.screens[i], glyphSet)) dmxSync(dmxScreen, FALSE); } } MAXSCREENSFREE(glyphPriv->glyphSets); xfree(glyphPriv); DMX_SET_GLYPH_PRIV(glyphSet, NULL); } return dmxSaveRenderVector[stuff->renderReqType](client); } /** Add glyphs to the Glyph Set on each screen. */ static int dmxProcRenderAddGlyphs(ClientPtr client) { int ret; REQUEST(xRenderAddGlyphsReq); ret = dmxSaveRenderVector[stuff->renderReqType](client); if (ret == Success) { GlyphSetPtr glyphSet; dmxGlyphPrivPtr glyphPriv; int i; int nglyphs; CARD32 *gids; Glyph *gidsCopy; xGlyphInfo *gi; CARD8 *bits; int nbytes; glyphSet = SecurityLookupIDByType(client, stuff->glyphset, GlyphSetType, DixReadAccess); glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet); nglyphs = stuff->nglyphs; gids = (CARD32 *)(stuff + 1); gi = (xGlyphInfo *)(gids + nglyphs); bits = (CARD8 *)(gi + nglyphs); nbytes = ((stuff->length << 2) - sizeof(xRenderAddGlyphsReq) - (sizeof(CARD32) + sizeof(xGlyphInfo)) * nglyphs); gidsCopy = xalloc(sizeof(*gidsCopy) * nglyphs); for (i = 0; i < nglyphs; i++) gidsCopy[i] = gids[i]; /* FIXME: Will this ever fail? */ for (i = 0; i < dmxNumScreens; i++) { DMXScreenInfo *dmxScreen = &dmxScreens[i]; if (dmxScreen->beDisplay) { XRenderAddGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[i], gidsCopy, (XGlyphInfo *)gi, nglyphs, (char *)bits, nbytes); dmxSync(dmxScreen, FALSE); } } xfree(gidsCopy); } return ret; } /** Free glyphs from the Glyph Set for each screen. */ static int dmxProcRenderFreeGlyphs(ClientPtr client) { GlyphSetPtr glyphSet; REQUEST(xRenderFreeGlyphsReq); REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq); glyphSet = SecurityLookupIDByType(client, stuff->glyphset, GlyphSetType, DixWriteAccess); if (glyphSet) { dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet); int i; int nglyphs; Glyph *gids; nglyphs = ((client->req_len << 2) - sizeof(xRenderFreeGlyphsReq)) >> 2; if (nglyphs) { gids = xalloc(sizeof(*gids) * nglyphs); for (i = 0; i < nglyphs; i++) gids[i] = ((CARD32 *)(stuff + 1))[i]; for (i = 0; i < dmxNumScreens; i++) { DMXScreenInfo *dmxScreen = &dmxScreens[i]; if (dmxScreen->beDisplay) { XRenderFreeGlyphs(dmxScreen->beDisplay, glyphPriv->glyphSets[i], gids, nglyphs); dmxSync(dmxScreen, FALSE); } } xfree(gids); } } return dmxSaveRenderVector[stuff->renderReqType](client); } /** Composite glyphs on each screen into the requested picture. If * either the src or dest picture has not been allocated due to lazy * window creation, this request will gracefully return. */ static int dmxProcRenderCompositeGlyphs(ClientPtr client) { int ret; REQUEST(xRenderCompositeGlyphsReq); ret = dmxSaveRenderVector[stuff->renderReqType](client); /* For the following to work with PanoramiX, it assumes that Render * wraps the ProcRenderVector after dmxRenderInit has been called. */ if (ret == Success) { PicturePtr pSrc; dmxPictPrivPtr pSrcPriv; PicturePtr pDst; dmxPictPrivPtr pDstPriv; PictFormatPtr pFmt; XRenderPictFormat *pFormat; int size; int scrnNum; DMXScreenInfo *dmxScreen; CARD8 *buffer; CARD8 *end; int space; int nglyph; char *glyphs; char *curGlyph; xGlyphElt *elt; int nelt; XGlyphElt8 *elts; XGlyphElt8 *curElt; GlyphSetPtr glyphSet; dmxGlyphPrivPtr glyphPriv; pSrc = SecurityLookupIDByType(client, stuff->src, PictureType, DixReadAccess); pSrcPriv = DMX_GET_PICT_PRIV(pSrc); if (!pSrcPriv->pict) return ret; pDst = SecurityLookupIDByType(client, stuff->dst, PictureType, DixWriteAccess); pDstPriv = DMX_GET_PICT_PRIV(pDst); if (!pDstPriv->pict) return ret; scrnNum = pDst->pDrawable->pScreen->myNum; dmxScreen = &dmxScreens[scrnNum]; /* Note: If the back-end display has been detached, then it * should not be possible to reach here since the pSrcPriv->pict * and pDstPriv->pict will have already been set to 0. */ if (!dmxScreen->beDisplay) return ret; if (stuff->maskFormat) pFmt = SecurityLookupIDByType(client, stuff->maskFormat, PictFormatType, DixReadAccess); else pFmt = NULL; pFormat = dmxFindFormat(dmxScreen, pFmt); switch (stuff->renderReqType) { case X_RenderCompositeGlyphs8: size = sizeof(CARD8); break; case X_RenderCompositeGlyphs16: size = sizeof(CARD16); break; case X_RenderCompositeGlyphs32: size = sizeof(CARD32); break; default: return BadPictOp; /* Can't happen */ } buffer = (CARD8 *)(stuff + 1); end = (CARD8 *)stuff + (stuff->length << 2); nelt = 0; nglyph = 0; while (buffer + sizeof(xGlyphElt) < end) { elt = (xGlyphElt *)buffer; buffer += sizeof(xGlyphElt); if (elt->len == 0xff) { buffer += 4; } else { nelt++; nglyph += elt->len; space = size * elt->len; if (space & 3) space += 4 - (space & 3); buffer += space; } } /* The following only works for Render version > 0.2 */ /* All of the XGlyphElt* structure sizes are identical */ elts = xalloc(nelt * sizeof(XGlyphElt8)); if (!elts) return BadAlloc; glyphs = xalloc(nglyph * size); if (!glyphs) { xfree(elts); return BadAlloc; } buffer = (CARD8 *)(stuff + 1); end = (CARD8 *)stuff + (stuff->length << 2); curGlyph = glyphs; curElt = elts; glyphSet = SecurityLookupIDByType(client, stuff->glyphset, GlyphSetType, DixReadAccess); glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet); while (buffer + sizeof(xGlyphElt) < end) { elt = (xGlyphElt *)buffer; buffer += sizeof(xGlyphElt); if (elt->len == 0xff) { glyphSet = SecurityLookupIDByType(client, *((CARD32 *)buffer), GlyphSetType, DixReadAccess); glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet); buffer += 4; } else { curElt->glyphset = glyphPriv->glyphSets[scrnNum]; curElt->xOff = elt->deltax; curElt->yOff = elt->deltay; curElt->nchars = elt->len; curElt->chars = curGlyph; memcpy(curGlyph, buffer, size*elt->len); curGlyph += size * elt->len; curElt++; space = size * elt->len; if (space & 3) space += 4 - (space & 3); buffer += space; } } switch (stuff->renderReqType) { case X_RenderCompositeGlyphs8: XRenderCompositeText8(dmxScreen->beDisplay, stuff->op, pSrcPriv->pict, pDstPriv->pict, pFormat, stuff->xSrc, stuff->ySrc, 0, 0, elts, nelt); break; case X_RenderCompositeGlyphs16: XRenderCompositeText16(dmxScreen->beDisplay, stuff->op, pSrcPriv->pict, pDstPriv->pict, pFormat, stuff->xSrc, stuff->ySrc, 0, 0, (XGlyphElt16 *)elts, nelt); break; case X_RenderCompositeGlyphs32: XRenderCompositeText32(dmxScreen->beDisplay, stuff->op, pSrcPriv->pict, pDstPriv->pict, pFormat, stuff->xSrc, stuff->ySrc, 0, 0, (XGlyphElt32 *)elts, nelt); break; } dmxSync(dmxScreen, FALSE); xfree(elts); xfree(glyphs); } return ret; } /** Set the picture transform on each screen. */ static int dmxProcRenderSetPictureTransform(ClientPtr client) { DMXScreenInfo *dmxScreen; PicturePtr pPicture; dmxPictPrivPtr pPictPriv; XTransform xform; REQUEST(xRenderSetPictureTransformReq); REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq); VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess, RenderErrBase + BadPicture); /* For the following to work with PanoramiX, it assumes that Render * wraps the ProcRenderVector after dmxRenderInit has been called. */ dmxScreen = &dmxScreens[pPicture->pDrawable->pScreen->myNum]; pPictPriv = DMX_GET_PICT_PRIV(pPicture); if (pPictPriv->pict) { xform.matrix[0][0] = stuff->transform.matrix11; xform.matrix[0][1] = stuff->transform.matrix12; xform.matrix[0][2] = stuff->transform.matrix13; xform.matrix[1][0] = stuff->transform.matrix21; xform.matrix[1][1] = stuff->transform.matrix22; xform.matrix[1][2] = stuff->transform.matrix23; xform.matrix[2][0] = stuff->transform.matrix31; xform.matrix[2][1] = stuff->transform.matrix32; xform.matrix[2][2] = stuff->transform.matrix33; XRenderSetPictureTransform(dmxScreen->beDisplay, pPictPriv->pict, &xform); dmxSync(dmxScreen, FALSE); } return dmxSaveRenderVector[stuff->renderReqType](client); } /** Set the picture filter on each screen. */ static int dmxProcRenderSetPictureFilter(ClientPtr client) { DMXScreenInfo *dmxScreen; PicturePtr pPicture; dmxPictPrivPtr pPictPriv; char *filter; XFixed *params; int nparams; REQUEST(xRenderSetPictureFilterReq); REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq); VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess, RenderErrBase + BadPicture); /* For the following to work with PanoramiX, it assumes that Render * wraps the ProcRenderVector after dmxRenderInit has been called. */ dmxScreen = &dmxScreens[pPicture->pDrawable->pScreen->myNum]; pPictPriv = DMX_GET_PICT_PRIV(pPicture); if (pPictPriv->pict) { filter = (char *)(stuff + 1); params = (XFixed *)(filter + ((stuff->nbytes + 3) & ~3)); nparams = ((XFixed *)stuff + client->req_len) - params; XRenderSetPictureFilter(dmxScreen->beDisplay, pPictPriv->pict, filter, params, nparams); dmxSync(dmxScreen, FALSE); } return dmxSaveRenderVector[stuff->renderReqType](client); } /** Create a picture on the appropriate screen. This is the actual * function that creates the picture. However, if the associated * window has not yet been created due to lazy window creation, then * delay the picture creation until the window is mapped. */ static Picture dmxDoCreatePicture(PicturePtr pPicture) { DrawablePtr pDraw = pPicture->pDrawable; ScreenPtr pScreen = pDraw->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; XRenderPictFormat *pFormat; Drawable draw; if (pPicture->pDrawable->type == DRAWABLE_WINDOW) { dmxWinPrivPtr pWinPriv = DMX_GET_WINDOW_PRIV((WindowPtr)(pDraw)); if (!(draw = pWinPriv->window)) { /* Window has not been created yet due to the window * optimization. Delay picture creation until window is * mapped. */ pWinPriv->hasPict = TRUE; return 0; } } else { dmxPixPrivPtr pPixPriv = DMX_GET_PIXMAP_PRIV((PixmapPtr)(pDraw)); if (!(draw = pPixPriv->pixmap)) { /* FIXME: Zero width/height pixmap?? */ return 0; } } /* This should not be reached if the back-end display has been * detached because the pWinPriv->window or the pPixPriv->pixmap * will be NULL; however, we add it here for completeness */ if (!dmxScreen->beDisplay) return 0; pFormat = dmxFindFormat(dmxScreen, pPicture->pFormat); return XRenderCreatePicture(dmxScreen->beDisplay, draw, pFormat, 0, 0); } /** Create a list of pictures. This function is called by * dmxCreateAndRealizeWindow() during the lazy window creation * realization process. It creates the entire list of pictures that * are associated with the given window. */ void dmxCreatePictureList(WindowPtr pWindow) { PicturePtr pPicture = GetPictureWindow(pWindow); while (pPicture) { dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); /* Create the picture for this window */ pPictPriv->pict = dmxDoCreatePicture(pPicture); /* ValidatePicture takes care of the state changes */ pPicture = pPicture->pNext; } } /** Create \a pPicture on the backend. */ int dmxBECreatePicture(PicturePtr pPicture) { dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); /* Create picutre on BE */ pPictPriv->pict = dmxDoCreatePicture(pPicture); /* Flush changes to the backend server */ dmxValidatePicture(pPicture, (1 << (CPLastBit+1)) - 1); return Success; } /** Create a picture. This function handles the CreatePicture * unwrapping/wrapping and calls dmxDoCreatePicture to actually create * the picture on the appropriate screen. */ int dmxCreatePicture(PicturePtr pPicture) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); int ret = Success; DMX_UNWRAP(CreatePicture, dmxScreen, ps); #if 1 if (ps->CreatePicture) ret = ps->CreatePicture(pPicture); #endif /* Create picture on back-end server */ pPictPriv->pict = dmxDoCreatePicture(pPicture); pPictPriv->savedMask = 0; DMX_WRAP(CreatePicture, dmxCreatePicture, dmxScreen, ps); return ret; } /** Destroy \a pPicture on the back-end server. */ Bool dmxBEFreePicture(PicturePtr pPicture) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); if (pPictPriv->pict) { XRenderFreePicture(dmxScreen->beDisplay, pPictPriv->pict); pPictPriv->pict = (Picture)0; return TRUE; } return FALSE; } /** Destroy a list of pictures that are associated with the window that * is being destroyed. This function is called by #dmxDestroyWindow(). * */ Bool dmxDestroyPictureList(WindowPtr pWindow) { PicturePtr pPicture = GetPictureWindow(pWindow); Bool ret = FALSE; while (pPicture) { ret |= dmxBEFreePicture(pPicture); pPicture = pPicture->pNext; } return ret; } /** Destroy a picture. This function calls the wrapped function that * frees the resources in the DMX server associated with this * picture. */ void dmxDestroyPicture(PicturePtr pPicture) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); DMX_UNWRAP(DestroyPicture, dmxScreen, ps); /* Destroy picture on back-end server */ if (dmxBEFreePicture(pPicture)) dmxSync(dmxScreen, FALSE); #if 1 if (ps->DestroyPicture) ps->DestroyPicture(pPicture); #endif DMX_WRAP(DestroyPicture, dmxDestroyPicture, dmxScreen, ps); } /** Change the picture's list of clip rectangles. */ int dmxChangePictureClip(PicturePtr pPicture, int clipType, pointer value, int n) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); DMX_UNWRAP(ChangePictureClip, dmxScreen, ps); #if 1 if (ps->ChangePictureClip) ps->ChangePictureClip(pPicture, clipType, value, n); #endif /* Change picture clip rects on back-end server */ if (pPictPriv->pict) { /* The clip has already been changed into a region by the mi * routine called above. */ if (clipType == CT_NONE) { /* Disable clipping, show all */ XFixesSetPictureClipRegion(dmxScreen->beDisplay, pPictPriv->pict, 0, 0, None); } else if (pPicture->clientClip) { RegionPtr pClip = pPicture->clientClip; BoxPtr pBox = REGION_RECTS(pClip); int nBox = REGION_NUM_RECTS(pClip); XRectangle *pRects; XRectangle *pRect; int nRects; nRects = nBox; pRects = pRect = xalloc(nRects * sizeof(*pRect)); while (nBox--) { pRect->x = pBox->x1; pRect->y = pBox->y1; pRect->width = pBox->x2 - pBox->x1; pRect->height = pBox->y2 - pBox->y1; pBox++; pRect++; } XRenderSetPictureClipRectangles(dmxScreen->beDisplay, pPictPriv->pict, 0, 0, pRects, nRects); xfree(pRects); } else { XRenderSetPictureClipRectangles(dmxScreen->beDisplay, pPictPriv->pict, 0, 0, NULL, 0); } dmxSync(dmxScreen, FALSE); } else { /* FIXME: Handle saving clip region when offscreen */ } DMX_WRAP(ChangePictureClip, dmxChangePictureClip, dmxScreen, ps); return Success; } /** Destroy the picture's list of clip rectangles. */ void dmxDestroyPictureClip(PicturePtr pPicture) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); DMX_UNWRAP(DestroyPictureClip, dmxScreen, ps); #if 1 if (ps->DestroyPictureClip) ps->DestroyPictureClip(pPicture); #endif /* Destroy picture clip rects on back-end server */ if (pPictPriv->pict) { XRenderSetPictureClipRectangles(dmxScreen->beDisplay, pPictPriv->pict, 0, 0, NULL, 0); dmxSync(dmxScreen, FALSE); } else { /* FIXME: Handle destroying clip region when offscreen */ } DMX_WRAP(DestroyPictureClip, dmxDestroyPictureClip, dmxScreen, ps); } /** Change the attributes of the pictures. If the picture has not yet * been created due to lazy window creation, save the mask so that it * can be used to appropriately initialize the picture's attributes * when it is created later. */ void dmxChangePicture(PicturePtr pPicture, Mask mask) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); DMX_UNWRAP(ChangePicture, dmxScreen, ps); #if 1 if (ps->ChangePicture) ps->ChangePicture(pPicture, mask); #endif /* Picture attribute changes are handled in ValidatePicture */ pPictPriv->savedMask |= mask; DMX_WRAP(ChangePicture, dmxChangePicture, dmxScreen, ps); } /** Validate the picture's attributes before rendering to it. Update * any picture attributes that have been changed by one of the higher * layers. */ void dmxValidatePicture(PicturePtr pPicture, Mask mask) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); DMX_UNWRAP(ValidatePicture, dmxScreen, ps); /* Change picture attributes on back-end server */ if (pPictPriv->pict) { XRenderPictureAttributes attribs; if (mask & CPRepeat) { attribs.repeat = pPicture->repeatType; } if (mask & CPAlphaMap) { if (pPicture->alphaMap) { dmxPictPrivPtr pAlphaPriv; pAlphaPriv = DMX_GET_PICT_PRIV(pPicture->alphaMap); if (pAlphaPriv->pict) { attribs.alpha_map = pAlphaPriv->pict; } else { /* FIXME: alpha picture drawable has not been created?? */ return; /* or should this be: attribs.alpha_map = None; */ } } else { attribs.alpha_map = None; } } if (mask & CPAlphaXOrigin) attribs.alpha_x_origin = pPicture->alphaOrigin.x; if (mask & CPAlphaYOrigin) attribs.alpha_y_origin = pPicture->alphaOrigin.y; if (mask & CPClipXOrigin) attribs.clip_x_origin = pPicture->clipOrigin.x; if (mask & CPClipYOrigin) attribs.clip_y_origin = pPicture->clipOrigin.y; if (mask & CPClipMask) mask &= ~CPClipMask; /* Handled in ChangePictureClip */ if (mask & CPGraphicsExposure) attribs.graphics_exposures = pPicture->graphicsExposures; if (mask & CPSubwindowMode) attribs.subwindow_mode = pPicture->subWindowMode; if (mask & CPPolyEdge) attribs.poly_edge = pPicture->polyEdge; if (mask & CPPolyMode) attribs.poly_mode = pPicture->polyMode; if (mask & CPDither) attribs.dither = pPicture->dither; if (mask & CPComponentAlpha) attribs.component_alpha = pPicture->componentAlpha; XRenderChangePicture(dmxScreen->beDisplay, pPictPriv->pict, mask, &attribs); dmxSync(dmxScreen, FALSE); } else { pPictPriv->savedMask |= mask; } #if 1 if (ps->ValidatePicture) ps->ValidatePicture(pPicture, mask); #endif DMX_WRAP(ValidatePicture, dmxValidatePicture, dmxScreen, ps); } /** Composite a picture on the appropriate screen by combining the * specified rectangle of the transformed src and mask operands with * the specified rectangle of the dst using op as the compositing * operator. For a complete description see the protocol document of * the RENDER library. */ void dmxComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height) { ScreenPtr pScreen = pDst->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pSrcPriv = DMX_GET_PICT_PRIV(pSrc); dmxPictPrivPtr pMaskPriv = NULL; dmxPictPrivPtr pDstPriv = DMX_GET_PICT_PRIV(pDst); if (pMask) pMaskPriv = DMX_GET_PICT_PRIV(pMask); DMX_UNWRAP(Composite, dmxScreen, ps); #if 0 if (ps->Composite) ps->Composite(op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height); #endif /* Composite on back-end server */ if (pSrcPriv->pict && pDstPriv->pict && ((pMaskPriv && pMaskPriv->pict) || !pMaskPriv)) { XRenderComposite(dmxScreen->beDisplay, op, pSrcPriv->pict, pMaskPriv ? pMaskPriv->pict : None, pDstPriv->pict, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height); dmxSync(dmxScreen, FALSE); } DMX_WRAP(Composite, dmxComposite, dmxScreen, ps); } /** Null function to catch when/if RENDER calls lower level mi hooks. * Compositing glyphs is handled by dmxProcRenderCompositeGlyphs(). * This function should never be called. */ void dmxGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlists, GlyphListPtr lists, GlyphPtr *glyphs) { /* This won't work, so we need to wrap ProcRenderCompositeGlyphs */ } /** Fill a rectangle on the appropriate screen by combining the color * with the dest picture in the area specified by the list of * rectangles. For a complete description see the protocol document of * the RENDER library. */ void dmxCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor *color, int nRect, xRectangle *rects) { ScreenPtr pScreen = pDst->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pDst); DMX_UNWRAP(CompositeRects, dmxScreen, ps); #if 0 if (ps->CompositeRects) ps->CompositeRects(op, pDst, color, nRect, rects); #endif /* CompositeRects on back-end server */ if (pPictPriv->pict) { XRenderFillRectangles(dmxScreen->beDisplay, op, pPictPriv->pict, (XRenderColor *)color, (XRectangle *)rects, nRect); dmxSync(dmxScreen, FALSE); } DMX_WRAP(CompositeRects, dmxCompositeRects, dmxScreen, ps); } /** Indexed color visuals are not yet supported. */ Bool dmxInitIndexed(ScreenPtr pScreen, PictFormatPtr pFormat) { return TRUE; } /** Indexed color visuals are not yet supported. */ void dmxCloseIndexed(ScreenPtr pScreen, PictFormatPtr pFormat) { } /** Indexed color visuals are not yet supported. */ void dmxUpdateIndexed(ScreenPtr pScreen, PictFormatPtr pFormat, int ndef, xColorItem *pdef) { } /** Composite a list of trapezoids on the appropriate screen. For a * complete description see the protocol document of the RENDER * library. */ void dmxTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int ntrap, xTrapezoid *traps) { ScreenPtr pScreen = pDst->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pSrcPriv = DMX_GET_PICT_PRIV(pSrc); dmxPictPrivPtr pDstPriv = DMX_GET_PICT_PRIV(pDst); DMX_UNWRAP(Trapezoids, dmxScreen, ps); #if 0 if (ps->Trapezoids) ps->Trapezoids(op, pSrc, pDst, maskFormat, xSrc, ySrc, ntrap, *traps); #endif /* Draw trapezoids on back-end server */ if (pDstPriv->pict) { XRenderPictFormat *pFormat; pFormat = dmxFindFormat(dmxScreen, maskFormat); if (!pFormat) { /* FIXME: Error! */ } XRenderCompositeTrapezoids(dmxScreen->beDisplay, op, pSrcPriv->pict, pDstPriv->pict, pFormat, xSrc, ySrc, (XTrapezoid *)traps, ntrap); dmxSync(dmxScreen, FALSE); } DMX_WRAP(Trapezoids, dmxTrapezoids, dmxScreen, ps); } /** Composite a list of triangles on the appropriate screen. For a * complete description see the protocol document of the RENDER * library. */ void dmxTriangles(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int ntri, xTriangle *tris) { ScreenPtr pScreen = pDst->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pSrcPriv = DMX_GET_PICT_PRIV(pSrc); dmxPictPrivPtr pDstPriv = DMX_GET_PICT_PRIV(pDst); DMX_UNWRAP(Triangles, dmxScreen, ps); #if 0 if (ps->Triangles) ps->Triangles(op, pSrc, pDst, maskFormat, xSrc, ySrc, ntri, *tris); #endif /* Draw trapezoids on back-end server */ if (pDstPriv->pict) { XRenderPictFormat *pFormat; pFormat = dmxFindFormat(dmxScreen, maskFormat); if (!pFormat) { /* FIXME: Error! */ } XRenderCompositeTriangles(dmxScreen->beDisplay, op, pSrcPriv->pict, pDstPriv->pict, pFormat, xSrc, ySrc, (XTriangle *)tris, ntri); dmxSync(dmxScreen, FALSE); } DMX_WRAP(Triangles, dmxTriangles, dmxScreen, ps); } /** Composite a triangle strip on the appropriate screen. For a * complete description see the protocol document of the RENDER * library. */ void dmxTriStrip(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int npoint, xPointFixed *points) { ScreenPtr pScreen = pDst->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pSrcPriv = DMX_GET_PICT_PRIV(pSrc); dmxPictPrivPtr pDstPriv = DMX_GET_PICT_PRIV(pDst); DMX_UNWRAP(TriStrip, dmxScreen, ps); #if 0 if (ps->TriStrip) ps->TriStrip(op, pSrc, pDst, maskFormat, xSrc, ySrc, npoint, *points); #endif /* Draw trapezoids on back-end server */ if (pDstPriv->pict) { XRenderPictFormat *pFormat; pFormat = dmxFindFormat(dmxScreen, maskFormat); if (!pFormat) { /* FIXME: Error! */ } XRenderCompositeTriStrip(dmxScreen->beDisplay, op, pSrcPriv->pict, pDstPriv->pict, pFormat, xSrc, ySrc, (XPointFixed *)points, npoint); dmxSync(dmxScreen, FALSE); } DMX_WRAP(TriStrip, dmxTriStrip, dmxScreen, ps); } /** Composite a triangle fan on the appropriate screen. For a complete * description see the protocol document of the RENDER library. */ void dmxTriFan(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int npoint, xPointFixed *points) { ScreenPtr pScreen = pDst->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pSrcPriv = DMX_GET_PICT_PRIV(pSrc); dmxPictPrivPtr pDstPriv = DMX_GET_PICT_PRIV(pDst); DMX_UNWRAP(TriFan, dmxScreen, ps); #if 0 if (ps->TriFan) ps->TriFan(op, pSrc, pDst, maskFormat, xSrc, ySrc, npoint, *points); #endif /* Draw trapezoids on back-end server */ if (pDstPriv->pict) { XRenderPictFormat *pFormat; pFormat = dmxFindFormat(dmxScreen, maskFormat); if (!pFormat) { /* FIXME: Error! */ } XRenderCompositeTriFan(dmxScreen->beDisplay, op, pSrcPriv->pict, pDstPriv->pict, pFormat, xSrc, ySrc, (XPointFixed *)points, npoint); dmxSync(dmxScreen, FALSE); } DMX_WRAP(TriFan, dmxTriFan, dmxScreen, ps); }