#ifdef NXAGENT_UPGRADE #include "X/NXrender.c" #else /* * $XFree86: xc/programs/Xserver/render/render.c,v 1.26 2003/02/14 18:15:21 dawes Exp $ * * Copyright � 2000 SuSE, Inc. * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of SuSE not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. SuSE makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, SuSE, Inc. */ /**************************************************************************/ /* */ /* Copyright (c) 2001, 2011 NoMachine, http://www.nomachine.com/. */ /* */ /* NXAGENT, NX protocol compression and NX extensions to this software */ /* are copyright of NoMachine. Redistribution and use of the present */ /* software is allowed according to terms specified in the file LICENSE */ /* which comes in the source distribution. */ /* */ /* Check http://www.nomachine.com/licensing.html for applicability. */ /* */ /* NX and NoMachine are trademarks of Medialogic S.p.A. */ /* */ /* All rights reserved. */ /* */ /**************************************************************************/ #define NEED_REPLIES #define NEED_EVENTS #include "X.h" #include "Xproto.h" #include "misc.h" #include "os.h" #include "dixstruct.h" #include "resource.h" #include "scrnintstr.h" #include "windowstr.h" #include "pixmapstr.h" #include "colormapst.h" #include "extnsionst.h" #include "servermd.h" #include "render.h" #include "renderproto.h" #include "Xfuncproto.h" #include "cursorstr.h" #ifdef EXTMODULE #include "xf86_ansic.h" #endif #include "NXpicturestr.h" #include "NXglyphstr.h" #include "Trap.h" #include "Render.h" #include "Pixmaps.h" #include "Options.h" #include "Screen.h" /* * Set here the required log level. */ #define PANIC #define WARNING #undef TEST #undef DEBUG /* * From NXmiglyph.c. */ void miGlyphExtents(int nlist, GlyphListPtr list, GlyphPtr *glyphs, BoxPtr extents); /* * Functions from Render.c. */ int nxagentCursorSaveRenderInfo(ScreenPtr, CursorPtr); void nxagentCursorPostSaveRenderInfo(CursorPtr, ScreenPtr, PicturePtr, int, int); int nxagentRenderRealizeCursor(ScreenPtr, CursorPtr); int nxagentCreatePicture(PicturePtr, Mask); void nxagentDestroyPicture(PicturePtr pPicture); void nxagentChangePicture(PicturePtr, Mask); int nxagentChangePictureClip(PicturePtr, int, int, xRectangle *, int, int); void nxagentComposite(CARD8, PicturePtr, PicturePtr, PicturePtr, INT16, INT16, INT16, INT16, INT16, INT16, CARD16, CARD16); void nxagentCompositeRects(CARD8, PicturePtr, xRenderColor *, int, xRectangle *); void nxagentCreateGlyphSet(GlyphSetPtr glyphSet); void nxagentReferenceGlyphSet(GlyphSetPtr glyphSet); void nxagentFreeGlyphs(GlyphSetPtr glyphSet, CARD32 *gids, int nglyph); void nxagentFreeGlyphSet(GlyphSetPtr glyphSet); void nxagentSetPictureTransform(PicturePtr pPicture, pointer transform); void nxagentSetPictureFilter(PicturePtr pPicture, char *filter, int name_size, pointer params, int nparams); void nxagentTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int ntrap, xTrapezoid *traps); /* * The void pointer is actually a XGlyphElt8. */ void nxagentGlyphs(CARD8, PicturePtr, PicturePtr, PictFormatPtr, INT16, INT16, int, void *, int, GlyphPtr *); static int ProcRenderQueryVersion (ClientPtr pClient); static int ProcRenderQueryPictFormats (ClientPtr pClient); static int ProcRenderQueryPictIndexValues (ClientPtr pClient); static int ProcRenderQueryDithers (ClientPtr pClient); static int ProcRenderCreatePicture (ClientPtr pClient); static int ProcRenderChangePicture (ClientPtr pClient); static int ProcRenderSetPictureClipRectangles (ClientPtr pClient); static int ProcRenderFreePicture (ClientPtr pClient); static int ProcRenderComposite (ClientPtr pClient); static int ProcRenderScale (ClientPtr pClient); static int ProcRenderTrapezoids (ClientPtr pClient); static int ProcRenderTriangles (ClientPtr pClient); static int ProcRenderTriStrip (ClientPtr pClient); static int ProcRenderTriFan (ClientPtr pClient); static int ProcRenderColorTrapezoids (ClientPtr pClient); static int ProcRenderColorTriangles (ClientPtr pClient); static int ProcRenderTransform (ClientPtr pClient); static int ProcRenderCreateGlyphSet (ClientPtr pClient); static int ProcRenderReferenceGlyphSet (ClientPtr pClient); static int ProcRenderFreeGlyphSet (ClientPtr pClient); static int ProcRenderAddGlyphs (ClientPtr pClient); static int ProcRenderAddGlyphsFromPicture (ClientPtr pClient); static int ProcRenderFreeGlyphs (ClientPtr pClient); static int ProcRenderCompositeGlyphs (ClientPtr pClient); static int ProcRenderFillRectangles (ClientPtr pClient); static int ProcRenderCreateCursor (ClientPtr pClient); static int ProcRenderSetPictureTransform (ClientPtr pClient); static int ProcRenderQueryFilters (ClientPtr pClient); static int ProcRenderSetPictureFilter (ClientPtr pClient); static int ProcRenderCreateAnimCursor (ClientPtr pClient); static int ProcRenderDispatch (ClientPtr pClient); static int SProcRenderQueryVersion (ClientPtr pClient); static int SProcRenderQueryPictFormats (ClientPtr pClient); static int SProcRenderQueryPictIndexValues (ClientPtr pClient); static int SProcRenderQueryDithers (ClientPtr pClient); static int SProcRenderCreatePicture (ClientPtr pClient); static int SProcRenderChangePicture (ClientPtr pClient); static int SProcRenderSetPictureClipRectangles (ClientPtr pClient); static int SProcRenderFreePicture (ClientPtr pClient); static int SProcRenderComposite (ClientPtr pClient); static int SProcRenderScale (ClientPtr pClient); static int SProcRenderTrapezoids (ClientPtr pClient); static int SProcRenderTriangles (ClientPtr pClient); static int SProcRenderTriStrip (ClientPtr pClient); static int SProcRenderTriFan (ClientPtr pClient); static int SProcRenderColorTrapezoids (ClientPtr pClient); static int SProcRenderColorTriangles (ClientPtr pClient); static int SProcRenderTransform (ClientPtr pClient); static int SProcRenderCreateGlyphSet (ClientPtr pClient); static int SProcRenderReferenceGlyphSet (ClientPtr pClient); static int SProcRenderFreeGlyphSet (ClientPtr pClient); static int SProcRenderAddGlyphs (ClientPtr pClient); static int SProcRenderAddGlyphsFromPicture (ClientPtr pClient); static int SProcRenderFreeGlyphs (ClientPtr pClient); static int SProcRenderCompositeGlyphs (ClientPtr pClient); static int SProcRenderFillRectangles (ClientPtr pClient); static int SProcRenderCreateCursor (ClientPtr pClient); static int SProcRenderSetPictureTransform (ClientPtr pClient); static int SProcRenderQueryFilters (ClientPtr pClient); static int SProcRenderSetPictureFilter (ClientPtr pClient); static int SProcRenderCreateAnimCursor (ClientPtr pClient); static int SProcRenderDispatch (ClientPtr pClient); int (*ProcRenderVector[RenderNumberRequests])(ClientPtr) = { ProcRenderQueryVersion, ProcRenderQueryPictFormats, ProcRenderQueryPictIndexValues, ProcRenderQueryDithers, ProcRenderCreatePicture, ProcRenderChangePicture, ProcRenderSetPictureClipRectangles, ProcRenderFreePicture, ProcRenderComposite, ProcRenderScale, ProcRenderTrapezoids, ProcRenderTriangles, ProcRenderTriStrip, ProcRenderTriFan, ProcRenderColorTrapezoids, ProcRenderColorTriangles, ProcRenderTransform, ProcRenderCreateGlyphSet, ProcRenderReferenceGlyphSet, ProcRenderFreeGlyphSet, ProcRenderAddGlyphs, ProcRenderAddGlyphsFromPicture, ProcRenderFreeGlyphs, ProcRenderCompositeGlyphs, ProcRenderCompositeGlyphs, ProcRenderCompositeGlyphs, ProcRenderFillRectangles, ProcRenderCreateCursor, ProcRenderSetPictureTransform, ProcRenderQueryFilters, ProcRenderSetPictureFilter, ProcRenderCreateAnimCursor, }; int (*SProcRenderVector[RenderNumberRequests])(ClientPtr) = { SProcRenderQueryVersion, SProcRenderQueryPictFormats, SProcRenderQueryPictIndexValues, SProcRenderQueryDithers, SProcRenderCreatePicture, SProcRenderChangePicture, SProcRenderSetPictureClipRectangles, SProcRenderFreePicture, SProcRenderComposite, SProcRenderScale, SProcRenderTrapezoids, SProcRenderTriangles, SProcRenderTriStrip, SProcRenderTriFan, SProcRenderColorTrapezoids, SProcRenderColorTriangles, SProcRenderTransform, SProcRenderCreateGlyphSet, SProcRenderReferenceGlyphSet, SProcRenderFreeGlyphSet, SProcRenderAddGlyphs, SProcRenderAddGlyphsFromPicture, SProcRenderFreeGlyphs, SProcRenderCompositeGlyphs, SProcRenderCompositeGlyphs, SProcRenderCompositeGlyphs, SProcRenderFillRectangles, SProcRenderCreateCursor, SProcRenderSetPictureTransform, SProcRenderQueryFilters, SProcRenderSetPictureFilter, SProcRenderCreateAnimCursor, }; static void RenderResetProc (ExtensionEntry *extEntry); static CARD8 RenderReqCode; int RenderErrBase; int RenderClientPrivateIndex; typedef struct _RenderClient { int major_version; int minor_version; } RenderClientRec, *RenderClientPtr; #define GetRenderClient(pClient) ((RenderClientPtr) (pClient)->devPrivates[RenderClientPrivateIndex].ptr) static void RenderClientCallback (CallbackListPtr *list, pointer closure, pointer data) { NewClientInfoRec *clientinfo = (NewClientInfoRec *) data; ClientPtr pClient = clientinfo->client; RenderClientPtr pRenderClient = GetRenderClient (pClient); pRenderClient->major_version = 0; pRenderClient->minor_version = 0; } void RenderExtensionInit (void) { ExtensionEntry *extEntry; if (!PictureType) return; if (!PictureFinishInit ()) return; RenderClientPrivateIndex = AllocateClientPrivateIndex (); if (!AllocateClientPrivate (RenderClientPrivateIndex, sizeof (RenderClientRec))) return; if (!AddCallback (&ClientStateCallback, RenderClientCallback, 0)) return; extEntry = AddExtension (RENDER_NAME, 0, RenderNumberErrors, ProcRenderDispatch, SProcRenderDispatch, RenderResetProc, StandardMinorOpcode); if (!extEntry) return; RenderReqCode = (CARD8) extEntry->base; RenderErrBase = extEntry->errorBase; } static void RenderResetProc (ExtensionEntry *extEntry) { } static int ProcRenderQueryVersion (ClientPtr client) { RenderClientPtr pRenderClient = GetRenderClient (client); xRenderQueryVersionReply rep; register int n; REQUEST(xRenderQueryVersionReq); pRenderClient->major_version = stuff->majorVersion; pRenderClient->minor_version = stuff->minorVersion; REQUEST_SIZE_MATCH(xRenderQueryVersionReq); rep.type = X_Reply; rep.length = 0; rep.sequenceNumber = client->sequence; rep.majorVersion = nxagentRenderVersionMajor; rep.minorVersion = nxagentRenderVersionMinor; if (client->swapped) { swaps(&rep.sequenceNumber, n); swapl(&rep.length, n); swapl(&rep.majorVersion, n); swapl(&rep.minorVersion, n); } WriteToClient(client, sizeof(xRenderQueryVersionReply), (char *)&rep); return (client->noClientException); } #if 0 static int VisualDepth (ScreenPtr pScreen, VisualPtr pVisual) { DepthPtr pDepth; int d, v; for (d = 0; d < pScreen->numDepths; d++) { pDepth = pScreen->allowedDepths + d; for (v = 0; v < pDepth->numVids; v++) { if (pDepth->vids[v] == pVisual->vid) return pDepth->depth; } } return 0; } #endif static VisualPtr findVisual (ScreenPtr pScreen, VisualID vid) { VisualPtr pVisual; int v; for (v = 0; v < pScreen->numVisuals; v++) { pVisual = pScreen->visuals + v; if (pVisual->vid == vid) return pVisual; } return 0; } extern char *ConnectionInfo; static int ProcRenderQueryPictFormats (ClientPtr client) { RenderClientPtr pRenderClient = GetRenderClient (client); xRenderQueryPictFormatsReply *reply; xPictScreen *pictScreen; xPictDepth *pictDepth; xPictVisual *pictVisual; xPictFormInfo *pictForm; CARD32 *pictSubpixel; ScreenPtr pScreen; VisualPtr pVisual; DepthPtr pDepth; int v, d; PictureScreenPtr ps; PictFormatPtr pFormat; int nformat; int ndepth; int nvisual; int rlength; int s; int n; int numScreens; int numSubpixel; extern int nxagentAlphaEnabled; /* REQUEST(xRenderQueryPictFormatsReq); */ REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq); #ifdef PANORAMIX if (noPanoramiXExtension) numScreens = screenInfo.numScreens; else numScreens = ((xConnSetup *)ConnectionInfo)->numRoots; #else numScreens = screenInfo.numScreens; #endif ndepth = nformat = nvisual = 0; for (s = 0; s < numScreens; s++) { pScreen = screenInfo.screens[s]; for (d = 0; d < pScreen->numDepths; d++) { pDepth = pScreen->allowedDepths + d; ++ndepth; for (v = 0; v < pDepth->numVids; v++) { pVisual = findVisual (pScreen, pDepth->vids[v]); if (pVisual && PictureMatchVisual (pScreen, pDepth->depth, pVisual)) ++nvisual; } } ps = GetPictureScreenIfSet(pScreen); if (ps) nformat += ps->nformats; } if (pRenderClient->major_version == 0 && pRenderClient->minor_version < 6) numSubpixel = 0; else numSubpixel = numScreens; rlength = (sizeof (xRenderQueryPictFormatsReply) + nformat * sizeof (xPictFormInfo) + numScreens * sizeof (xPictScreen) + ndepth * sizeof (xPictDepth) + nvisual * sizeof (xPictVisual) + numSubpixel * sizeof (CARD32)); reply = (xRenderQueryPictFormatsReply *) xalloc (rlength); if (!reply) return BadAlloc; reply->type = X_Reply; reply->sequenceNumber = client->sequence; reply->length = (rlength - sizeof(xGenericReply)) >> 2; reply->numFormats = nformat; reply->numScreens = numScreens; reply->numDepths = ndepth; reply->numVisuals = nvisual; reply->numSubpixel = numSubpixel; pictForm = (xPictFormInfo *) (reply + 1); for (s = 0; s < numScreens; s++) { pScreen = screenInfo.screens[s]; ps = GetPictureScreenIfSet(pScreen); if (ps) { for (nformat = 0, pFormat = ps->formats; nformat < ps->nformats; nformat++, pFormat++) { pictForm->id = pFormat->id; pictForm->type = pFormat->type; pictForm->depth = pFormat->depth; pictForm->direct.red = pFormat->direct.red; pictForm->direct.redMask = pFormat->direct.redMask; pictForm->direct.green = pFormat->direct.green; pictForm->direct.greenMask = pFormat->direct.greenMask; pictForm->direct.blue = pFormat->direct.blue; pictForm->direct.blueMask = pFormat->direct.blueMask; pictForm->direct.alpha = nxagentAlphaEnabled ? pFormat->direct.alpha : 0; pictForm->direct.alphaMask = pFormat->direct.alphaMask; if (pFormat->type == PictTypeIndexed && pFormat->index.pColormap) pictForm->colormap = pFormat->index.pColormap->mid; else pictForm->colormap = None; if (client->swapped) { swapl (&pictForm->id, n); swaps (&pictForm->direct.red, n); swaps (&pictForm->direct.redMask, n); swaps (&pictForm->direct.green, n); swaps (&pictForm->direct.greenMask, n); swaps (&pictForm->direct.blue, n); swaps (&pictForm->direct.blueMask, n); swaps (&pictForm->direct.alpha, n); swaps (&pictForm->direct.alphaMask, n); swapl (&pictForm->colormap, n); } pictForm++; } } } pictScreen = (xPictScreen *) pictForm; for (s = 0; s < numScreens; s++) { pScreen = screenInfo.screens[s]; pictDepth = (xPictDepth *) (pictScreen + 1); ndepth = 0; for (d = 0; d < pScreen->numDepths; d++) { pictVisual = (xPictVisual *) (pictDepth + 1); pDepth = pScreen->allowedDepths + d; nvisual = 0; for (v = 0; v < pDepth->numVids; v++) { pVisual = findVisual (pScreen, pDepth->vids[v]); if (pVisual && (pFormat = PictureMatchVisual (pScreen, pDepth->depth, pVisual))) { pictVisual->visual = pVisual->vid; pictVisual->format = pFormat->id; if (client->swapped) { swapl (&pictVisual->visual, n); swapl (&pictVisual->format, n); } pictVisual++; nvisual++; } } pictDepth->depth = pDepth->depth; pictDepth->nPictVisuals = nvisual; if (client->swapped) { swaps (&pictDepth->nPictVisuals, n); } ndepth++; pictDepth = (xPictDepth *) pictVisual; } pictScreen->nDepth = ndepth; ps = GetPictureScreenIfSet(pScreen); if (ps) pictScreen->fallback = ps->fallback->id; else pictScreen->fallback = 0; if (client->swapped) { swapl (&pictScreen->nDepth, n); swapl (&pictScreen->fallback, n); } pictScreen = (xPictScreen *) pictDepth; } pictSubpixel = (CARD32 *) pictScreen; for (s = 0; s < numSubpixel; s++) { pScreen = screenInfo.screens[s]; ps = GetPictureScreenIfSet(pScreen); if (ps) *pictSubpixel = ps->subpixel; else *pictSubpixel = SubPixelUnknown; if (client->swapped) { swapl (pictSubpixel, n); } ++pictSubpixel; } if (client->swapped) { swaps (&reply->sequenceNumber, n); swapl (&reply->length, n); swapl (&reply->numFormats, n); swapl (&reply->numScreens, n); swapl (&reply->numDepths, n); swapl (&reply->numVisuals, n); swapl (&reply->numSubpixel, n); } WriteToClient(client, rlength, (char *) reply); xfree (reply); return client->noClientException; } static int ProcRenderQueryPictIndexValues (ClientPtr client) { PictFormatPtr pFormat; int num; int rlength; int i, n; REQUEST(xRenderQueryPictIndexValuesReq); xRenderQueryPictIndexValuesReply *reply; xIndexValue *values; REQUEST_AT_LEAST_SIZE(xRenderQueryPictIndexValuesReq); pFormat = (PictFormatPtr) SecurityLookupIDByType (client, stuff->format, PictFormatType, SecurityReadAccess); if (!pFormat) { client->errorValue = stuff->format; return RenderErrBase + BadPictFormat; } if (pFormat->type != PictTypeIndexed) { client->errorValue = stuff->format; return BadMatch; } num = pFormat->index.nvalues; rlength = (sizeof (xRenderQueryPictIndexValuesReply) + num * sizeof(xIndexValue)); reply = (xRenderQueryPictIndexValuesReply *) xalloc (rlength); if (!reply) return BadAlloc; reply->type = X_Reply; reply->sequenceNumber = client->sequence; reply->length = (rlength - sizeof(xGenericReply)) >> 2; reply->numIndexValues = num; values = (xIndexValue *) (reply + 1); memcpy (reply + 1, pFormat->index.pValues, num * sizeof (xIndexValue)); if (client->swapped) { for (i = 0; i < num; i++) { swapl (&values[i].pixel, n); swaps (&values[i].red, n); swaps (&values[i].green, n); swaps (&values[i].blue, n); swaps (&values[i].alpha, n); } swaps (&reply->sequenceNumber, n); swapl (&reply->length, n); swapl (&reply->numIndexValues, n); } WriteToClient(client, rlength, (char *) reply); xfree(reply); return (client->noClientException); } static int ProcRenderQueryDithers (ClientPtr client) { return BadImplementation; } static int ProcRenderCreatePicture (ClientPtr client) { PicturePtr pPicture; DrawablePtr pDrawable; PictFormatPtr pFormat; int len; int error; REQUEST(xRenderCreatePictureReq); REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq); LEGAL_NEW_RESOURCE(stuff->pid, client); SECURITY_VERIFY_DRAWABLE(pDrawable, stuff->drawable, client, SecurityWriteAccess); pFormat = (PictFormatPtr) SecurityLookupIDByType (client, stuff->format, PictFormatType, SecurityReadAccess); if (!pFormat) { client->errorValue = stuff->format; return RenderErrBase + BadPictFormat; } if (pFormat->depth != pDrawable->depth) return BadMatch; len = client->req_len - (sizeof(xRenderCreatePictureReq) >> 2); if (Ones(stuff->mask) != len) return BadLength; pPicture = CreatePicture (stuff->pid, pDrawable, pFormat, stuff->mask, (XID *) (stuff + 1), client, &error); if (!pPicture) return error; nxagentCreatePicture(pPicture, stuff -> mask); if (!AddResource (stuff->pid, PictureType, (pointer)pPicture)) return BadAlloc; return Success; } static int ProcRenderChangePicture (ClientPtr client) { PicturePtr pPicture; REQUEST(xRenderChangePictureReq); int len; int error; REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq); VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess, RenderErrBase + BadPicture); len = client->req_len - (sizeof(xRenderChangePictureReq) >> 2); if (Ones(stuff->mask) != len) return BadLength; error = ChangePicture (pPicture, stuff->mask, (XID *) (stuff + 1), (DevUnion *) 0, client); nxagentChangePicture(pPicture, stuff->mask); return error; } static int ProcRenderSetPictureClipRectangles (ClientPtr client) { REQUEST(xRenderSetPictureClipRectanglesReq); PicturePtr pPicture; int nr; int result; REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq); VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess, RenderErrBase + BadPicture); /* * The original code used sizeof(xRenderChangePictureReq). * This was harmless, as both structures have the same size. * * nr = (client->req_len << 2) - sizeof(xRenderChangePictureReq); */ nr = (client->req_len << 2) - sizeof(xRenderSetPictureClipRectanglesReq); if (nr & 4) return BadLength; nr >>= 3; result = SetPictureClipRects (pPicture, stuff->xOrigin, stuff->yOrigin, nr, (xRectangle *) &stuff[1]); nxagentChangePictureClip (pPicture, CT_NONE, nr, (xRectangle *) &stuff[1], (int)stuff -> xOrigin, (int)stuff -> yOrigin); if (client->noClientException != Success) return(client->noClientException); else return(result); } static int ProcRenderFreePicture (ClientPtr client) { PicturePtr pPicture; REQUEST(xRenderFreePictureReq); REQUEST_SIZE_MATCH(xRenderFreePictureReq); VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityDestroyAccess, RenderErrBase + BadPicture); nxagentDestroyPicture(pPicture); FreeResource (stuff->picture, RT_NONE); return(client->noClientException); } static Bool PictOpValid (CARD8 op) { if (/*PictOpMinimum <= op && */ op <= PictOpMaximum) return TRUE; if (PictOpDisjointMinimum <= op && op <= PictOpDisjointMaximum) return TRUE; if (PictOpConjointMinimum <= op && op <= PictOpConjointMaximum) return TRUE; return FALSE; } /* * Check if both pictures have drawables which are * virtual pixmaps. See the corresponding define * in NXpicture.c */ #define NXAGENT_PICTURE_ALWAYS_POINTS_TO_VIRTUAL #ifdef NXAGENT_PICTURE_ALWAYS_POINTS_TO_VIRTUAL #define nxagentCompositePredicate(pSrc, pDst) TRUE #else /* * This is still under development. The final * goal is to let pictures point to the real * pixmaps instead of pointing to virtuals. */ int nxagentCompositePredicate(PicturePtr pSrc, PicturePtr pDst) { PixmapPtr pPixmap1; PixmapPtr pPixmap2; pPixmap1 = (pSrc -> pDrawable -> type == DRAWABLE_PIXMAP ? ((PixmapPtr) pSrc -> pDrawable) : NULL); pPixmap2 = (pDst -> pDrawable -> type == DRAWABLE_PIXMAP ? ((PixmapPtr) pDst -> pDrawable) : NULL); if (pPixmap1 == NULL || pPixmap2 == NULL) { #ifdef TEST fprintf(stderr, "nxagentCompositePredicate: Case 0.\n"); #endif return FALSE; } else { #ifdef TEST fprintf(stderr, "nxagentCompositePredicate: Case 1.\n"); #endif if (nxagentPixmapIsVirtual(pPixmap1) == 1 && nxagentPixmapIsVirtual(pPixmap2) == 1) { #ifdef TEST fprintf(stderr, "nxagentCompositePredicate: Case 2.\n"); #endif return TRUE; } } #ifdef TEST fprintf(stderr, "nxagentCompositePredicate: Case 3.\n"); #endif return FALSE; } #endif static int ProcRenderComposite (ClientPtr client) { PicturePtr pSrc, pMask, pDst; REQUEST(xRenderCompositeReq); REQUEST_SIZE_MATCH(xRenderCompositeReq); if (!PictOpValid (stuff->op)) { client->errorValue = stuff->op; return BadValue; } VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_ALPHA (pMask, stuff->mask, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); if (pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen || (pMask && pSrc->pDrawable->pScreen != pMask->pDrawable->pScreen)) return BadMatch; ValidatePicture (pSrc); if (pMask) ValidatePicture (pMask); ValidatePicture (pDst); #ifdef NXAGENT_PICTURE_ALWAYS_POINTS_TO_VIRTUAL if (nxagentCompositePredicate(pSrc, pDst)) { #ifdef TEST fprintf(stderr, "ProcRenderComposite: Going to composite with " "source at [%p] mask at [%p] and destination at [%p].\n", (void *) pSrc, (void *) pMask, (void *) pDst); #endif CompositePicture (stuff->op, pSrc, pMask, pDst, stuff->xSrc, stuff->ySrc, stuff->xMask, stuff->yMask, stuff->xDst, stuff->yDst, stuff->width, stuff->height); } #else if (pSrc -> pDrawable -> type == DRAWABLE_PIXMAP && pDst -> pDrawable -> type == DRAWABLE_PIXMAP && (!pMask || pMask -> pDrawable -> type == DRAWABLE_PIXMAP)) { PixmapPtr pVirtualPixmapSrc; PixmapPtr pVirtualPixmapDst; PixmapPtr pVirtualPixmapMask; PicturePtr pVirtualPictureSrc; PicturePtr pVirtualPictureDst; PicturePtr pVirtualPictureMask; pVirtualPixmapSrc = (PixmapPtr) pSrc -> pDrawable; pVirtualPictureSrc = nxagentPixmapPriv(pVirtualPixmapSrc) -> pPicture; pVirtualPixmapDst = (PixmapPtr) pDst -> pDrawable; pVirtualPictureDst = nxagentPixmapPriv(pVirtualPixmapDst) -> pPicture; if (pMask) { pVirtualPixmapMask = (PixmapPtr) pMask -> pDrawable; pVirtualPictureMask = nxagentPixmapPriv(pVirtualPixmapMask) -> pPicture; } else { pVirtualPixmapMask = NULL; pVirtualPictureMask = NULL; } if (pVirtualPictureSrc && pVirtualPictureDst) { #ifdef TEST fprintf(stderr, "ProcRenderComposite: Going to composite with " "source at [%p] mask at [%p] and destination at [%p].\n", (void *) pVirtualPixmapSrc, (void *) pVirtualPixmapMask, (void *) pVirtualPixmapDst); #endif CompositePicture (stuff->op, pVirtualPictureSrc, pVirtualPictureMask, pVirtualPictureDst, stuff->xSrc, stuff->ySrc, stuff->xMask, stuff->yMask, stuff->xDst, stuff->yDst, stuff->width, stuff->height); } } #endif nxagentComposite (stuff -> op, pSrc, pMask, pDst, stuff -> xSrc, stuff -> ySrc, stuff -> xMask, stuff -> yMask, stuff -> xDst, stuff -> yDst, stuff -> width, stuff -> height); return Success; } static int ProcRenderScale (ClientPtr client) { return BadImplementation; } static int ProcRenderTrapezoids (ClientPtr client) { int ntraps; PicturePtr pSrc, pDst; PictFormatPtr pFormat; REQUEST(xRenderTrapezoidsReq); REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq); if (!PictOpValid (stuff->op)) { client->errorValue = stuff->op; return BadValue; } VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); if (pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) return BadMatch; if (stuff->maskFormat) { pFormat = (PictFormatPtr) SecurityLookupIDByType (client, stuff->maskFormat, PictFormatType, SecurityReadAccess); if (!pFormat) { client->errorValue = stuff->maskFormat; return RenderErrBase + BadPictFormat; } } else pFormat = 0; ntraps = (client->req_len << 2) - sizeof (xRenderTrapezoidsReq); if (ntraps % sizeof (xTrapezoid)) return BadLength; ntraps /= sizeof (xTrapezoid); if (ntraps) { if (nxagentCompositePredicate(pSrc, pDst)) { CompositeTrapezoids (stuff->op, pSrc, pDst, pFormat, stuff->xSrc, stuff->ySrc, ntraps, (xTrapezoid *) &stuff[1]); } nxagentTrapezoids (stuff->op, pSrc, pDst, pFormat, stuff->xSrc, stuff->ySrc, ntraps, (xTrapezoid *) &stuff[1]); } return client->noClientException; } static int ProcRenderTriangles (ClientPtr client) { int ntris; PicturePtr pSrc, pDst; PictFormatPtr pFormat; REQUEST(xRenderTrianglesReq); REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq); if (!PictOpValid (stuff->op)) { client->errorValue = stuff->op; return BadValue; } VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); if (pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) return BadMatch; if (stuff->maskFormat) { pFormat = (PictFormatPtr) SecurityLookupIDByType (client, stuff->maskFormat, PictFormatType, SecurityReadAccess); if (!pFormat) { client->errorValue = stuff->maskFormat; return RenderErrBase + BadPictFormat; } } else pFormat = 0; ntris = (client->req_len << 2) - sizeof (xRenderTrianglesReq); if (ntris % sizeof (xTriangle)) return BadLength; ntris /= sizeof (xTriangle); if (ntris) CompositeTriangles (stuff->op, pSrc, pDst, pFormat, stuff->xSrc, stuff->ySrc, ntris, (xTriangle *) &stuff[1]); return client->noClientException; } static int ProcRenderTriStrip (ClientPtr client) { int npoints; PicturePtr pSrc, pDst; PictFormatPtr pFormat; REQUEST(xRenderTrianglesReq); REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq); if (!PictOpValid (stuff->op)) { client->errorValue = stuff->op; return BadValue; } VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); if (pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) return BadMatch; if (stuff->maskFormat) { pFormat = (PictFormatPtr) SecurityLookupIDByType (client, stuff->maskFormat, PictFormatType, SecurityReadAccess); if (!pFormat) { client->errorValue = stuff->maskFormat; return RenderErrBase + BadPictFormat; } } else pFormat = 0; npoints = ((client->req_len << 2) - sizeof (xRenderTriStripReq)); if (npoints & 4) return(BadLength); npoints >>= 3; if (npoints >= 3) CompositeTriStrip (stuff->op, pSrc, pDst, pFormat, stuff->xSrc, stuff->ySrc, npoints, (xPointFixed *) &stuff[1]); return client->noClientException; } static int ProcRenderTriFan (ClientPtr client) { int npoints; PicturePtr pSrc, pDst; PictFormatPtr pFormat; REQUEST(xRenderTrianglesReq); REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq); if (!PictOpValid (stuff->op)) { client->errorValue = stuff->op; return BadValue; } VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); if (pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) return BadMatch; if (stuff->maskFormat) { pFormat = (PictFormatPtr) SecurityLookupIDByType (client, stuff->maskFormat, PictFormatType, SecurityReadAccess); if (!pFormat) { client->errorValue = stuff->maskFormat; return RenderErrBase + BadPictFormat; } } else pFormat = 0; npoints = ((client->req_len << 2) - sizeof (xRenderTriStripReq)); if (npoints & 4) return(BadLength); npoints >>= 3; if (npoints >= 3) CompositeTriFan (stuff->op, pSrc, pDst, pFormat, stuff->xSrc, stuff->ySrc, npoints, (xPointFixed *) &stuff[1]); return client->noClientException; } static int ProcRenderColorTrapezoids (ClientPtr client) { return BadImplementation; } static int ProcRenderColorTriangles (ClientPtr client) { return BadImplementation; } static int ProcRenderTransform (ClientPtr client) { return BadImplementation; } static int ProcRenderCreateGlyphSet (ClientPtr client) { GlyphSetPtr glyphSet; PictFormatPtr format; int f; REQUEST(xRenderCreateGlyphSetReq); REQUEST_SIZE_MATCH(xRenderCreateGlyphSetReq); LEGAL_NEW_RESOURCE(stuff->gsid, client); format = (PictFormatPtr) SecurityLookupIDByType (client, stuff->format, PictFormatType, SecurityReadAccess); if (!format) { client->errorValue = stuff->format; return RenderErrBase + BadPictFormat; } switch (format->depth) { case 1: f = GlyphFormat1; break; case 4: f = GlyphFormat4; break; case 8: f = GlyphFormat8; break; case 16: f = GlyphFormat16; break; case 32: f = GlyphFormat32; break; default: return BadMatch; } if (format->type != PictTypeDirect) return BadMatch; glyphSet = AllocateGlyphSet (f, format); if (!glyphSet) return BadAlloc; if (!AddResource (stuff->gsid, GlyphSetType, (pointer)glyphSet)) return BadAlloc; nxagentCreateGlyphSet(glyphSet); return Success; } static int ProcRenderReferenceGlyphSet (ClientPtr client) { GlyphSetPtr glyphSet; REQUEST(xRenderReferenceGlyphSetReq); REQUEST_SIZE_MATCH(xRenderReferenceGlyphSetReq); LEGAL_NEW_RESOURCE(stuff->gsid, client); glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client, stuff->existing, GlyphSetType, SecurityWriteAccess); if (!glyphSet) { client->errorValue = stuff->existing; return RenderErrBase + BadGlyphSet; } glyphSet->refcnt++; nxagentReferenceGlyphSet(glyphSet); if (!AddResource (stuff->gsid, GlyphSetType, (pointer)glyphSet)) return BadAlloc; return client->noClientException; } #define NLOCALDELTA 64 #define NLOCALGLYPH 256 static int ProcRenderFreeGlyphSet (ClientPtr client) { GlyphSetPtr glyphSet; REQUEST(xRenderFreeGlyphSetReq); REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq); glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client, stuff->glyphset, GlyphSetType, SecurityDestroyAccess); if (!glyphSet) { client->errorValue = stuff->glyphset; return RenderErrBase + BadGlyphSet; } nxagentFreeGlyphSet(glyphSet); FreeResource (stuff->glyphset, RT_NONE); return client->noClientException; } typedef struct _GlyphNew { Glyph id; GlyphPtr glyph; } GlyphNewRec, *GlyphNewPtr; static int ProcRenderAddGlyphs (ClientPtr client) { GlyphSetPtr glyphSet; REQUEST(xRenderAddGlyphsReq); GlyphNewRec glyphsLocal[NLOCALGLYPH]; GlyphNewPtr glyphsBase, glyphs; GlyphPtr glyph = NULL; int remain, nglyphs; CARD32 *gids; xGlyphInfo *gi; CARD8 *bits; int size; int err = BadAlloc; int totSizeImages; REQUEST_AT_LEAST_SIZE(xRenderAddGlyphsReq); glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client, stuff->glyphset, GlyphSetType, SecurityWriteAccess); if (!glyphSet) { client->errorValue = stuff->glyphset; return RenderErrBase + BadGlyphSet; } nglyphs = stuff->nglyphs; if (nglyphs <= NLOCALGLYPH) glyphsBase = glyphsLocal; else { glyphsBase = (GlyphNewPtr) ALLOCATE_LOCAL (nglyphs * sizeof (GlyphNewRec)); if (!glyphsBase) return BadAlloc; } remain = (client->req_len << 2) - sizeof (xRenderAddGlyphsReq); glyphs = glyphsBase; totSizeImages = 0; gids = (CARD32 *) (stuff + 1); gi = (xGlyphInfo *) (gids + nglyphs); bits = (CARD8 *) (gi + nglyphs); remain -= (sizeof (CARD32) + sizeof (xGlyphInfo)) * nglyphs; while (remain >= 0 && nglyphs) { glyph = AllocateGlyph (gi, glyphSet->fdepth); if (!glyph) { err = BadAlloc; goto bail; } glyphs->glyph = glyph; glyphs->id = *gids; size = glyph->size - sizeof (xGlyphInfo); if (remain < size) break; memcpy ((CARD8 *) (glyph + 1), bits, size); if (size & 3) size += 4 - (size & 3); bits += size; totSizeImages += size; remain -= size; gi++; gids++; glyphs++; nglyphs--; } if (nglyphs || remain) { err = BadLength; goto bail; } nglyphs = stuff->nglyphs; if (!ResizeGlyphSet (glyphSet, nglyphs)) { err = BadAlloc; goto bail; } glyphs = glyphsBase; while (nglyphs--) AddGlyph (glyphSet, glyphs->glyph, glyphs->id); if (glyphsBase != glyphsLocal) DEALLOCATE_LOCAL (glyphsBase); return client->noClientException; bail: while (glyphs != glyphsBase) { --glyphs; xfree (glyphs->glyph); } if (glyphsBase != glyphsLocal) DEALLOCATE_LOCAL (glyphsBase); return err; } static int ProcRenderAddGlyphsFromPicture (ClientPtr client) { return BadImplementation; } static int ProcRenderFreeGlyphs (ClientPtr client) { REQUEST(xRenderFreeGlyphsReq); GlyphSetPtr glyphSet; int nglyph; CARD32 *gids; CARD32 glyph; REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq); glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client, stuff->glyphset, GlyphSetType, SecurityWriteAccess); if (!glyphSet) { client->errorValue = stuff->glyphset; return RenderErrBase + BadGlyphSet; } nglyph = ((client->req_len << 2) - sizeof (xRenderFreeGlyphsReq)) >> 2; gids = (CARD32 *) (stuff + 1); nxagentFreeGlyphs(glyphSet, gids, nglyph); while (nglyph-- > 0) { glyph = *gids++; if (!DeleteGlyph (glyphSet, glyph)) { client->errorValue = glyph; return RenderErrBase + BadGlyph; } } return client->noClientException; } typedef struct XGlyphElt8{ GlyphSet glyphset; _Xconst char *chars; int nchars; int xOff; int yOff; } XGlyphElt8; static int ProcRenderCompositeGlyphs (ClientPtr client) { GlyphSetPtr glyphSet; GlyphSet gs; PicturePtr pSrc, pDst; PictFormatPtr pFormat; GlyphListRec listsLocal[NLOCALDELTA]; GlyphListPtr lists, listsBase; GlyphPtr glyphsLocal[NLOCALGLYPH]; Glyph glyph; GlyphPtr *glyphs, *glyphsBase; xGlyphElt *elt; CARD8 *buffer, *end; int nglyph; int nlist; int space; int size; int n; XGlyphElt8 *elements, *elementsBase; REQUEST(xRenderCompositeGlyphsReq); REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq); switch (stuff->renderReqType) { default: size = 1; break; case X_RenderCompositeGlyphs16: size = 2; break; case X_RenderCompositeGlyphs32: size = 4; break; } if (!PictOpValid (stuff->op)) { client->errorValue = stuff->op; return BadValue; } VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); if (pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) return BadMatch; if (stuff->maskFormat) { pFormat = (PictFormatPtr) SecurityLookupIDByType (client, stuff->maskFormat, PictFormatType, SecurityReadAccess); if (!pFormat) { client->errorValue = stuff->maskFormat; return RenderErrBase + BadPictFormat; } } else pFormat = 0; glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client, stuff->glyphset, GlyphSetType, SecurityReadAccess); if (!glyphSet) { client->errorValue = stuff->glyphset; return RenderErrBase + BadGlyphSet; } buffer = (CARD8 *) (stuff + 1); end = (CARD8 *) stuff + (client->req_len << 2); nglyph = 0; nlist = 0; while (buffer + sizeof (xGlyphElt) < end) { elt = (xGlyphElt *) buffer; buffer += sizeof (xGlyphElt); if (elt->len == 0xff) { buffer += 4; } else { nlist++; nglyph += elt->len; space = size * elt->len; if (space & 3) space += 4 - (space & 3); buffer += space; } } if (nglyph <= NLOCALGLYPH) glyphsBase = glyphsLocal; else { glyphsBase = (GlyphPtr *) ALLOCATE_LOCAL (nglyph * sizeof (GlyphPtr)); if (!glyphsBase) return BadAlloc; } if (nlist <= NLOCALDELTA) listsBase = listsLocal; else { listsBase = (GlyphListPtr) ALLOCATE_LOCAL (nlist * sizeof (GlyphListRec)); if (!listsBase) return BadAlloc; } elementsBase = xalloc(nlist * sizeof(XGlyphElt8)); if (!elementsBase) return BadAlloc; buffer = (CARD8 *) (stuff + 1); glyphs = glyphsBase; lists = listsBase; elements = elementsBase; while (buffer + sizeof (xGlyphElt) < end) { elt = (xGlyphElt *) buffer; buffer += sizeof (xGlyphElt); if (elt->len == 0xff) { #ifdef DEBUG fprintf(stderr, "ProcRenderCompositeGlyphs: Glyphset change with base size [%d].\n", size); #endif if (buffer + sizeof (GlyphSet) < end) { gs = *(GlyphSet *) buffer; glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client, gs, GlyphSetType, SecurityReadAccess); if (!glyphSet) { client->errorValue = gs; if (glyphsBase != glyphsLocal) DEALLOCATE_LOCAL (glyphsBase); if (listsBase != listsLocal) DEALLOCATE_LOCAL (listsBase); return RenderErrBase + BadGlyphSet; } } buffer += 4; } else { lists->xOff = elt->deltax; lists->yOff = elt->deltay; lists->format = glyphSet->format; lists->len = 0; elements -> glyphset = glyphSet -> remoteID; elements -> chars = (char *) buffer; elements -> nchars = elt->len; elements -> xOff = elt->deltax; elements -> yOff = elt->deltay; n = elt->len; while (n--) { if (buffer + size <= end) { switch (size) { case 1: glyph = *((CARD8 *)buffer); break; case 2: glyph = *((CARD16 *)buffer); break; case 4: default: glyph = *((CARD32 *)buffer); break; } if ((*glyphs = FindGlyph (glyphSet, glyph))) { lists->len++; glyphs++; } } buffer += size; } space = size * elt->len; if (space & 3) buffer += 4 - (space & 3); lists++; elements++; } } if (buffer > end) return BadLength; /* * We need to know the glyphs extents to synchronize * the drawables involved in the composite text ope- * ration. Also we need to synchronize only the back- * ground of the text we are going to render, so the * operations on the framebuffer must be executed * after the X requests. */ if (pFormat != NULL) { nxagentGlyphsExtents = (BoxPtr) xalloc(sizeof(BoxRec)); miGlyphExtents(nlist, listsBase, glyphsBase, nxagentGlyphsExtents); } nxagentGlyphs(stuff -> op, pSrc, pDst, pFormat, stuff -> xSrc, stuff -> ySrc, nlist, elementsBase, size, glyphsBase); if (nxagentCompositePredicate(pSrc, pDst) == 1) { #ifdef TEST fprintf(stderr, "ProcRenderCompositeGlyphs: Going to composite glyphs with " "source at [%p] and destination at [%p].\n", (void *) pSrc, (void *) pDst); #endif CompositeGlyphs(stuff -> op, pSrc, pDst, pFormat, stuff -> xSrc, stuff -> ySrc, nlist, listsBase, glyphsBase); } if (nxagentGlyphsExtents != NullBox) { xfree(nxagentGlyphsExtents); nxagentGlyphsExtents = NullBox; } if (glyphsBase != glyphsLocal) DEALLOCATE_LOCAL (glyphsBase); if (listsBase != listsLocal) DEALLOCATE_LOCAL (listsBase); xfree(elementsBase); return client->noClientException; } static int ProcRenderFillRectangles (ClientPtr client) { PicturePtr pDst; int things; REQUEST(xRenderFillRectanglesReq); REQUEST_AT_LEAST_SIZE (xRenderFillRectanglesReq); if (!PictOpValid (stuff->op)) { client->errorValue = stuff->op; return BadValue; } VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); things = (client->req_len << 2) - sizeof(xRenderFillRectanglesReq); if (things & 4) return(BadLength); things >>= 3; CompositeRects (stuff->op, pDst, &stuff->color, things, (xRectangle *) &stuff[1]); ValidatePicture (pDst); nxagentCompositeRects(stuff -> op, pDst, &stuff -> color, things, (xRectangle *) &stuff[1]); return client->noClientException; } static void SetBit (unsigned char *line, int x, int bit) { unsigned char mask; if (screenInfo.bitmapBitOrder == LSBFirst) mask = (1 << (x & 7)); else mask = (0x80 >> (x & 7)); /* XXX assumes byte order is host byte order */ line += (x >> 3); if (bit) *line |= mask; else *line &= ~mask; } #define DITHER_DIM 2 static CARD32 orderedDither[DITHER_DIM][DITHER_DIM] = { { 1, 3, }, { 4, 2, }, }; #define DITHER_SIZE ((sizeof orderedDither / sizeof orderedDither[0][0]) + 1) static int ProcRenderCreateCursor (ClientPtr client) { REQUEST(xRenderCreateCursorReq); PicturePtr pSrc; ScreenPtr pScreen; unsigned short width, height; CARD32 *argbbits, *argb; unsigned char *srcbits, *srcline; unsigned char *mskbits, *mskline; int stride; int x, y; int nbytes_mono; CursorMetricRec cm; CursorPtr pCursor; CARD32 twocolor[3]; int ncolor; RealizeCursorProcPtr saveRealizeCursor; REQUEST_SIZE_MATCH (xRenderCreateCursorReq); LEGAL_NEW_RESOURCE(stuff->cid, client); VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, RenderErrBase + BadPicture); pScreen = pSrc->pDrawable->pScreen; width = pSrc->pDrawable->width; height = pSrc->pDrawable->height; if ( stuff->x > width || stuff->y > height ) return (BadMatch); argbbits = xalloc (width * height * sizeof (CARD32)); if (!argbbits) return (BadAlloc); stride = BitmapBytePad(width); nbytes_mono = stride*height; srcbits = (unsigned char *)xalloc(nbytes_mono); if (!srcbits) { xfree (argbbits); return (BadAlloc); } mskbits = (unsigned char *)xalloc(nbytes_mono); if (!mskbits) { xfree(argbbits); xfree(srcbits); return (BadAlloc); } bzero ((char *) mskbits, nbytes_mono); bzero ((char *) srcbits, nbytes_mono); if (pSrc->format == PICT_a8r8g8b8) { (*pScreen->GetImage) (pSrc->pDrawable, 0, 0, width, height, ZPixmap, 0xffffffff, (pointer) argbbits); } else { PixmapPtr pPixmap; PicturePtr pPicture; PictFormatPtr pFormat; int error; pFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8); if (!pFormat) { xfree (argbbits); xfree (srcbits); xfree (mskbits); return (BadImplementation); } pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 32); if (!pPixmap) { xfree (argbbits); xfree (srcbits); xfree (mskbits); return (BadAlloc); } pPicture = CreatePicture (0, &pPixmap->drawable, pFormat, 0, 0, client, &error); if (!pPicture) { xfree (argbbits); xfree (srcbits); xfree (mskbits); return error; } (*pScreen->DestroyPixmap) (pPixmap); CompositePicture (PictOpSrc, pSrc, 0, pPicture, 0, 0, 0, 0, 0, 0, width, height); (*pScreen->GetImage) (pPicture->pDrawable, 0, 0, width, height, ZPixmap, 0xffffffff, (pointer) argbbits); FreePicture (pPicture, 0); } /* * Check whether the cursor can be directly supported by * the core cursor code */ ncolor = 0; argb = argbbits; for (y = 0; ncolor <= 2 && y < height; y++) { for (x = 0; ncolor <= 2 && x < width; x++) { CARD32 p = *argb++; CARD32 a = (p >> 24); if (a == 0) /* transparent */ continue; if (a == 0xff) /* opaque */ { int n; for (n = 0; n < ncolor; n++) if (p == twocolor[n]) break; if (n == ncolor) twocolor[ncolor++] = p; } else ncolor = 3; } } /* * Convert argb image to two plane cursor */ srcline = srcbits; mskline = mskbits; argb = argbbits; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { CARD32 p = *argb++; if (ncolor <= 2) { CARD32 a = ((p >> 24)); SetBit (mskline, x, a != 0); SetBit (srcline, x, a != 0 && p == twocolor[0]); } else { CARD32 a = ((p >> 24) * DITHER_SIZE + 127) / 255; CARD32 i = ((CvtR8G8B8toY15(p) >> 7) * DITHER_SIZE + 127) / 255; CARD32 d = orderedDither[y&(DITHER_DIM-1)][x&(DITHER_DIM-1)]; /* Set mask from dithered alpha value */ SetBit(mskline, x, a > d); /* Set src from dithered intensity value */ SetBit(srcline, x, a > d && i <= d); } } srcline += stride; mskline += stride; } /* * Dither to white and black if the cursor has more than two colors */ if (ncolor > 2) { twocolor[0] = 0xff000000; twocolor[1] = 0xffffffff; } else { xfree (argbbits); argbbits = 0; } #define GetByte(p,s) (((p) >> (s)) & 0xff) #define GetColor(p,s) (GetByte(p,s) | (GetByte(p,s) << 8)) cm.width = width; cm.height = height; cm.xhot = stuff->x; cm.yhot = stuff->y; /* * This cursor uses RENDER, so we make sure * that it is allocated in a way that allows * the mi and dix layers to handle it but we * later create it on the server by mirror- * ing the RENDER operation we got from the * client. */ saveRealizeCursor = pScreen -> RealizeCursor; pScreen -> RealizeCursor = nxagentCursorSaveRenderInfo; pCursor = AllocCursorARGB (srcbits, mskbits, argbbits, &cm, GetColor(twocolor[0], 16), GetColor(twocolor[0], 8), GetColor(twocolor[0], 0), GetColor(twocolor[1], 16), GetColor(twocolor[1], 8), GetColor(twocolor[1], 0)); pScreen -> RealizeCursor = saveRealizeCursor; /* * Store into the private data members the * information needed to recreate it at * reconnection. This is done in two steps * as in the first step we don't have the * picture info. */ if (pCursor == NULL) { return BadAlloc; } nxagentCursorPostSaveRenderInfo(pCursor, pScreen, pSrc, stuff -> x, stuff -> y); nxagentRenderRealizeCursor(pScreen, pCursor); if (AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor)) return (client->noClientException); return BadAlloc; } static int ProcRenderSetPictureTransform (ClientPtr client) { REQUEST(xRenderSetPictureTransformReq); PicturePtr pPicture; int result; REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq); VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess, RenderErrBase + BadPicture); result = SetPictureTransform (pPicture, (PictTransform *) &stuff->transform); nxagentSetPictureTransform(pPicture, &stuff->transform); if (client->noClientException != Success) return(client->noClientException); else return(result); } static int ProcRenderQueryFilters (ClientPtr client) { REQUEST (xRenderQueryFiltersReq); DrawablePtr pDrawable; xRenderQueryFiltersReply *reply; int nbytesName; int nnames; ScreenPtr pScreen; PictureScreenPtr ps; int i, j; int len; int total_bytes; INT16 *aliases; char *names; REQUEST_SIZE_MATCH(xRenderQueryFiltersReq); SECURITY_VERIFY_DRAWABLE(pDrawable, stuff->drawable, client, SecurityReadAccess); pScreen = pDrawable->pScreen; nbytesName = 0; nnames = 0; ps = GetPictureScreenIfSet(pScreen); if (ps) { for (i = 0; i < ps->nfilters; i++) nbytesName += 1 + strlen (ps->filters[i].name); for (i = 0; i < ps->nfilterAliases; i++) nbytesName += 1 + strlen (ps->filterAliases[i].alias); nnames = ps->nfilters + ps->nfilterAliases; } len = ((nnames + 1) >> 1) + ((nbytesName + 3) >> 2); total_bytes = sizeof (xRenderQueryFiltersReply) + (len << 2); reply = (xRenderQueryFiltersReply *) xalloc (total_bytes); if (!reply) return BadAlloc; aliases = (INT16 *) (reply + 1); names = (char *) (aliases + ((nnames + 1) & ~1)); reply->type = X_Reply; reply->sequenceNumber = client->sequence; reply->length = len; reply->numAliases = nnames; reply->numFilters = nnames; if (ps) { /* fill in alias values */ for (i = 0; i < ps->nfilters; i++) aliases[i] = FilterAliasNone; for (i = 0; i < ps->nfilterAliases; i++) { for (j = 0; j < ps->nfilters; j++) if (ps->filterAliases[i].filter_id == ps->filters[j].id) break; if (j == ps->nfilters) { for (j = 0; j < ps->nfilterAliases; j++) if (ps->filterAliases[i].filter_id == ps->filterAliases[j].alias_id) { break; } if (j == ps->nfilterAliases) j = FilterAliasNone; else j = j + ps->nfilters; } aliases[i + ps->nfilters] = j; } /* fill in filter names */ for (i = 0; i < ps->nfilters; i++) { j = strlen (ps->filters[i].name); *names++ = j; strncpy (names, ps->filters[i].name, j); names += j; } /* fill in filter alias names */ for (i = 0; i < ps->nfilterAliases; i++) { j = strlen (ps->filterAliases[i].alias); *names++ = j; strncpy (names, ps->filterAliases[i].alias, j); names += j; } } if (client->swapped) { register int n; for (i = 0; i < (int)reply->numAliases; i++) { swaps (&aliases[i], n); } swaps(&reply->sequenceNumber, n); swapl(&reply->length, n); swapl(&reply->numAliases, n); swapl(&reply->numFilters, n); } WriteToClient(client, total_bytes, (char *) reply); xfree (reply); return(client->noClientException); } static int ProcRenderSetPictureFilter (ClientPtr client) { REQUEST (xRenderSetPictureFilterReq); PicturePtr pPicture; int result; xFixed *params; int nparams; char *name; REQUEST_AT_LEAST_SIZE (xRenderSetPictureFilterReq); VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess, RenderErrBase + BadPicture); name = (char *) (stuff + 1); params = (xFixed *) (name + ((stuff->nbytes + 3) & ~3)); nparams = ((xFixed *) stuff + client->req_len) - params; result = SetPictureFilter (pPicture, name, stuff->nbytes, params, nparams); nxagentSetPictureFilter(pPicture, name, stuff->nbytes, params, nparams); return result; } static int ProcRenderCreateAnimCursor (ClientPtr client) { REQUEST(xRenderCreateAnimCursorReq); CursorPtr *cursors; CARD32 *deltas; CursorPtr pCursor; int ncursor; xAnimCursorElt *elt; int i; int ret; REQUEST_AT_LEAST_SIZE(xRenderCreateAnimCursorReq); LEGAL_NEW_RESOURCE(stuff->cid, client); if (client->req_len & 1) return BadLength; ncursor = (client->req_len - (SIZEOF(xRenderCreateAnimCursorReq) >> 2)) >> 1; cursors = xalloc (ncursor * (sizeof (CursorPtr) + sizeof (CARD32))); if (!cursors) return BadAlloc; deltas = (CARD32 *) (cursors + ncursor); elt = (xAnimCursorElt *) (stuff + 1); for (i = 0; i < ncursor; i++) { cursors[i] = (CursorPtr)SecurityLookupIDByType(client, elt->cursor, RT_CURSOR, SecurityReadAccess); if (!cursors[i]) { xfree (cursors); client->errorValue = elt->cursor; return BadCursor; } deltas[i] = elt->delay; elt++; } ret = AnimCursorCreate (cursors, deltas, ncursor, &pCursor); xfree (cursors); if (ret != Success) return ret; for (i = 0; i < MAXSCREENS; i++) { pCursor -> devPriv[i] = NULL; } if (AddResource (stuff->cid, RT_CURSOR, (pointer)pCursor)) return client->noClientException; return BadAlloc; } static int ProcRenderDispatch (ClientPtr client) { int result; REQUEST(xReq); /* * Let the client fail if we are * hiding the RENDER extension. */ if (nxagentRenderTrap) { return BadRequest; } if (stuff->data < RenderNumberRequests) { /* * Set the nxagentGCTrap flag while * dispatching a render operation to * avoid reentrancy in GCOps.c. */ nxagentGCTrap = 1; result = (*ProcRenderVector[stuff->data]) (client); nxagentGCTrap = 0; return result; } else return BadRequest; } static int SProcRenderQueryVersion (ClientPtr client) { register int n; REQUEST(xRenderQueryVersionReq); swaps(&stuff->length, n); swapl(&stuff->majorVersion, n); swapl(&stuff->minorVersion, n); return (*ProcRenderVector[stuff->renderReqType])(client); } static int SProcRenderQueryPictFormats (ClientPtr client) { register int n; REQUEST(xRenderQueryPictFormatsReq); swaps(&stuff->length, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderQueryPictIndexValues (ClientPtr client) { register int n; REQUEST(xRenderQueryPictIndexValuesReq); swaps(&stuff->length, n); swapl(&stuff->format, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderQueryDithers (ClientPtr client) { return BadImplementation; } static int SProcRenderCreatePicture (ClientPtr client) { register int n; REQUEST(xRenderCreatePictureReq); swaps(&stuff->length, n); swapl(&stuff->pid, n); swapl(&stuff->drawable, n); swapl(&stuff->format, n); swapl(&stuff->mask, n); SwapRestL(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderChangePicture (ClientPtr client) { register int n; REQUEST(xRenderChangePictureReq); swaps(&stuff->length, n); swapl(&stuff->picture, n); swapl(&stuff->mask, n); SwapRestL(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderSetPictureClipRectangles (ClientPtr client) { register int n; REQUEST(xRenderSetPictureClipRectanglesReq); swaps(&stuff->length, n); swapl(&stuff->picture, n); SwapRestS(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderFreePicture (ClientPtr client) { register int n; REQUEST(xRenderFreePictureReq); swaps(&stuff->length, n); swapl(&stuff->picture, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderComposite (ClientPtr client) { register int n; REQUEST(xRenderCompositeReq); swaps(&stuff->length, n); swapl(&stuff->src, n); swapl(&stuff->mask, n); swapl(&stuff->dst, n); swaps(&stuff->xSrc, n); swaps(&stuff->ySrc, n); swaps(&stuff->xMask, n); swaps(&stuff->yMask, n); swaps(&stuff->xDst, n); swaps(&stuff->yDst, n); swaps(&stuff->width, n); swaps(&stuff->height, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderScale (ClientPtr client) { register int n; REQUEST(xRenderScaleReq); swaps(&stuff->length, n); swapl(&stuff->src, n); swapl(&stuff->dst, n); swapl(&stuff->colorScale, n); swapl(&stuff->alphaScale, n); swaps(&stuff->xSrc, n); swaps(&stuff->ySrc, n); swaps(&stuff->xDst, n); swaps(&stuff->yDst, n); swaps(&stuff->width, n); swaps(&stuff->height, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderTrapezoids (ClientPtr client) { register int n; REQUEST(xRenderTrapezoidsReq); REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq); swaps (&stuff->length, n); swapl (&stuff->src, n); swapl (&stuff->dst, n); swapl (&stuff->maskFormat, n); swaps (&stuff->xSrc, n); swaps (&stuff->ySrc, n); SwapRestL(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderTriangles (ClientPtr client) { register int n; REQUEST(xRenderTrianglesReq); REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq); swaps (&stuff->length, n); swapl (&stuff->src, n); swapl (&stuff->dst, n); swapl (&stuff->maskFormat, n); swaps (&stuff->xSrc, n); swaps (&stuff->ySrc, n); SwapRestL(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderTriStrip (ClientPtr client) { register int n; REQUEST(xRenderTriStripReq); REQUEST_AT_LEAST_SIZE(xRenderTriStripReq); swaps (&stuff->length, n); swapl (&stuff->src, n); swapl (&stuff->dst, n); swapl (&stuff->maskFormat, n); swaps (&stuff->xSrc, n); swaps (&stuff->ySrc, n); SwapRestL(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderTriFan (ClientPtr client) { register int n; REQUEST(xRenderTriFanReq); REQUEST_AT_LEAST_SIZE(xRenderTriFanReq); swaps (&stuff->length, n); swapl (&stuff->src, n); swapl (&stuff->dst, n); swapl (&stuff->maskFormat, n); swaps (&stuff->xSrc, n); swaps (&stuff->ySrc, n); SwapRestL(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderColorTrapezoids (ClientPtr client) { return BadImplementation; } static int SProcRenderColorTriangles (ClientPtr client) { return BadImplementation; } static int SProcRenderTransform (ClientPtr client) { return BadImplementation; } static int SProcRenderCreateGlyphSet (ClientPtr client) { register int n; REQUEST(xRenderCreateGlyphSetReq); swaps(&stuff->length, n); swapl(&stuff->gsid, n); swapl(&stuff->format, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderReferenceGlyphSet (ClientPtr client) { register int n; REQUEST(xRenderReferenceGlyphSetReq); swaps(&stuff->length, n); swapl(&stuff->gsid, n); swapl(&stuff->existing, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderFreeGlyphSet (ClientPtr client) { register int n; REQUEST(xRenderFreeGlyphSetReq); swaps(&stuff->length, n); swapl(&stuff->glyphset, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderAddGlyphs (ClientPtr client) { register int n; register unsigned int i; CARD32 *gids; void *end; xGlyphInfo *gi; REQUEST(xRenderAddGlyphsReq); swaps(&stuff->length, n); swapl(&stuff->glyphset, n); swapl(&stuff->nglyphs, n); if (stuff->nglyphs & 0xe0000000) return BadLength; end = (CARD8 *) stuff + (client->req_len << 2); gids = (CARD32 *) (stuff + 1); gi = (xGlyphInfo *) (gids + stuff->nglyphs); if ((char *) end - (char *) (gids + stuff->nglyphs) < 0) return BadLength; if ((char *) end - (char *) (gi + stuff->nglyphs) < 0) return BadLength; for (i = 0; i < stuff->nglyphs; i++) { swapl (&gids[i], n); swaps (&gi[i].width, n); swaps (&gi[i].height, n); swaps (&gi[i].x, n); swaps (&gi[i].y, n); swaps (&gi[i].xOff, n); swaps (&gi[i].yOff, n); } return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderAddGlyphsFromPicture (ClientPtr client) { return BadImplementation; } static int SProcRenderFreeGlyphs (ClientPtr client) { register int n; REQUEST(xRenderFreeGlyphsReq); swaps(&stuff->length, n); swapl(&stuff->glyphset, n); SwapRestL(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderCompositeGlyphs (ClientPtr client) { register int n; xGlyphElt *elt; CARD8 *buffer; CARD8 *end; int space; int i; int size; REQUEST(xRenderCompositeGlyphsReq); switch (stuff->renderReqType) { default: size = 1; break; case X_RenderCompositeGlyphs16: size = 2; break; case X_RenderCompositeGlyphs32: size = 4; break; } swaps(&stuff->length, n); swapl(&stuff->src, n); swapl(&stuff->dst, n); swapl(&stuff->maskFormat, n); swapl(&stuff->glyphset, n); swaps(&stuff->xSrc, n); swaps(&stuff->ySrc, n); buffer = (CARD8 *) (stuff + 1); end = (CARD8 *) stuff + (client->req_len << 2); while (buffer + sizeof (xGlyphElt) < end) { elt = (xGlyphElt *) buffer; buffer += sizeof (xGlyphElt); swaps (&elt->deltax, n); swaps (&elt->deltay, n); i = elt->len; if (i == 0xff) { swapl (buffer, n); buffer += 4; } else { space = size * i; switch (size) { case 1: buffer += i; break; case 2: while (i--) { swaps (buffer, n); buffer += 2; } break; case 4: while (i--) { swapl (buffer, n); buffer += 4; } break; } if (space & 3) buffer += 4 - (space & 3); } } return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderFillRectangles (ClientPtr client) { register int n; REQUEST(xRenderFillRectanglesReq); REQUEST_AT_LEAST_SIZE (xRenderFillRectanglesReq); swaps(&stuff->length, n); swapl(&stuff->dst, n); swaps(&stuff->color.red, n); swaps(&stuff->color.green, n); swaps(&stuff->color.blue, n); swaps(&stuff->color.alpha, n); SwapRestS(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderCreateCursor (ClientPtr client) { register int n; REQUEST(xRenderCreateCursorReq); REQUEST_SIZE_MATCH (xRenderCreateCursorReq); swaps(&stuff->length, n); swapl(&stuff->cid, n); swapl(&stuff->src, n); swaps(&stuff->x, n); swaps(&stuff->y, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderSetPictureTransform (ClientPtr client) { register int n; REQUEST(xRenderSetPictureTransformReq); REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq); swaps(&stuff->length, n); swapl(&stuff->picture, n); swapl(&stuff->transform.matrix11, n); swapl(&stuff->transform.matrix12, n); swapl(&stuff->transform.matrix13, n); swapl(&stuff->transform.matrix21, n); swapl(&stuff->transform.matrix22, n); swapl(&stuff->transform.matrix23, n); swapl(&stuff->transform.matrix31, n); swapl(&stuff->transform.matrix32, n); swapl(&stuff->transform.matrix33, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderQueryFilters (ClientPtr client) { register int n; REQUEST (xRenderQueryFiltersReq); REQUEST_SIZE_MATCH (xRenderQueryFiltersReq); swaps(&stuff->length, n); swapl(&stuff->drawable, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderSetPictureFilter (ClientPtr client) { register int n; REQUEST (xRenderSetPictureFilterReq); REQUEST_AT_LEAST_SIZE (xRenderSetPictureFilterReq); swaps(&stuff->length, n); swapl(&stuff->picture, n); swaps(&stuff->nbytes, n); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderCreateAnimCursor (ClientPtr client) { register int n; REQUEST (xRenderCreateAnimCursorReq); REQUEST_AT_LEAST_SIZE (xRenderCreateAnimCursorReq); swaps(&stuff->length, n); swapl(&stuff->cid, n); SwapRestL(stuff); return (*ProcRenderVector[stuff->renderReqType]) (client); } static int SProcRenderDispatch (ClientPtr client) { int result; REQUEST(xReq); /* * Let the client fail if we are * hiding the RENDER extension. */ if (nxagentRenderTrap) { return BadRequest; } if (stuff->data < RenderNumberRequests) { /* * Set the nxagentGCTrap flag while * dispatching a render operation to * avoid reentrancy in GCOps.c. */ nxagentGCTrap = 1; result = (*SProcRenderVector[stuff->data]) (client); nxagentGCTrap = 0; return result; } else return BadRequest; } #ifdef PANORAMIX #include "panoramiX.h" #include "panoramiXsrv.h" #define VERIFY_XIN_PICTURE(pPicture, pid, client, mode, err) {\ pPicture = SecurityLookupIDByType(client, pid, XRT_PICTURE, mode);\ if (!pPicture) { \ client->errorValue = pid; \ return err; \ } \ } #define VERIFY_XIN_ALPHA(pPicture, pid, client, mode, err) {\ if (pid == None) \ pPicture = 0; \ else { \ VERIFY_XIN_PICTURE(pPicture, pid, client, mode, err); \ } \ } \ int (*PanoramiXSaveRenderVector[RenderNumberRequests])(ClientPtr); unsigned long XRT_PICTURE; static int PanoramiXRenderCreatePicture (ClientPtr client) { REQUEST(xRenderCreatePictureReq); PanoramiXRes *refDraw, *newPict; int result = Success, j; REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq); if(!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass( client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess))) return BadDrawable; if(!(newPict = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes)))) return BadAlloc; newPict->type = XRT_PICTURE; newPict->info[0].id = stuff->pid; if (refDraw->type == XRT_WINDOW && stuff->drawable == WindowTable[0]->drawable.id) { newPict->u.pict.root = TRUE; } else newPict->u.pict.root = FALSE; for(j = 1; j < PanoramiXNumScreens; j++) newPict->info[j].id = FakeClientID(client->index); FOR_NSCREENS_BACKWARD(j) { stuff->pid = newPict->info[j].id; stuff->drawable = refDraw->info[j].id; result = (*PanoramiXSaveRenderVector[X_RenderCreatePicture]) (client); if(result != Success) break; } if (result == Success) AddResource(newPict->info[0].id, XRT_PICTURE, newPict); else xfree(newPict); return (result); } static int PanoramiXRenderChangePicture (ClientPtr client) { PanoramiXRes *pict; int result = Success, j; REQUEST(xRenderChangePictureReq); REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq); VERIFY_XIN_PICTURE(pict, stuff->picture, client, SecurityWriteAccess, RenderErrBase + BadPicture); FOR_NSCREENS_BACKWARD(j) { stuff->picture = pict->info[j].id; result = (*PanoramiXSaveRenderVector[X_RenderChangePicture]) (client); if(result != Success) break; } return (result); } static int PanoramiXRenderSetPictureClipRectangles (ClientPtr client) { REQUEST(xRenderSetPictureClipRectanglesReq); int result = Success, j; PanoramiXRes *pict; REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq); VERIFY_XIN_PICTURE(pict, stuff->picture, client, SecurityWriteAccess, RenderErrBase + BadPicture); FOR_NSCREENS_BACKWARD(j) { stuff->picture = pict->info[j].id; result = (*PanoramiXSaveRenderVector[X_RenderSetPictureClipRectangles]) (client); if(result != Success) break; } return (result); } static int PanoramiXRenderFreePicture (ClientPtr client) { PanoramiXRes *pict; int result = Success, j; REQUEST(xRenderFreePictureReq); REQUEST_SIZE_MATCH(xRenderFreePictureReq); client->errorValue = stuff->picture; VERIFY_XIN_PICTURE(pict, stuff->picture, client, SecurityDestroyAccess, RenderErrBase + BadPicture); FOR_NSCREENS_BACKWARD(j) { stuff->picture = pict->info[j].id; result = (*PanoramiXSaveRenderVector[X_RenderFreePicture]) (client); if(result != Success) break; } /* Since ProcRenderFreePicture is using FreeResource, it will free our resource for us on the last pass through the loop above */ return (result); } static int PanoramiXRenderComposite (ClientPtr client) { PanoramiXRes *src, *msk, *dst; int result = Success, j; xRenderCompositeReq orig; REQUEST(xRenderCompositeReq); REQUEST_SIZE_MATCH(xRenderCompositeReq); VERIFY_XIN_PICTURE (src, stuff->src, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_XIN_ALPHA (msk, stuff->mask, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); orig = *stuff; FOR_NSCREENS_FORWARD(j) { stuff->src = src->info[j].id; if (src->u.pict.root) { stuff->xSrc = orig.xSrc - panoramiXdataPtr[j].x; stuff->ySrc = orig.ySrc - panoramiXdataPtr[j].y; } stuff->dst = dst->info[j].id; if (dst->u.pict.root) { stuff->xDst = orig.xDst - panoramiXdataPtr[j].x; stuff->yDst = orig.yDst - panoramiXdataPtr[j].y; } if (msk) { stuff->mask = msk->info[j].id; if (msk->u.pict.root) { stuff->xMask = orig.xMask - panoramiXdataPtr[j].x; stuff->yMask = orig.yMask - panoramiXdataPtr[j].y; } } result = (*PanoramiXSaveRenderVector[X_RenderComposite]) (client); if(result != Success) break; } return result; } static int PanoramiXRenderCompositeGlyphs (ClientPtr client) { PanoramiXRes *src, *dst; int result = Success, j; REQUEST(xRenderCompositeGlyphsReq); xGlyphElt origElt, *elt; INT16 xSrc, ySrc; REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq); VERIFY_XIN_PICTURE (src, stuff->src, client, SecurityReadAccess, RenderErrBase + BadPicture); VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); if (client->req_len << 2 >= (sizeof (xRenderCompositeGlyphsReq) + sizeof (xGlyphElt))) { elt = (xGlyphElt *) (stuff + 1); origElt = *elt; xSrc = stuff->xSrc; ySrc = stuff->ySrc; FOR_NSCREENS_FORWARD(j) { stuff->src = src->info[j].id; if (src->u.pict.root) { stuff->xSrc = xSrc - panoramiXdataPtr[j].x; stuff->ySrc = ySrc - panoramiXdataPtr[j].y; } stuff->dst = dst->info[j].id; if (dst->u.pict.root) { elt->deltax = origElt.deltax - panoramiXdataPtr[j].x; elt->deltay = origElt.deltay - panoramiXdataPtr[j].y; } result = (*PanoramiXSaveRenderVector[stuff->renderReqType]) (client); if(result != Success) break; } } return result; } static int PanoramiXRenderFillRectangles (ClientPtr client) { PanoramiXRes *dst; int result = Success, j; REQUEST(xRenderFillRectanglesReq); char *extra; int extra_len; REQUEST_AT_LEAST_SIZE (xRenderFillRectanglesReq); VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess, RenderErrBase + BadPicture); extra_len = (client->req_len << 2) - sizeof (xRenderFillRectanglesReq); if (extra_len && (extra = (char *) ALLOCATE_LOCAL (extra_len))) { memcpy (extra, stuff + 1, extra_len); FOR_NSCREENS_FORWARD(j) { if (j) memcpy (stuff + 1, extra, extra_len); if (dst->u.pict.root) { int x_off = panoramiXdataPtr[j].x; int y_off = panoramiXdataPtr[j].y; if(x_off || y_off) { xRectangle *rects = (xRectangle *) (stuff + 1); int i = extra_len / sizeof (xRectangle); while (i--) { rects->x -= x_off; rects->y -= y_off; rects++; } } } stuff->dst = dst->info[j].id; result = (*PanoramiXSaveRenderVector[X_RenderFillRectangles]) (client); if(result != Success) break; } DEALLOCATE_LOCAL(extra); } return result; } void PanoramiXRenderInit (void) { int i; XRT_PICTURE = CreateNewResourceType (XineramaDeleteResource); for (i = 0; i < RenderNumberRequests; i++) PanoramiXSaveRenderVector[i] = ProcRenderVector[i]; /* * Stuff in Xinerama aware request processing hooks */ ProcRenderVector[X_RenderCreatePicture] = PanoramiXRenderCreatePicture; ProcRenderVector[X_RenderChangePicture] = PanoramiXRenderChangePicture; ProcRenderVector[X_RenderSetPictureClipRectangles] = PanoramiXRenderSetPictureClipRectangles; ProcRenderVector[X_RenderFreePicture] = PanoramiXRenderFreePicture; ProcRenderVector[X_RenderComposite] = PanoramiXRenderComposite; ProcRenderVector[X_RenderCompositeGlyphs8] = PanoramiXRenderCompositeGlyphs; ProcRenderVector[X_RenderCompositeGlyphs16] = PanoramiXRenderCompositeGlyphs; ProcRenderVector[X_RenderCompositeGlyphs32] = PanoramiXRenderCompositeGlyphs; ProcRenderVector[X_RenderFillRectangles] = PanoramiXRenderFillRectangles; } void PanoramiXRenderReset (void) { int i; for (i = 0; i < RenderNumberRequests; i++) ProcRenderVector[i] = PanoramiXSaveRenderVector[i]; } #endif /* PANORAMIX */ #endif /* #ifdef NXAGENT_UPGRADE */