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