/* $Xorg: cmap.c,v 1.5 2001/02/09 02:05:31 xorgcvs Exp $ */ /* Copyright 1996, 1998 The Open Group 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. The above copyright notice and this permission notice 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 NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP 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. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ /* * Copyright 1994 Network Computing Devices, 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 Network Computing Devices, Inc. not be * used in advertising or publicity pertaining to distribution of this * software without specific, written prior permission. * * THIS SOFTWARE IS PROVIDED `AS-IS'. NETWORK COMPUTING DEVICES, INC., * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT * LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE, OR NONINFRINGEMENT. IN NO EVENT SHALL NETWORK * COMPUTING DEVICES, INC., BE LIABLE FOR ANY DAMAGES WHATSOEVER, INCLUDING * SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, INCLUDING LOSS OF USE, DATA, * OR PROFITS, EVEN IF ADVISED OF THE POSSIBILITY THEREOF, AND REGARDLESS OF * WHETHER IN AN ACTION IN CONTRACT, TORT OR NEGLIGENCE, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ /* $XFree86: xc/programs/lbxproxy/di/cmap.c,v 1.7 2003/11/17 22:20:48 dawes Exp $ */ #include #include "assert.h" #include "misc.h" #include "lbx.h" #include "atomcache.h" #include "util.h" #include "tags.h" #include "colormap.h" #include "resource.h" #include "wire.h" #include "swap.h" #include "reqtype.h" #include "lbxext.h" static void LocalAllocColor (); static void FoundPixel (); static Bool grab_cmap_reply(); static Bool alloc_named_color_reply(); static Bool alloc_color_cells_reply(); static Bool alloc_color_planes_reply(); static Bool lookup_color_reply(); /* ------------------------------------------------------------------------- */ /* * ResolveColor scales down an rgb to the specified number of bits. */ void ResolveColor (pVisual, red, green, blue) LbxVisualPtr pVisual; CARD16 *red, *green, *blue; { int shift = 16 - pVisual->bitsPerRGB; unsigned lim = (1 << pVisual->bitsPerRGB) - 1; unsigned limr, limg, limb; switch (pVisual->class) { case PseudoColor: case DirectColor: case StaticColor: /* rescale to rgb bits */ *red = ((*red >> shift) * 65535) / lim; *green = ((*green >> shift) * 65535) / lim; *blue = ((*blue >> shift) * 65535) / lim; break; case GrayScale: /* rescale to gray then rgb bits */ *red = (30L * *red + 59L * *green + 11L * *blue) / 100; *blue = *green = *red = ((*red >> shift) * 65535) / lim; break; case StaticGray: limg = pVisual->colormapEntries - 1; /* rescale to gray then [0..limg] then [0..65535] then rgb bits */ *red = (30L * *red + 59L * *green + 11L * *blue) / 100; *red = ((((*red * (limg + 1))) >> 16) * 65535) / limg; *blue = *green = *red = ((*red >> shift) * 65535) / lim; break; case TrueColor: limr = NUMRED(pVisual) - 1; limg = NUMGREEN(pVisual) - 1; limb = NUMBLUE(pVisual) - 1; /* rescale to [0..limN] then [0..65535] then rgb bits */ *red = ((((((*red * (limr + 1)) >> 16) * 65535) / limr) >> shift) * 65535) / lim; *green = ((((((*green * (limg + 1)) >> 16) * 65535) / limg) >> shift) * 65535) / lim; *blue = ((((((*blue * (limb + 1)) >> 16) * 65535) / limb) >> shift) * 65535) / lim; break; } } void (* LbxResolveColor)( LbxVisualPtr /* pVisual */, CARD16* /* red */, CARD16* /* green */, CARD16* /* blue */ ) = ResolveColor; static Pixel find_cell(pent, num, rgb, channel) Entry *pent; int num; CARD32 rgb; int channel; { Pixel pixel, freep; freep = ~((Pixel)0); for (pixel = 0; pixel < num; pixel++, pent++) { if (pent->status == PIXEL_SHARED) { switch (channel) { case DoRed: if (pent->red == rgb) return pixel; break; case DoGreen: if (pent->green == rgb) return pixel; break; case DoBlue: if (pent->blue == rgb) return pixel; break; } } if (pent->status == PIXEL_FREE && freep == ~((Pixel)0)) freep = pixel; } return freep; } /* * Find a free pixel in the colormap. */ Pixel FindFreePixel (pmap, red, green, blue) ColormapPtr pmap; CARD32 red, green, blue; { Entry *pent; Pixel pixel, p; if (pmap->pVisual->class != DirectColor) { for (pixel = 0, pent = pmap->red; pixel < pmap->pVisual->colormapEntries; pixel++, pent++) { if (pent->status == PIXEL_FREE) return pixel; } return ~((Pixel)0); } p = find_cell(pmap->red, NUMRED(pmap->pVisual), red, DoRed); if (p == ~((Pixel)0)) return p; pixel = p << pmap->pVisual->offsetRed; p = find_cell(pmap->green, NUMGREEN(pmap->pVisual), green, DoGreen); if (p == ~((Pixel)0)) return p; pixel |= p << pmap->pVisual->offsetGreen; p = find_cell(pmap->blue, NUMBLUE(pmap->pVisual), blue, DoBlue); if (p == ~((Pixel)0)) return p; pixel |= p << pmap->pVisual->offsetBlue; return pixel; } Pixel (* LbxFindFreePixel)( ColormapPtr /* pmap */, CARD32 /* red */, CARD32 /* green */, CARD32 /* blue */ ) = FindFreePixel; typedef unsigned short BigNumUpper; typedef unsigned long BigNumLower; #define BIGNUMLOWERBITS 24 #define BIGNUMUPPERBITS 16 #define BIGNUMLOWER (1 << BIGNUMLOWERBITS) #define BIGNUMUPPER (1 << BIGNUMUPPERBITS) #define UPPERPART(i) ((i) >> BIGNUMLOWERBITS) #define LOWERPART(i) ((i) & (BIGNUMLOWER - 1)) typedef struct _bignum { BigNumUpper upper; BigNumLower lower; } BigNumRec, *BigNumPtr; #define BigNumGreater(x,y) (((x)->upper > (y)->upper) ||\ (((x)->upper == (y)->upper) &&\ ((x)->lower > (y)->lower))) #define UnsignedToBigNum(u,r) (((r)->upper = UPPERPART(u)), \ ((r)->lower = LOWERPART(u))) #define MaxBigNum(r) (((r)->upper = BIGNUMUPPER-1), \ ((r)->lower = BIGNUMLOWER-1)) static void BigNumAdd (x, y, r) BigNumPtr x, y, r; { BigNumLower lower, carry = 0; lower = x->lower + y->lower; if (lower >= BIGNUMLOWER) { lower -= BIGNUMLOWER; carry = 1; } r->lower = lower; r->upper = x->upper + y->upper + carry; } Entry * FindBestPixel(pmap, red, green, blue, channels) ColormapPtr pmap; CARD32 red, green, blue; int channels; { Entry *pent; int num; Entry *final; Pixel pixel; long dr, dg, db; unsigned long sq; BigNumRec minval, sum, temp; switch(channels) { case DoRed: pent = pmap->red; num = NUMRED(pmap->pVisual); break; case DoGreen: pent = pmap->green; num = NUMGREEN(pmap->pVisual); break; case DoBlue: pent = pmap->blue; num = NUMBLUE(pmap->pVisual); break; default: pent = pmap->red; num = pmap->pVisual->colormapEntries; break; } final = pent; MaxBigNum(&minval); /* look for the minimal difference */ for (pixel = 0; pixel < num; pent++, pixel++) { dr = dg = db = 0; switch(channels) { case DoRed: dr = pent->red - red; break; case DoGreen: dg = pent->green - green; break; case DoBlue: db = pent->blue - blue; break; default: dr = pent->red - red; dg = pent->green - green; db = pent->blue - blue; break; } sq = dr * dr; UnsignedToBigNum (sq, &sum); sq = dg * dg; UnsignedToBigNum (sq, &temp); BigNumAdd (&sum, &temp, &sum); sq = db * db; UnsignedToBigNum (sq, &temp); BigNumAdd (&sum, &temp, &sum); if (BigNumGreater (&minval, &sum)) { final = pent; minval = sum; } } return final; } Entry * (* LbxFindBestPixel)( ColormapPtr /* pmap */, CARD32 /* red */, CARD32 /* green */, CARD32 /* blue */, int /* channels */ ) = FindBestPixel; /* ------------------------------------------------------------------------- */ #define PIX_IN(ptr,is2,dst) \ if (is2) { \ dst = *ptr++ << 8; dst |= *ptr++; \ } else \ dst = *ptr++ #define RGB_IN(ptr,is2,lim,dst) \ if (is2) { \ dst = *ptr++ << 8; dst |= *ptr++; \ } else \ dst = (*ptr++ * 65535) / lim static CARD8 * DecodeChannel(pmap, pent, flags, channels, data) ColormapPtr pmap; Entry *pent; CARD8 flags; CARD8 channels; CARD8 *data; { Bool px2; Bool rgb2; CARD16 pixel1, pixel2; int i; int lim; CARD8 code; px2 = (flags & LBX_2BYTE_PIXELS) != 0; rgb2 = (flags & LBX_RGB_BITS_MASK) > 7; lim = (1 << ((flags & LBX_RGB_BITS_MASK) + 1)) - 1; /* * All pixels other than the ones specified in the GrabCmap reply * are implied to be free. Mark all the cells free now, and then * mark the cells specified in the GrabCmap reply either: * * PIXEL_PRIVATE - a read/write cell - proxy can't do local alloc * in this cell. We don't care about the contents. * PIXEL_SHARED - a read only cell that can be shared. */ for (i = 0; i < pmap->pVisual->colormapEntries; i++) { if ((pent[i].status == PIXEL_SHARED && pent[i].refcnt == 0) || (pent[i].status == PIXEL_PRIVATE && pent[i].server_ref)) pent[i].status = PIXEL_FREE; } while ((code = *data++)) { if (code == LBX_PIXEL_PRIVATE) { PIX_IN(data, px2, pixel1); pent[pixel1].pixel = pixel1; if (pent[pixel1].status != PIXEL_PRIVATE) pent[pixel1].server_ref = 1; pent[pixel1].status = PIXEL_PRIVATE; #ifdef COLOR_DEBUG fprintf (stderr, "Got PIXEL_PRIVATE, pixel = %d\n", pixel1); #endif } else if (code == LBX_PIXEL_RANGE_PRIVATE) { PIX_IN(data, px2, pixel1); PIX_IN(data, px2, pixel2); for (i = pixel1; i <= pixel2; i++) { pent[i].pixel = i; if (pent[i].status != PIXEL_PRIVATE) pent[i].server_ref = 1; pent[i].status = PIXEL_PRIVATE; } #ifdef COLOR_DEBUG fprintf (stderr, "Got PIXEL_RANGE_PRIVATE, pixels = %d...%d\n", pixel1, pixel2); #endif } else if (code == LBX_PIXEL_SHARED) { PIX_IN(data, px2, pixel1); pent[pixel1].pixel = pixel1; if (pent[pixel1].status != PIXEL_SHARED) pent[pixel1].refcnt = 0; pent[pixel1].status = PIXEL_SHARED; pent[pixel1].server_ref = 1; if (channels & DoRed) { RGB_IN(data, rgb2, lim, pent[pixel1].red); } if (channels & DoGreen) { RGB_IN(data, rgb2, lim, pent[pixel1].green); } if (channels & DoBlue) { RGB_IN(data, rgb2, lim, pent[pixel1].blue); } #ifdef COLOR_DEBUG fprintf (stderr, "Got PIXEL_SHARED, pixel = %d, rgb = (%d,%d,%d)\n", pixel1, pent[pixel1].red, pent[pixel1].green, pent[pixel1].blue); #endif } else if (code == LBX_PIXEL_RANGE_SHARED) { PIX_IN(data, px2, pixel1); PIX_IN(data, px2, pixel2); #ifdef COLOR_DEBUG fprintf (stderr, "Got PIXEL_RANGE_SHARED, pixels = %d...%d\n", pixel1, pixel2); #endif for (i = pixel1; i <= pixel2; i++) { pent[i].pixel = i; if (pent[i].status != PIXEL_SHARED) pent[i].refcnt = 0; pent[i].status = PIXEL_SHARED; pent[i].server_ref = 1; if (channels & DoRed) { RGB_IN(data, rgb2, lim, pent[i].red); } if (channels & DoGreen) { RGB_IN(data, rgb2, lim, pent[i].green); } if (channels & DoBlue) { RGB_IN(data, rgb2, lim, pent[i].blue); } #ifdef COLOR_DEBUG fprintf (stderr, " pixel = %d, rgb = (%d,%d,%d)\n", i, pent[i].red, pent[i].green, pent[i].blue); #endif } } else break; } return data; } static void GotColormapGrab (pmap, flags, data) ColormapPtr pmap; CARD8 flags; CARD8 *data; { pmap->grab_status = CMAP_GRABBED; if (flags & LBX_SMART_GRAB) { /* * We have a SMART GRAB : since this proxy last ungrabbed the * colormap, no color cell was alloc'd by an entity other than * this proxy (this includes other proxies as well as clients * directly connected to the X server without a proxy). * * We want to optimize this special case because a proxy may give * up a grab because it got a request that it could not handle * (e.g. AllocNamedColor or LookupColor). When it asks back for * the grab, there is no need for the server to send the colormap * state, because the proxy is already up to date on the state of * the colormap. * * In order for this to work, the following assumptions are made * about the proxy: * * - the proxy is kept up to date on all cell allocations made on its * behalf resulting from the following requests: AllocNamedColor, * AllocColorCells, AllocColorPlanes * - the proxy is kept up to date on all cells freed by any client * via the LbxFreeCell event. */ return; } if ((pmap->pVisual->class | DynamicClass) != DirectColor) DecodeChannel(pmap, pmap->red, flags, DoRed|DoGreen|DoBlue, data); else { data = DecodeChannel(pmap, pmap->red, flags, DoRed, data); data = DecodeChannel(pmap, pmap->green, flags, DoGreen, data); DecodeChannel(pmap, pmap->blue, flags, DoBlue, data); } } static void GrabCmap (client, pmap, red, green, blue, alloc_named, xred, xgreen, xblue) ClientPtr client; ColormapPtr pmap; CARD16 red, green, blue; Bool alloc_named; CARD16 xred, xgreen, xblue; { xLbxGrabCmapReq req; ReplyStuffPtr nr; #ifdef COLOR_DEBUG fprintf (stderr, "LbxGrabCmapReq: cmap = 0x%x, seq = 0x%x\n", pmap->id, LBXSequenceNumber(client)); fprintf (stderr, "suspending %s (%d, %d, %d)\n", alloc_named ? "AllocNamedColor" : "AllocColor", red, green, blue); #endif nr = NewReply(client, client->server->lbxReq, X_LbxGrabCmap, grab_cmap_reply); if (nr) { --nr->sequenceNumber; nr->request_info.lbxgrabcmap.pmap = pmap; nr->request_info.lbxgrabcmap.alloc_named = alloc_named; nr->request_info.lbxgrabcmap.vred = red; nr->request_info.lbxgrabcmap.vgreen = green; nr->request_info.lbxgrabcmap.vblue = blue; nr->request_info.lbxgrabcmap.xred = xred; nr->request_info.lbxgrabcmap.xgreen = xgreen; nr->request_info.lbxgrabcmap.xblue = xblue; } req.reqType = client->server->lbxReq; req.lbxReqType = X_LbxGrabCmap; req.length = sz_xLbxGrabCmapReq >> 2; req.cmap = pmap->id; if (client->swapped) SwapGrabCmap (&req); WriteReqToServer (client, sz_xLbxGrabCmapReq, (char *) &req, TRUE); pmap->grab_status = CMAP_GRAB_REQUESTED; } static Bool grab_cmap_reply(client, nr, data) ClientPtr client; ReplyStuffPtr nr; char *data; { xLbxGrabCmapReply *reply; Entry *pent; reply = (xLbxGrabCmapReply *) data; #ifdef COLOR_DEBUG fprintf (stderr, "LbxGrabCmapReply: cmap = 0x%x, seq = 0x%x, ", nr->request_info.lbxgrabcmap.pmap->id, reply->sequenceNumber); fprintf (stderr, "flags = %x\n", reply->flags); fprintf (stderr, "resuming %s (%d, %d, %d)\n", nr->request_info.lbxgrabcmap.alloc_named ? "AllocNamedColor" : "AllocColor", nr->request_info.lbxgrabcmap.vred, nr->request_info.lbxgrabcmap.vgreen, nr->request_info.lbxgrabcmap.vblue); #endif GotColormapGrab (nr->request_info.lbxgrabcmap.pmap, reply->flags, (CARD8 *) reply + sz_xLbxGrabCmapReplyHdr); /* * We suspended an AllocColor request so we could grab the colormap. * Now that the colormap is grabbed we resume handling the AllocColor. * We first check to see if the color is already allocated. */ FindPixel (client, nr->request_info.lbxgrabcmap.pmap, nr->request_info.lbxgrabcmap.vred, nr->request_info.lbxgrabcmap.vgreen, nr->request_info.lbxgrabcmap.vblue, &pent); if (pent) { /* * We found the pixel in the proxy's colormap. We can * immediately short circuit this AllocColor. */ FoundPixel (client, TRUE, nr->request_info.lbxgrabcmap.pmap, pent, nr->request_info.lbxgrabcmap.alloc_named, nr->request_info.lbxgrabcmap.xred, nr->request_info.lbxgrabcmap.xgreen, nr->request_info.lbxgrabcmap.xblue); } else { /* * We didn't find the pixel, but we just grabbed the color map, * so we can handle the color allocation locally now, then do * the short circuit. */ LocalAllocColor (client, TRUE, nr->request_info.lbxgrabcmap.pmap, nr->request_info.lbxgrabcmap.vred, nr->request_info.lbxgrabcmap.vgreen, nr->request_info.lbxgrabcmap.vblue, nr->request_info.lbxgrabcmap.alloc_named, nr->request_info.lbxgrabcmap.xred, nr->request_info.lbxgrabcmap.xgreen, nr->request_info.lbxgrabcmap.xblue); } return TRUE; } /* * Release the colormap currently grabbed by the proxy. */ void ReleaseCmap (client, pmap) ClientPtr client; ColormapPtr pmap; { xLbxReleaseCmapReq req; pmap->grab_status = CMAP_NOT_GRABBED; req.reqType = client->server->lbxReq; req.lbxReqType = X_LbxReleaseCmap; req.length = sz_xLbxReleaseCmapReq >> 2; req.cmap = pmap->id; /* write the request on the proxy control connection */ WriteReqToServer (client->server->serverClient, sz_xLbxReleaseCmapReq, (char *) &req, FALSE); } /* ------------------------------------------------------------------------- */ static void DoAllocColorReply (client, in_reply, red, green, blue, pixel) ClientPtr client; Bool in_reply; CARD16 red, green, blue; Pixel pixel; { /* * Prepare the AllocColor reply for the client. */ xAllocColorReply reply; reply.type = X_Reply; reply.length = 0; reply.sequenceNumber = LBXSequenceNumber(client); reply.red = red; reply.green = green; reply.blue = blue; reply.pixel = pixel; if (client->swapped) SwapAllocColorReply (&reply); if (LBXCacheSafe (client)) { /* * We can write the AllocColor reply now. */ if (!in_reply) FinishLBXRequest(client, REQ_REPLACE); WriteToClient (client, sizeof (xAllocColorReply), &reply); #ifdef LBX_STATS ac_good++; #endif } else { /* * We can't write the AllocColor reply now, we must first sync. */ if (!LBXCanDelayReply(client)) SendLbxSync (client); if (!in_reply) FinishLBXRequest(client, REQ_REPLACELATE); /* * Save the AllocColor reply. We will write it when the * LbxSync reply comes back. */ SaveReplyData (client, (xReply *) & reply, 0, NULL); } } static void DoAllocNamedColorReply (client, in_reply, red, green, blue, pixel, xred, xgreen, xblue) ClientPtr client; Bool in_reply; CARD16 red, green, blue; Pixel pixel; CARD16 xred, xgreen, xblue; { /* * Prepare the AllocNamedColor reply for the client. */ xAllocNamedColorReply reply; reply.type = X_Reply; reply.length = 0; reply.sequenceNumber = LBXSequenceNumber(client); reply.exactRed = xred; reply.exactGreen = xgreen; reply.exactBlue = xblue; reply.screenRed = red; reply.screenGreen = green; reply.screenBlue = blue; reply.pixel = pixel; if (client->swapped) SwapAllocNamedColorReply (&reply); if (LBXCacheSafe (client)) { /* * We can write the AllocColor reply now. */ if (!in_reply) FinishLBXRequest(client, REQ_REPLACE); WriteToClient (client, sizeof (xAllocNamedColorReply), &reply); #ifdef LBX_STATS anc_good++; #endif } else { /* * We can't write the AllocColor reply now, we must first sync. */ if (!LBXCanDelayReply(client)) SendLbxSync (client); if (!in_reply) FinishLBXRequest(client, REQ_REPLACELATE); /* * We can't write the AllocNamedColor reply now, we must first * sync. You might ask why we didn't just send the AllocNamedColor * request to the server? The answer is that if the colormap is * grabbed, we don't want to send the AllocNamedColor to the server * because that would force the proxy to give up control over the * colormap. So the proxy generates the reply on its own, but must * force a round trip sync before the reply is written. */ SaveReplyData (client, (xReply *) & reply, 0, NULL); #ifdef LBX_STATS anc_miss++; #endif } } /* * LocalAllocColor is called when the specified color is not already * allocated in the colormap, and the proxy has the colormap grabbed. * The proxy handles the AllocColor locally, and tells the server * what allocation it made. * * (red, green, blue) are actual rgb values, not requested ones - * they have already been put through ResolveColor. */ static void LocalAllocColor (client, in_reply, pmap, red, green, blue, alloc_named, xred, xgreen, xblue) ClientPtr client; Bool in_reply; ColormapPtr pmap; CARD16 red, green, blue; Bool alloc_named; CARD16 xred, xgreen, xblue; { Pixel pixel; /* * First find a free cell. */ pixel = (*LbxFindFreePixel) (pmap, red, green, blue); if (pixel == ~((Pixel)0)) { #ifdef COLOR_DEBUG fprintf(stderr, "alloc failed: (%d, %d, %d)\n", red, green, blue); #endif if (in_reply) WriteError(client, alloc_named ? X_AllocNamedColor : X_AllocColor, 0, pmap->id, BadAlloc); else SendErrorToClient(client, alloc_named ? X_AllocNamedColor : X_AllocColor, 0, pmap->id, BadAlloc); return; } #ifdef COLOR_DEBUG if (LBXCacheSafe (client)) fprintf (stderr, "X %s: short circuiting (allocating color locally):\n", alloc_named ? "AllocNamedColor" : "AllocColor"); else fprintf (stderr, "X %s: allocating color locally, but need Sync:\n", alloc_named ? "AllocNamedColor" : "AllocColor"); fprintf (stderr, " seq = 0x%x, cmap = 0x%x, pixel = %d, rgb = (%d,%d,%d)\n", LBXSequenceNumber(client), pmap->id, pixel, red, green, blue); #endif /* * Now handle the X AllocColor reply to the client. */ if (alloc_named) DoAllocNamedColorReply (client, in_reply, red, green, blue, pixel, xred, xgreen, xblue); else DoAllocColorReply (client, in_reply, red, green, blue, pixel); /* * Store the rgb in the cell. */ StorePixel (client, pmap, red, green, blue, pixel, FALSE); } static void FoundPixel (client, in_reply, pmap, pent, alloc_named, xred, xgreen, xblue) ClientPtr client; Bool in_reply; ColormapPtr pmap; Entry *pent; Bool alloc_named; CARD16 xred, xgreen, xblue; { #ifdef COLOR_DEBUG if (LBXCacheSafe (client)) fprintf (stderr, "X %s: short circuiting (color already exists):\n", alloc_named ? "AllocNamedColor" : "AllocColor"); else { fprintf (stderr, "X %s: color already exists locally, but need Sync:\n", alloc_named ? "AllocNamedColor" : "AllocColor"); } fprintf (stderr, " seq = 0x%x, cmap = 0x%x, pixel = %d, rgb = (%d,%d,%d)\n", LBXSequenceNumber(client), pmap->id, pent->pixel, pent->red, pent->green, pent->blue); #endif /* * Now handle the X AllocColor reply to the client. */ if (alloc_named) DoAllocNamedColorReply (client, in_reply, pent->red, pent->green, pent->blue, pent->pixel, xred, xgreen, xblue); else DoAllocColorReply (client, in_reply, pent->red, pent->green, pent->blue, pent->pixel); /* * We found a match. Increment our ref count and tell the * server to bump up its own ref count. */ IncrementPixel (client, pmap, pent, FALSE); } /* ------------------------------------------------------------------------- */ int ProcLBXCreateColormap(client) ClientPtr client; { REQUEST(xCreateColormapReq); Colormap cmap; VisualID vis; char n; /* AllocAll are read/write, so ignore */ if (stuff->alloc) { cmap = stuff->mid; vis = stuff->visual; if (client->swapped) { swapl(&cmap, n); swapl(&vis, n); } CreateColormap(client, cmap, vis); } return ProcStandardRequest(client); } static ColormapPtr create_colormap(cmap, visual) Colormap cmap; VisualID visual; { ColormapPtr pmap; LbxVisualPtr pvis; int tsize, csize; Pixel **pptr; pvis = GetVisual(visual); csize = pvis->colormapEntries; tsize = (csize * sizeof(Entry)) + (MAXCLIENTS * sizeof(Pixel *)) + (MAXCLIENTS * sizeof(int)); if ((pvis->class | DynamicClass) == DirectColor) tsize *= 3; tsize += sizeof(ColormapRec); pmap = (ColormapPtr) xalloc(tsize); if (!pmap) return pmap; bzero((char *) pmap, tsize); pmap->id = cmap; pmap->pVisual = pvis; pmap->grab_status = CMAP_NOT_GRABBED; pmap->red = (Entry *) ((char *) pmap + sizeof(ColormapRec)); pmap->clientPixelsRed = (Pixel **) ((char *) pmap->red + (csize * sizeof(Entry))); pmap->numPixelsRed = (int *) ((char *) pmap->clientPixelsRed + (MAXCLIENTS * sizeof(Pixel *))); bzero((char *) pmap->red, (csize * sizeof(Entry))); bzero((char *) pmap->numPixelsRed, (MAXCLIENTS * sizeof(int))); for (pptr = &pmap->clientPixelsRed[MAXCLIENTS]; --pptr >= pmap->clientPixelsRed; ) *pptr = (Pixel *) NULL; if ((pvis->class | DynamicClass) != DirectColor) { pmap->green = NULL; pmap->numPixelsGreen = NULL; pmap->clientPixelsGreen = NULL; pmap->blue = NULL; pmap->numPixelsBlue = NULL; pmap->clientPixelsBlue = NULL; return pmap; } pmap->green = (Entry *) ((char *) pmap->numPixelsRed + (MAXCLIENTS * sizeof(int))); pmap->clientPixelsGreen = (Pixel **) ((char *) pmap->green + (csize * sizeof(Entry))); pmap->numPixelsGreen = (int *) ((char *) pmap->clientPixelsGreen + (MAXCLIENTS * sizeof(Pixel *))); bzero((char *) pmap->green, (csize * sizeof(Entry))); bzero((char *) pmap->numPixelsGreen, (MAXCLIENTS * sizeof(int))); for (pptr = &pmap->clientPixelsGreen[MAXCLIENTS]; --pptr >= pmap->clientPixelsGreen; ) *pptr = (Pixel *) NULL; pmap->blue = (Entry *) ((char *) pmap->numPixelsGreen + (MAXCLIENTS * sizeof(int))); pmap->clientPixelsBlue = (Pixel **) ((char *) pmap->blue + (csize * sizeof(Entry))); pmap->numPixelsBlue = (int *) ((char *) pmap->clientPixelsBlue + (MAXCLIENTS * sizeof(Pixel *))); bzero((char *) pmap->blue, (csize * sizeof(Entry))); bzero((char *) pmap->numPixelsBlue, (MAXCLIENTS * sizeof(int))); for (pptr = &pmap->clientPixelsBlue[MAXCLIENTS]; --pptr >= pmap->clientPixelsBlue; ) *pptr = (Pixel *) NULL; return pmap; } /* ARGSUSED */ Bool CreateColormap(client, cmap, visual) ClientPtr client; Colormap cmap; VisualID visual; { ColormapPtr pmap; pmap = create_colormap(cmap, visual); if (!pmap) return FALSE; return AddResource(client, cmap, RT_COLORMAP, (pointer) pmap); } /* ------------------------------------------------------------------------- */ int ProcLBXFreeColormap(client) ClientPtr client; { REQUEST(xResourceReq); Colormap cmap; char n; cmap = stuff->id; if (client->swapped) { swapl(&cmap, n); } FreeColormap(client, cmap); return ProcStandardRequest(client); } /* ARGSUSED */ Bool FreeColormap(client, cmap) ClientPtr client; Colormap cmap; { ColormapPtr pmap; pmap = (ColormapPtr) LookupIDByType(client, cmap, RT_COLORMAP); if (!pmap) return FALSE; FreeResource(client, cmap, RT_NONE); return TRUE; } /* ------------------------------------------------------------------------- */ /* * cop out: don't try to track the new colormap */ int ProcLBXCopyColormapAndFree(client) ClientPtr client; { REQUEST(xCopyColormapAndFreeReq); Colormap srcmap; ColormapPtr pmap; char n; srcmap = stuff->srcCmap; if (client->swapped) { swapl(&srcmap, n); } pmap = (ColormapPtr) LookupIDByType(client, srcmap, RT_COLORMAP); if (pmap) FreeAllClientPixels(pmap, client->index); return ProcStandardRequest(client); } /* ------------------------------------------------------------------------- */ int ProcLBXFreeColors(client) ClientPtr client; { REQUEST(xFreeColorsReq); int num; Pixel *pixels; CARD32 mask; Colormap cmap; Bool freepix = FALSE; int n; CARD16 len; ColormapPtr pmap; mask = stuff->planeMask; cmap = stuff->cmap; len = stuff->length; if (client->swapped) { swapl(&cmap, n); swapl(&mask, n); swaps(&len, n); } pmap = (ColormapPtr) LookupIDByType(client, cmap, RT_COLORMAP); if (!pmap) return ProcStandardRequest(client); num = ((len << 2) - sizeof(xFreeColorsReq)) >> 2; if (client->swapped) { pixels = (Pixel *) ALLOCATE_LOCAL(num * sizeof(Pixel)); if (pixels) { memcpy((char *) pixels, (char *) &stuff[1], (num * sizeof(Pixel))); SwapLongs((CARD32 *) pixels, num); } freepix = TRUE; } else pixels = (Pixel *) &stuff[1]; #ifdef COLOR_DEBUG fprintf(stderr, "freeing on cmap 0x%x mask: %d pixels:", cmap, mask); for (n = 0; n < num; n++) fprintf(stderr, " %d", pixels[n]); fprintf(stderr, "\n"); #endif FreePixels(client, pmap, num, pixels, mask); if (freepix) DEALLOCATE_LOCAL(pixels); return ProcStandardRequest(client); } /* ------------------------------------------------------------------------- */ int ProcLBXAllocColor(client) ClientPtr client; { REQUEST(xAllocColorReq); Entry *pent; Colormap cmap; ColormapPtr pmap; CARD16 red, green, blue; char n; cmap = stuff->cmap; if (client->swapped) swapl(&cmap, n); pmap = (ColormapPtr) LookupIDByType (client, cmap, RT_COLORMAP); if (!pmap) return ProcStandardRequest(client); red = stuff->red; green = stuff->green; blue = stuff->blue; if (client->swapped) { swaps(&red, n); swaps(&green, n); swaps(&blue, n); } /* * Resolve the color (requested rgb -> actual rgb) */ (*LbxResolveColor)(pmap->pVisual, &red, &green, &blue); /* * Search for the pixel in the proxy's colormap. */ FindPixel (client, pmap, red, green, blue, &pent); if (pent && (pent->refcnt || pmap->grab_status == CMAP_GRABBED)) { /* * We found the pixel in the proxy's colormap. We can * short circuit this AllocColor. */ FoundPixel (client, FALSE, pmap, pent, FALSE, 0, 0, 0); } else if (pmap->grab_status == CMAP_GRABBED) { /* * The color map is already grabbed by the proxy, so we * can handle the AllocColor locally now. */ LocalAllocColor(client, FALSE, pmap, red, green, blue, FALSE, 0, 0, 0); } else { /* * The proxy must first grab the color map. Then it can * handle the AllocColor. */ FinishLBXRequest(client, REQ_REPLACELATE); GrabCmap(client, pmap, red, green, blue, FALSE, 0, 0, 0); } return Success; } /* ------------------------------------------------------------------------- */ int ProcLBXAllocNamedColor(client) ClientPtr client; { REQUEST(xAllocNamedColorReq); Entry *pent; RGBEntryPtr rgbe; ReplyStuffPtr nr; CARD16 nbytes; Colormap cmap; ColormapPtr pmap; char n; cmap = stuff->cmap; nbytes = stuff->nbytes; if (client->swapped) { swapl(&cmap, n); swaps(&nbytes, n); } pmap = (ColormapPtr) LookupIDByType (client, cmap, RT_COLORMAP); if (nbytes > MAX_COLORNAME_LENGTH || !pmap) return ProcStandardRequest(client); pent = NULL; rgbe = FindColorName(client->server, (char *) &stuff[1], nbytes, pmap->pVisual); if (rgbe) { #ifdef COLOR_DEBUG fprintf(stderr, "looking for %.*s = (%d,%d,%d)\n", nbytes, (char *)&stuff[1], rgbe->vred, rgbe->vgreen, rgbe->vblue); #endif FindPixel (client, pmap, rgbe->vred, rgbe->vgreen, rgbe->vblue, &pent); } if (pent && (pent->refcnt || pmap->grab_status == CMAP_GRABBED)) { FoundPixel (client, FALSE, pmap, pent, TRUE, rgbe->xred, rgbe->xgreen, rgbe->xblue); } else if (rgbe) { if (pmap->grab_status == CMAP_GRABBED) { /* * The color map is already grabbed by the proxy, so we * can handle the AllocNamedColor locally now. */ LocalAllocColor (client, FALSE, pmap, rgbe->vred, rgbe->vgreen, rgbe->vblue, TRUE, rgbe->xred, rgbe->xgreen, rgbe->xblue); } else { FinishLBXRequest(client, REQ_REPLACELATE); GrabCmap(client, pmap, rgbe->vred, rgbe->vgreen, rgbe->vblue, TRUE, rgbe->xred, rgbe->xgreen, rgbe->xblue); } } else { /* * We can't short circuit the AllocNamedColor request. * The proxy will need control over the colormap to handle * this request, so rather than wait for the server to ask * the proxy to release the colormap, we release it now. */ if (pmap->grab_status == CMAP_GRABBED && (pmap->pVisual->class & DynamicClass)) ReleaseCmap (client, pmap); /* * We need to catch the AllocNamedColor reply so we can cache * the results for future short circuiting. */ nr = NewReply(client, X_AllocNamedColor, 0, alloc_named_color_reply); if (!nr) return ProcStandardRequest(client); nr->request_info.xallocnamedcolor.pmap = pmap; strncpy(nr->request_info.xallocnamedcolor.name, (char *) &stuff[1], nbytes); nr->request_info.xallocnamedcolor.namelen = nbytes; #ifdef COLOR_DEBUG fprintf (stderr, "X AllocNamedColor: could not short circuit\n"); fprintf (stderr, " seq = 0x%x, cmap = 0x%x\n", LBXSequenceNumber(client), cmap); #endif #ifdef LBX_STATS anc_miss++; #endif return ProcStandardRequest(client); } return Success; } static Bool alloc_named_color_reply(client, nr, data) ClientPtr client; ReplyStuffPtr nr; char *data; { xAllocNamedColorReply *reply; Pixel pixel; char n; RGBEntryRec rgbe; reply = (xAllocNamedColorReply *) data; rgbe.xred = reply->exactRed; rgbe.xgreen = reply->exactGreen; rgbe.xblue = reply->exactBlue; rgbe.vred = reply->screenRed; rgbe.vgreen = reply->screenGreen; rgbe.vblue = reply->screenBlue; pixel = reply->pixel; if (client->swapped) { swapl(&pixel, n); swaps(&rgbe.xred, n); swaps(&rgbe.xgreen, n); swaps(&rgbe.xblue, n); swaps(&rgbe.vred, n); swaps(&rgbe.vgreen, n); swaps(&rgbe.vblue, n); } #ifdef COLOR_DEBUG fprintf (stderr, "X AllocNamedColorReply: caching results\n"); fprintf (stderr, "pixel = %d, rgb = (%d,%d,%d)\n", pixel, rgbe.vred, rgbe.vgreen, rgbe.vblue); #endif AddColorName(client->server, nr->request_info.xallocnamedcolor.name, nr->request_info.xallocnamedcolor.namelen, &rgbe); return StorePixel(client, nr->request_info.xallocnamedcolor.pmap, rgbe.vred, rgbe.vgreen, rgbe.vblue, pixel, TRUE); } /* ------------------------------------------------------------------------- */ int ProcLBXAllocColorCells(client) ClientPtr client; { REQUEST(xAllocColorCellsReq); ReplyStuffPtr nr; Colormap cmap; ColormapPtr pmap; char n; cmap = stuff->cmap; if (client->swapped) swapl(&cmap, n); pmap = (ColormapPtr) LookupIDByType (client, cmap, RT_COLORMAP); if (!pmap) return ProcStandardRequest(client); if (!(pmap->pVisual->class & DynamicClass)) return BadAlloc; /* * We don't short circuit AllocColorCells requests. * The server will need control over the colormap to handle * this request, so rather than wait for the server to ask * the proxy to release the colormap, we release it now. */ if (pmap->grab_status == CMAP_GRABBED) ReleaseCmap (client, pmap); /* * The proxy needs to keep track of all read/write cells allocated * for its own clients. By doing this, we can optimize the special * case of GrabCmapReply with smartGrab = TRUE. This means * that the proxy asked back for a grab that it temporarily gave up * to the server, and no other client or proxy did a color allocation * in the colormap. */ nr = NewReply(client, X_AllocColorCells, 0, alloc_color_cells_reply); if (nr) nr->request_info.xalloccolorcells.pmap = pmap; return ProcStandardRequest(client); } static Bool alloc_color_cells_reply(client, nr, data) ClientPtr client; ReplyStuffPtr nr; char *data; { xAllocColorCellsReply *reply; CARD16 nPixels, nMasks; CARD32 *pixels, *masks; ColormapPtr pmap; int i, j, k; char n; reply = (xAllocColorCellsReply *) data; pmap = nr->request_info.xalloccolorcells.pmap; #ifdef COLOR_DEBUG fprintf (stderr, "AllocColorCells on cmap 0x%x:", nr->request_info.xalloccolorcells.pmap->id); #endif nPixels = reply->nPixels; nMasks = reply->nMasks; if (client->swapped) { swaps(&nPixels, n); swaps(&nMasks, n); pixels = (CARD32 *) xalloc (nPixels * sizeof (CARD32)); masks = (CARD32 *) xalloc (nMasks * sizeof (CARD32)); memcpy (pixels, (char *) (reply + 1), nPixels * sizeof (CARD32)); memcpy (masks, ((char *) (reply + 1)) + nPixels * sizeof (CARD32), nMasks * sizeof (CARD32)); for (i = 0; i < nPixels; i++) swapl (&pixels[i], n); for (i = 0; i < nMasks; i++) swapl (&masks[i], n); } else { pixels = (CARD32 *) (reply + 1); masks = pixels + nPixels; } for (i = 0; i < nPixels; i++) for (j = 0; j < (1 << nMasks); j++) { CARD32 pixel, plane_mask = 0; int bits = j; for (k = 0; k < nMasks; k++) { if (bits & 1) plane_mask |= masks[k]; bits >>= 1; } pixel = pixels[i] | plane_mask; AllocCell(client, pmap, pixel); #ifdef COLOR_DEBUG fprintf (stderr, " %d", pixel); #endif } #ifdef COLOR_DEBUG fprintf (stderr, "\n"); #endif if (client->swapped) { xfree (pixels); xfree (masks); } return TRUE; } /* ------------------------------------------------------------------------- */ int ProcLBXAllocColorPlanes(client) ClientPtr client; { REQUEST(xAllocColorPlanesReq); ReplyStuffPtr nr; Colormap cmap; ColormapPtr pmap; char n; cmap = stuff->cmap; if (client->swapped) swapl(&cmap, n); pmap = (ColormapPtr) LookupIDByType (client, cmap, RT_COLORMAP); if (!pmap) return ProcStandardRequest(client); if (!(pmap->pVisual->class & DynamicClass)) return BadAlloc; /* * We don't short circuit AllocColorPlanes requests. * The server will need control over the colormap to handle * this request, so rather than wait for the server to ask * the proxy to release the colormap, we release it now. */ if (pmap->grab_status == CMAP_GRABBED) ReleaseCmap (client, pmap); /* * The proxy needs to keep track of all read/write cells allocated * for its own clients. By doing this, we can optimize the special * case of GrabCmapReply with smartGrab = TRUE. This means * that the proxy asked back for a grab that it temporarily gave up * to the server, and no other client or proxy did a color allocation * in the colormap. */ nr = NewReply(client, X_AllocColorPlanes, 0, alloc_color_planes_reply); if (nr) nr->request_info.xalloccolorplanes.pmap = pmap; return ProcStandardRequest(client); } static Bool alloc_color_planes_reply(client, nr, data) ClientPtr client; ReplyStuffPtr nr; char *data; { xAllocColorPlanesReply *reply; CARD32 redMask, greenMask, blueMask, mask; CARD16 nPixels; CARD32 *pixels; ColormapPtr pmap; int i; char n; reply = (xAllocColorPlanesReply *) data; pmap = nr->request_info.xalloccolorplanes.pmap; nPixels = reply->nPixels; redMask = reply->redMask; greenMask = reply->greenMask; blueMask = reply->blueMask; if (client->swapped) { swaps(&nPixels, n); swapl(&redMask, n); swapl(&greenMask, n); swapl(&blueMask, n); pixels = (CARD32 *) xalloc (nPixels * sizeof (CARD32)); memcpy (pixels, (char *) (reply + 1), nPixels * sizeof (CARD32)); for (i = 0; i < nPixels; i++) swapl (&pixels[i], n); } else { pixels = (CARD32 *) (reply + 1); } #ifdef COLOR_DEBUG fprintf (stderr, "AllocColorPlanes on cmap 0x%x:", nr->request_info.xalloccolorplanes.pmap->id); #endif mask = redMask | greenMask | blueMask; for (i = 0; i < nPixels; i++) { Pixel pixel, x = 0; do { x = (x + ~mask + 1) & mask; pixel = x | pixels[i]; AllocCell(client, pmap, pixel); #ifdef COLOR_DEBUG fprintf(stderr, " %d", pixel); #endif } while (x); } #ifdef COLOR_DEBUG fprintf(stderr, "\n"); #endif if (client->swapped) { xfree (pixels); } return TRUE; } /* ------------------------------------------------------------------------- */ int ProcLBXLookupColor(client) ClientPtr client; { REQUEST(xLookupColorReq); xLookupColorReply reply; ReplyStuffPtr nr; RGBEntryPtr rgbe; int len; char n; Colormap cmap; ColormapPtr pmap; len = stuff->nbytes; cmap = stuff->cmap; if (client->swapped) { swapl(&cmap, n); swaps(&len, n); } pmap = (ColormapPtr) LookupIDByType (client, cmap, RT_COLORMAP); if (len > MAX_COLORNAME_LENGTH || !pmap) return ProcStandardRequest(client); rgbe = FindColorName(client->server, (char *) &stuff[1], len, pmap->pVisual); if (rgbe) { /* found the value */ reply.type = X_Reply; reply.length = 0; reply.sequenceNumber = LBXSequenceNumber(client); reply.exactRed = rgbe->xred; reply.exactBlue = rgbe->xblue; reply.exactGreen = rgbe->xgreen; reply.screenRed = rgbe->vred; reply.screenBlue = rgbe->vblue; reply.screenGreen = rgbe->vgreen; #ifdef COLOR_DEBUG if (LBXCacheSafe (client)) fprintf(stderr, "X LookupColor: short circuiting:\n"); else fprintf(stderr, "X LookupColor: short circuiting, but need Sync:\n"); fprintf (stderr, " seq = 0x%x, name = %.*s\n", LBXSequenceNumber(client), len, (char *)&stuff[1]); #endif if (client->swapped) SwapLookupColorReply(&reply); if (LBXCacheSafe(client)) { FinishLBXRequest(client, REQ_YANK); WriteToClient(client, sizeof(xLookupColorReply), &reply); } else { if (!LBXCanDelayReply(client)) SendLbxSync(client); FinishLBXRequest(client, REQ_YANKLATE); SaveReplyData(client, (xReply *) & reply, 0, NULL); } #ifdef LBX_STATS luc_good++; #endif return Success; } else { nr = NewReply(client, X_LookupColor, 0, lookup_color_reply); if (!nr) return ProcStandardRequest(client); strncpy(nr->request_info.xlookupcolor.name, (char *) &stuff[1], len); nr->request_info.xlookupcolor.namelen = len; nr->request_info.xlookupcolor.visual = pmap->pVisual->id; #ifdef LBX_STATS luc_miss++; #endif return ProcStandardRequest(client); } } static Bool lookup_color_reply(client, nr, data) ClientPtr client; ReplyStuffPtr nr; char *data; { xLookupColorReply *reply; RGBEntryRec rgbe; char n; reply = (xLookupColorReply *) data; rgbe.xred = reply->exactRed; rgbe.xblue = reply->exactBlue; rgbe.xgreen = reply->exactGreen; rgbe.vred = reply->screenRed; rgbe.vgreen = reply->screenGreen; rgbe.vblue = reply->screenBlue; rgbe.visual = nr->request_info.xlookupcolor.visual; if (client->swapped) { swaps(&rgbe.xred, n); swaps(&rgbe.xgreen, n); swaps(&rgbe.xblue, n); swaps(&rgbe.vred, n); swaps(&rgbe.vgreen, n); swaps(&rgbe.vblue, n); } AddColorName(client->server, nr->request_info.xlookupcolor.name, nr->request_info.xlookupcolor.namelen, &rgbe); return TRUE; }