Introduce a consistent coding style

This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>

15 files changed, 4829 insertions, 5232 deletions

diff --git a/render/animcur.c b/render/animcur.c
index 8d4a9c2ef..485c068fe 100644
--- a/render/animcur.c
+++ b/render/animcur.c
@@ -48,35 +48,36 @@
 #include "xace.h"
 
 typedef struct _AnimCurElt {
-    CursorPtr	pCursor;    /* cursor to show */
-    CARD32	delay;	    /* in ms */
+    CursorPtr pCursor;          /* cursor to show */
+    CARD32 delay;               /* in ms */
 } AnimCurElt;
 
 typedef struct _AnimCur {
-    int		nelt;	    /* number of elements in the elts array */
-    AnimCurElt	*elts;	    /* actually allocated right after the structure */
+    int nelt;                   /* number of elements in the elts array */
+    AnimCurElt *elts;           /* actually allocated right after the structure */
 } AnimCurRec, *AnimCurPtr;
 
 typedef struct _AnimScrPriv {
-    CloseScreenProcPtr		CloseScreen;
+    CloseScreenProcPtr CloseScreen;
 
-    ScreenBlockHandlerProcPtr	BlockHandler;
+    ScreenBlockHandlerProcPtr BlockHandler;
 
-    CursorLimitsProcPtr		CursorLimits;
-    DisplayCursorProcPtr	DisplayCursor;
-    SetCursorPositionProcPtr	SetCursorPosition;
-    RealizeCursorProcPtr	RealizeCursor;
-    UnrealizeCursorProcPtr	UnrealizeCursor;
-    RecolorCursorProcPtr	RecolorCursor;
+    CursorLimitsProcPtr CursorLimits;
+    DisplayCursorProcPtr DisplayCursor;
+    SetCursorPositionProcPtr SetCursorPosition;
+    RealizeCursorProcPtr RealizeCursor;
+    UnrealizeCursorProcPtr UnrealizeCursor;
+    RecolorCursorProcPtr RecolorCursor;
 } AnimCurScreenRec, *AnimCurScreenPtr;
 
 static unsigned char empty[4];
 
-static CursorBits   animCursorBits = {
+static CursorBits animCursorBits = {
     empty, empty, 2, 1, 1, 0, 0, 1
 };
 
 static DevPrivateKeyRec AnimCurScreenPrivateKeyRec;
+
 #define AnimCurScreenPrivateKey (&AnimCurScreenPrivateKeyRec)
 
 #define IsAnimCur(c)	    ((c) && ((c)->bits == &animCursorBits))
@@ -87,12 +88,11 @@ static DevPrivateKeyRec AnimCurScreenPrivateKeyRec;
 #define Wrap(as,s,elt,func) (((as)->elt = (s)->elt), (s)->elt = func)
 #define Unwrap(as,s,elt)    ((s)->elt = (as)->elt)
 
-
 static Bool
-AnimCurCloseScreen (int index, ScreenPtr pScreen)
+AnimCurCloseScreen(int index, ScreenPtr pScreen)
 {
-    AnimCurScreenPtr    as = GetAnimCurScreen(pScreen);
-    Bool                ret;
+    AnimCurScreenPtr as = GetAnimCurScreen(pScreen);
+    Bool ret;
 
     Unwrap(as, pScreen, CloseScreen);
 
@@ -102,35 +102,30 @@ AnimCurCloseScreen (int index, ScreenPtr pScreen)
     Unwrap(as, pScreen, RealizeCursor);
     Unwrap(as, pScreen, UnrealizeCursor);
     Unwrap(as, pScreen, RecolorCursor);
-    SetAnimCurScreen(pScreen,0);
+    SetAnimCurScreen(pScreen, 0);
     ret = (*pScreen->CloseScreen) (index, pScreen);
     free(as);
     return ret;
 }
 
-static void 
-AnimCurCursorLimits (DeviceIntPtr pDev,
-                     ScreenPtr pScreen,
-		     CursorPtr pCursor,
-		     BoxPtr pHotBox,
-		     BoxPtr pTopLeftBox)
+static void
+AnimCurCursorLimits(DeviceIntPtr pDev,
+                    ScreenPtr pScreen,
+                    CursorPtr pCursor, BoxPtr pHotBox, BoxPtr pTopLeftBox)
 {
-    AnimCurScreenPtr    as = GetAnimCurScreen(pScreen);
+    AnimCurScreenPtr as = GetAnimCurScreen(pScreen);
 
-    Unwrap (as, pScreen, CursorLimits);
-    if (IsAnimCur(pCursor))
-    {
-	AnimCurPtr	ac = GetAnimCur(pCursor);
+    Unwrap(as, pScreen, CursorLimits);
+    if (IsAnimCur(pCursor)) {
+        AnimCurPtr ac = GetAnimCur(pCursor);
 
-        (*pScreen->CursorLimits) (pDev, pScreen, ac->elts[0].pCursor, 
-                                  pHotBox, pTopLeftBox); 
+        (*pScreen->CursorLimits) (pDev, pScreen, ac->elts[0].pCursor,
+                                  pHotBox, pTopLeftBox);
     }
-    else
-    {
-        (*pScreen->CursorLimits) (pDev, pScreen, pCursor,
-                                  pHotBox, pTopLeftBox); 
+    else {
+        (*pScreen->CursorLimits) (pDev, pScreen, pCursor, pHotBox, pTopLeftBox);
     }
-    Wrap (as, pScreen, CursorLimits, AnimCurCursorLimits);
+    Wrap(as, pScreen, CursorLimits, AnimCurCursorLimits);
 }
 
 /*
@@ -140,209 +135,188 @@ AnimCurCursorLimits (DeviceIntPtr pDev,
  */
 
 static void
-AnimCurScreenBlockHandler (int screenNum,
-			   pointer blockData,
-			   pointer pTimeout,
-			   pointer pReadmask)
+AnimCurScreenBlockHandler(int screenNum,
+                          pointer blockData,
+                          pointer pTimeout, pointer pReadmask)
 {
-    ScreenPtr		pScreen = screenInfo.screens[screenNum];
-    AnimCurScreenPtr    as = GetAnimCurScreen(pScreen);
-    DeviceIntPtr        dev;
-    Bool                activeDevice = FALSE;
-    CARD32              now = 0, 
-                        soonest = ~0; /* earliest time to wakeup again */
-
-    for (dev = inputInfo.devices; dev; dev = dev->next)
-    {
-	if (IsPointerDevice(dev) && pScreen == dev->spriteInfo->anim.pScreen)
-	{
-	    if (!activeDevice) {
-                now = GetTimeInMillis ();
+    ScreenPtr pScreen = screenInfo.screens[screenNum];
+    AnimCurScreenPtr as = GetAnimCurScreen(pScreen);
+    DeviceIntPtr dev;
+    Bool activeDevice = FALSE;
+    CARD32 now = 0, soonest = ~0;       /* earliest time to wakeup again */
+
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+        if (IsPointerDevice(dev) && pScreen == dev->spriteInfo->anim.pScreen) {
+            if (!activeDevice) {
+                now = GetTimeInMillis();
                 activeDevice = TRUE;
             }
 
-	    if ((INT32) (now - dev->spriteInfo->anim.time) >= 0)
-	    {
-		AnimCurPtr ac  = GetAnimCur(dev->spriteInfo->anim.pCursor);
-		int        elt = (dev->spriteInfo->anim.elt + 1) % ac->nelt;
-		DisplayCursorProcPtr DisplayCursor;
-
-		/*
-		 * Not a simple Unwrap/Wrap as this
-		 * isn't called along the DisplayCursor 
-		 * wrapper chain.
-		 */
-		DisplayCursor = pScreen->DisplayCursor;
-		pScreen->DisplayCursor = as->DisplayCursor;
-		(void) (*pScreen->DisplayCursor) (dev,
-						  pScreen, 
-						  ac->elts[elt].pCursor);
-		as->DisplayCursor = pScreen->DisplayCursor;
-		pScreen->DisplayCursor = DisplayCursor;
-
-		dev->spriteInfo->anim.elt = elt;
-		dev->spriteInfo->anim.time = now + ac->elts[elt].delay;
-	    }
-
-	    if (soonest > dev->spriteInfo->anim.time)
-		soonest = dev->spriteInfo->anim.time;
-	}
+            if ((INT32) (now - dev->spriteInfo->anim.time) >= 0) {
+                AnimCurPtr ac = GetAnimCur(dev->spriteInfo->anim.pCursor);
+                int elt = (dev->spriteInfo->anim.elt + 1) % ac->nelt;
+                DisplayCursorProcPtr DisplayCursor;
+
+                /*
+                 * Not a simple Unwrap/Wrap as this
+                 * isn't called along the DisplayCursor 
+                 * wrapper chain.
+                 */
+                DisplayCursor = pScreen->DisplayCursor;
+                pScreen->DisplayCursor = as->DisplayCursor;
+                (void) (*pScreen->DisplayCursor) (dev,
+                                                  pScreen,
+                                                  ac->elts[elt].pCursor);
+                as->DisplayCursor = pScreen->DisplayCursor;
+                pScreen->DisplayCursor = DisplayCursor;
+
+                dev->spriteInfo->anim.elt = elt;
+                dev->spriteInfo->anim.time = now + ac->elts[elt].delay;
+            }
+
+            if (soonest > dev->spriteInfo->anim.time)
+                soonest = dev->spriteInfo->anim.time;
+        }
     }
 
     if (activeDevice)
-        AdjustWaitForDelay (pTimeout, soonest - now);
+        AdjustWaitForDelay(pTimeout, soonest - now);
 
-    Unwrap (as, pScreen, BlockHandler);
+    Unwrap(as, pScreen, BlockHandler);
     (*pScreen->BlockHandler) (screenNum, blockData, pTimeout, pReadmask);
     if (activeDevice)
-        Wrap (as, pScreen, BlockHandler, AnimCurScreenBlockHandler);
+        Wrap(as, pScreen, BlockHandler, AnimCurScreenBlockHandler);
     else
         as->BlockHandler = NULL;
 }
 
 static Bool
-AnimCurDisplayCursor (DeviceIntPtr pDev,
-                      ScreenPtr pScreen,
-		      CursorPtr pCursor)
+AnimCurDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
 {
-    AnimCurScreenPtr    as = GetAnimCurScreen(pScreen);
-    Bool		ret;
+    AnimCurScreenPtr as = GetAnimCurScreen(pScreen);
+    Bool ret;
 
     if (IsFloating(pDev))
-	    return FALSE;
+        return FALSE;
 
-    Unwrap (as, pScreen, DisplayCursor);
-    if (IsAnimCur(pCursor))
-    {
-	if (pCursor != pDev->spriteInfo->anim.pCursor)
-	{
-	    AnimCurPtr		ac = GetAnimCur(pCursor);
+    Unwrap(as, pScreen, DisplayCursor);
+    if (IsAnimCur(pCursor)) {
+        if (pCursor != pDev->spriteInfo->anim.pCursor) {
+            AnimCurPtr ac = GetAnimCur(pCursor);
 
-	    ret = (*pScreen->DisplayCursor) 
+            ret = (*pScreen->DisplayCursor)
                 (pDev, pScreen, ac->elts[0].pCursor);
-	    if (ret)
-	    {
-		pDev->spriteInfo->anim.elt = 0;
-		pDev->spriteInfo->anim.time = GetTimeInMillis () + ac->elts[0].delay;
-		pDev->spriteInfo->anim.pCursor = pCursor;
-		pDev->spriteInfo->anim.pScreen = pScreen;
-
-		if (!as->BlockHandler)
-		    Wrap(as, pScreen, BlockHandler, AnimCurScreenBlockHandler);
-	    }
-	}
-	else
-	    ret = TRUE;
+            if (ret) {
+                pDev->spriteInfo->anim.elt = 0;
+                pDev->spriteInfo->anim.time =
+                    GetTimeInMillis() + ac->elts[0].delay;
+                pDev->spriteInfo->anim.pCursor = pCursor;
+                pDev->spriteInfo->anim.pScreen = pScreen;
+
+                if (!as->BlockHandler)
+                    Wrap(as, pScreen, BlockHandler, AnimCurScreenBlockHandler);
+            }
+        }
+        else
+            ret = TRUE;
     }
-    else
-    {
-	pDev->spriteInfo->anim.pCursor = 0;
-	pDev->spriteInfo->anim.pScreen = 0;
-	ret = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor);
+    else {
+        pDev->spriteInfo->anim.pCursor = 0;
+        pDev->spriteInfo->anim.pScreen = 0;
+        ret = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor);
     }
-    Wrap (as, pScreen, DisplayCursor, AnimCurDisplayCursor);
+    Wrap(as, pScreen, DisplayCursor, AnimCurDisplayCursor);
     return ret;
 }
 
 static Bool
-AnimCurSetCursorPosition (DeviceIntPtr pDev,
-                          ScreenPtr pScreen,
-			  int x,
-			  int y,
-			  Bool generateEvent)
+AnimCurSetCursorPosition(DeviceIntPtr pDev,
+                         ScreenPtr pScreen, int x, int y, Bool generateEvent)
 {
-    AnimCurScreenPtr    as = GetAnimCurScreen(pScreen);
-    Bool		ret;
-    
-    Unwrap (as, pScreen, SetCursorPosition);
+    AnimCurScreenPtr as = GetAnimCurScreen(pScreen);
+    Bool ret;
+
+    Unwrap(as, pScreen, SetCursorPosition);
     if (pDev->spriteInfo->anim.pCursor) {
-	pDev->spriteInfo->anim.pScreen = pScreen;
+        pDev->spriteInfo->anim.pScreen = pScreen;
 
-	if (!as->BlockHandler)
-	    Wrap(as, pScreen, BlockHandler, AnimCurScreenBlockHandler);
+        if (!as->BlockHandler)
+            Wrap(as, pScreen, BlockHandler, AnimCurScreenBlockHandler);
     }
     ret = (*pScreen->SetCursorPosition) (pDev, pScreen, x, y, generateEvent);
-    Wrap (as, pScreen, SetCursorPosition, AnimCurSetCursorPosition);
+    Wrap(as, pScreen, SetCursorPosition, AnimCurSetCursorPosition);
     return ret;
 }
 
-static Bool 
-AnimCurRealizeCursor (DeviceIntPtr pDev,
-                      ScreenPtr pScreen,
-		      CursorPtr pCursor)
+static Bool
+AnimCurRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
 {
-    AnimCurScreenPtr    as = GetAnimCurScreen(pScreen);
-    Bool		ret;
-    
-    Unwrap (as, pScreen, RealizeCursor);
+    AnimCurScreenPtr as = GetAnimCurScreen(pScreen);
+    Bool ret;
+
+    Unwrap(as, pScreen, RealizeCursor);
     if (IsAnimCur(pCursor))
-	ret = TRUE;
+        ret = TRUE;
     else
-	ret = (*pScreen->RealizeCursor) (pDev, pScreen, pCursor);
-    Wrap (as, pScreen, RealizeCursor, AnimCurRealizeCursor);
+        ret = (*pScreen->RealizeCursor) (pDev, pScreen, pCursor);
+    Wrap(as, pScreen, RealizeCursor, AnimCurRealizeCursor);
     return ret;
 }
 
-static Bool 
-AnimCurUnrealizeCursor (DeviceIntPtr pDev,
-                        ScreenPtr pScreen,
-			CursorPtr pCursor)
+static Bool
+AnimCurUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
 {
-    AnimCurScreenPtr    as = GetAnimCurScreen(pScreen);
-    Bool		ret;
-    
-    Unwrap (as, pScreen, UnrealizeCursor);
-    if (IsAnimCur(pCursor))
-    {
-        AnimCurPtr  ac = GetAnimCur(pCursor);
-	int	    i;
-
-	if (pScreen->myNum == 0)
-	    for (i = 0; i < ac->nelt; i++)
-		FreeCursor (ac->elts[i].pCursor, 0);
-	ret = TRUE;
+    AnimCurScreenPtr as = GetAnimCurScreen(pScreen);
+    Bool ret;
+
+    Unwrap(as, pScreen, UnrealizeCursor);
+    if (IsAnimCur(pCursor)) {
+        AnimCurPtr ac = GetAnimCur(pCursor);
+        int i;
+
+        if (pScreen->myNum == 0)
+            for (i = 0; i < ac->nelt; i++)
+                FreeCursor(ac->elts[i].pCursor, 0);
+        ret = TRUE;
     }
     else
-	ret = (*pScreen->UnrealizeCursor) (pDev, pScreen, pCursor);
-    Wrap (as, pScreen, UnrealizeCursor, AnimCurUnrealizeCursor);
+        ret = (*pScreen->UnrealizeCursor) (pDev, pScreen, pCursor);
+    Wrap(as, pScreen, UnrealizeCursor, AnimCurUnrealizeCursor);
     return ret;
 }
 
 static void
-AnimCurRecolorCursor (DeviceIntPtr pDev,
-                      ScreenPtr pScreen,
-		      CursorPtr pCursor,
-		      Bool displayed)
+AnimCurRecolorCursor(DeviceIntPtr pDev,
+                     ScreenPtr pScreen, CursorPtr pCursor, Bool displayed)
 {
-    AnimCurScreenPtr    as = GetAnimCurScreen(pScreen);
-    
-    Unwrap (as, pScreen, RecolorCursor);
-    if (IsAnimCur(pCursor))
-    {
-        AnimCurPtr  ac = GetAnimCur(pCursor);
-	int	    i;
+    AnimCurScreenPtr as = GetAnimCurScreen(pScreen);
+
+    Unwrap(as, pScreen, RecolorCursor);
+    if (IsAnimCur(pCursor)) {
+        AnimCurPtr ac = GetAnimCur(pCursor);
+        int i;
 
         for (i = 0; i < ac->nelt; i++)
-	    (*pScreen->RecolorCursor) (pDev, pScreen, ac->elts[i].pCursor,
-				       displayed && 
-				       pDev->spriteInfo->anim.elt == i);
+            (*pScreen->RecolorCursor) (pDev, pScreen, ac->elts[i].pCursor,
+                                       displayed &&
+                                       pDev->spriteInfo->anim.elt == i);
     }
     else
-	(*pScreen->RecolorCursor) (pDev, pScreen, pCursor, displayed);
-    Wrap (as, pScreen, RecolorCursor, AnimCurRecolorCursor);
+        (*pScreen->RecolorCursor) (pDev, pScreen, pCursor, displayed);
+    Wrap(as, pScreen, RecolorCursor, AnimCurRecolorCursor);
 }
 
 Bool
-AnimCurInit (ScreenPtr pScreen)
+AnimCurInit(ScreenPtr pScreen)
 {
-    AnimCurScreenPtr    as;
+    AnimCurScreenPtr as;
 
     if (!dixRegisterPrivateKey(&AnimCurScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
+        return FALSE;
 
-    as = (AnimCurScreenPtr) malloc(sizeof (AnimCurScreenRec));
+    as = (AnimCurScreenPtr) malloc(sizeof(AnimCurScreenRec));
     if (!as)
-	return FALSE;
+        return FALSE;
     Wrap(as, pScreen, CloseScreen, AnimCurCloseScreen);
 
     as->BlockHandler = NULL;
@@ -353,38 +327,39 @@ AnimCurInit (ScreenPtr pScreen)
     Wrap(as, pScreen, RealizeCursor, AnimCurRealizeCursor);
     Wrap(as, pScreen, UnrealizeCursor, AnimCurUnrealizeCursor);
     Wrap(as, pScreen, RecolorCursor, AnimCurRecolorCursor);
-    SetAnimCurScreen(pScreen,as);
+    SetAnimCurScreen(pScreen, as);
     return TRUE;
 }
 
 int
-AnimCursorCreate (CursorPtr *cursors, CARD32 *deltas, int ncursor, CursorPtr *ppCursor, ClientPtr client, XID cid)
+AnimCursorCreate(CursorPtr *cursors, CARD32 *deltas, int ncursor,
+                 CursorPtr *ppCursor, ClientPtr client, XID cid)
 {
-    CursorPtr	pCursor;
-    int		rc, i;
-    AnimCurPtr	ac;
+    CursorPtr pCursor;
+    int rc, i;
+    AnimCurPtr ac;
 
     for (i = 0; i < screenInfo.numScreens; i++)
-	if (!GetAnimCurScreen (screenInfo.screens[i]))
-	    return BadImplementation;
+        if (!GetAnimCurScreen(screenInfo.screens[i]))
+            return BadImplementation;
 
     for (i = 0; i < ncursor; i++)
-	if (IsAnimCur (cursors[i]))
-	    return BadMatch;
-	
+        if (IsAnimCur(cursors[i]))
+            return BadMatch;
+
     pCursor = (CursorPtr) calloc(CURSOR_REC_SIZE +
-				 sizeof (AnimCurRec) +
-				 ncursor * sizeof (AnimCurElt), 1);
+                                 sizeof(AnimCurRec) +
+                                 ncursor * sizeof(AnimCurElt), 1);
     if (!pCursor)
-	return BadAlloc;
+        return BadAlloc;
     dixInitPrivates(pCursor, pCursor + 1, PRIVATE_CURSOR);
     pCursor->bits = &animCursorBits;
     pCursor->refcnt = 1;
-    
+
     pCursor->foreRed = cursors[0]->foreRed;
     pCursor->foreGreen = cursors[0]->foreGreen;
     pCursor->foreBlue = cursors[0]->foreBlue;
-    
+
     pCursor->backRed = cursors[0]->backRed;
     pCursor->backGreen = cursors[0]->backGreen;
     pCursor->backBlue = cursors[0]->backBlue;
@@ -393,28 +368,27 @@ AnimCursorCreate (CursorPtr *cursors, CARD32 *deltas, int ncursor, CursorPtr *pp
 
     /* security creation/labeling check */
     rc = XaceHook(XACE_RESOURCE_ACCESS, client, cid, RT_CURSOR, pCursor,
-		  RT_NONE, NULL, DixCreateAccess);
+                  RT_NONE, NULL, DixCreateAccess);
     if (rc != Success) {
-	dixFiniPrivates(pCursor, PRIVATE_CURSOR);
-	free(pCursor);
-	return rc;
+        dixFiniPrivates(pCursor, PRIVATE_CURSOR);
+        free(pCursor);
+        return rc;
     }
-	
+
     /*
      * Fill in the AnimCurRec
      */
     animCursorBits.refcnt++;
-    ac = GetAnimCur (pCursor);
+    ac = GetAnimCur(pCursor);
     ac->nelt = ncursor;
     ac->elts = (AnimCurElt *) (ac + 1);
-    
-    for (i = 0; i < ncursor; i++)
-    {
-	cursors[i]->refcnt++;
-	ac->elts[i].pCursor = cursors[i];
-	ac->elts[i].delay = deltas[i];
+
+    for (i = 0; i < ncursor; i++) {
+        cursors[i]->refcnt++;
+        ac->elts[i].pCursor = cursors[i];
+        ac->elts[i].delay = deltas[i];
     }
-    
+
     *ppCursor = pCursor;
     return Success;
 }
diff --git a/render/filter.c b/render/filter.c
index c513ee8f9..8c401ee5d 100644
--- a/render/filter.c
+++ b/render/filter.c
@@ -40,40 +40,39 @@
 #include "picturestr.h"
 
 static char **filterNames;
-static int  nfilterNames;
+static int nfilterNames;
 
 /*
  * standard but not required filters don't have constant indices
  */
 
 int
-PictureGetFilterId (const char *filter, int len, Bool makeit)
+PictureGetFilterId(const char *filter, int len, Bool makeit)
 {
-    int	    i;
-    char    *name;
-    char    **names;
+    int i;
+    char *name;
+    char **names;
 
     if (len < 0)
-	len = strlen (filter);
+        len = strlen(filter);
     for (i = 0; i < nfilterNames; i++)
-	if (!CompareISOLatin1Lowered ((const unsigned char *) filterNames[i], -1,
-				      (const unsigned char *) filter, len))
-	    return i;
+        if (!CompareISOLatin1Lowered((const unsigned char *) filterNames[i], -1,
+                                     (const unsigned char *) filter, len))
+            return i;
     if (!makeit)
-	return -1;
+        return -1;
     name = malloc(len + 1);
     if (!name)
-	return -1;
-    memcpy (name, filter, len);
+        return -1;
+    memcpy(name, filter, len);
     name[len] = '\0';
     if (filterNames)
-	names = realloc(filterNames, (nfilterNames + 1) * sizeof (char *));
+        names = realloc(filterNames, (nfilterNames + 1) * sizeof(char *));
     else
-	names = malloc(sizeof (char *));
-    if (!names)
-    {
-	free(name);
-	return -1;
+        names = malloc(sizeof(char *));
+    if (!names) {
+        free(name);
+        return -1;
     }
     filterNames = names;
     i = nfilterNames++;
@@ -82,77 +81,78 @@ PictureGetFilterId (const char *filter, int len, Bool makeit)
 }
 
 static Bool
-PictureSetDefaultIds (void)
+PictureSetDefaultIds(void)
 {
     /* careful here -- this list must match the #define values */
 
-    if (PictureGetFilterId (FilterNearest, -1, TRUE) != PictFilterNearest)
-	return FALSE;
-    if (PictureGetFilterId (FilterBilinear, -1, TRUE) != PictFilterBilinear)
-	return FALSE;
+    if (PictureGetFilterId(FilterNearest, -1, TRUE) != PictFilterNearest)
+        return FALSE;
+    if (PictureGetFilterId(FilterBilinear, -1, TRUE) != PictFilterBilinear)
+        return FALSE;
 
-    if (PictureGetFilterId (FilterFast, -1, TRUE) != PictFilterFast)
-	return FALSE;
-    if (PictureGetFilterId (FilterGood, -1, TRUE) != PictFilterGood)
-	return FALSE;
-    if (PictureGetFilterId (FilterBest, -1, TRUE) != PictFilterBest)
-	return FALSE;
+    if (PictureGetFilterId(FilterFast, -1, TRUE) != PictFilterFast)
+        return FALSE;
+    if (PictureGetFilterId(FilterGood, -1, TRUE) != PictFilterGood)
+        return FALSE;
+    if (PictureGetFilterId(FilterBest, -1, TRUE) != PictFilterBest)
+        return FALSE;
 
-    if (PictureGetFilterId (FilterConvolution, -1, TRUE) != PictFilterConvolution)
-	return FALSE;
+    if (PictureGetFilterId(FilterConvolution, -1, TRUE) !=
+        PictFilterConvolution)
+        return FALSE;
     return TRUE;
 }
 
 char *
-PictureGetFilterName (int id)
+PictureGetFilterName(int id)
 {
     if (0 <= id && id < nfilterNames)
-	return filterNames[id];
+        return filterNames[id];
     else
-	return 0;
+        return 0;
 }
 
 static void
-PictureFreeFilterIds (void)
+PictureFreeFilterIds(void)
 {
-    int	    i;
+    int i;
 
     for (i = 0; i < nfilterNames; i++)
-	free(filterNames[i]);
+        free(filterNames[i]);
     free(filterNames);
     nfilterNames = 0;
     filterNames = 0;
 }
 
 int
-PictureAddFilter (ScreenPtr			    pScreen,
-		  const char			    *filter,
-		  PictFilterValidateParamsProcPtr   ValidateParams,
-		  int				    width,
-		  int				    height)
+PictureAddFilter(ScreenPtr pScreen,
+                 const char *filter,
+                 PictFilterValidateParamsProcPtr ValidateParams,
+                 int width, int height)
 {
-    PictureScreenPtr    ps = GetPictureScreen(pScreen);
-    int			id = PictureGetFilterId (filter, -1,  TRUE);
-    int			i;
-    PictFilterPtr	filters;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    int id = PictureGetFilterId(filter, -1, TRUE);
+    int i;
+    PictFilterPtr filters;
 
     if (id < 0)
-	return -1;
+        return -1;
     /*
      * It's an error to attempt to reregister a filter
      */
     for (i = 0; i < ps->nfilters; i++)
-	if (ps->filters[i].id == id)
-	    return -1;
+        if (ps->filters[i].id == id)
+            return -1;
     if (ps->filters)
-	filters = realloc(ps->filters, (ps->nfilters + 1) * sizeof (PictFilterRec));
+        filters =
+            realloc(ps->filters, (ps->nfilters + 1) * sizeof(PictFilterRec));
     else
-	filters = malloc(sizeof (PictFilterRec));
+        filters = malloc(sizeof(PictFilterRec));
     if (!filters)
-	return -1;
+        return -1;
     ps->filters = filters;
     i = ps->nfilters++;
-    ps->filters[i].name = PictureGetFilterName (id);
+    ps->filters[i].name = PictureGetFilterName(id);
     ps->filters[i].id = id;
     ps->filters[i].ValidateParams = ValidateParams;
     ps->filters[i].width = width;
@@ -161,79 +161,76 @@ PictureAddFilter (ScreenPtr			    pScreen,
 }
 
 Bool
-PictureSetFilterAlias (ScreenPtr pScreen, const char *filter, const char *alias)
+PictureSetFilterAlias(ScreenPtr pScreen, const char *filter, const char *alias)
 {
-    PictureScreenPtr    ps = GetPictureScreen(pScreen);
-    int			filter_id = PictureGetFilterId (filter, -1, FALSE);
-    int			alias_id = PictureGetFilterId (alias, -1, TRUE);
-    int			i;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    int filter_id = PictureGetFilterId(filter, -1, FALSE);
+    int alias_id = PictureGetFilterId(alias, -1, TRUE);
+    int i;
 
     if (filter_id < 0 || alias_id < 0)
-	return FALSE;
+        return FALSE;
     for (i = 0; i < ps->nfilterAliases; i++)
-	if (ps->filterAliases[i].alias_id == alias_id)
-	    break;
-    if (i == ps->nfilterAliases)
-    {
-	PictFilterAliasPtr  aliases;
-
-	if (ps->filterAliases)
-	    aliases = realloc(ps->filterAliases,
-				(ps->nfilterAliases + 1) *
-				sizeof (PictFilterAliasRec));
-	else
-	    aliases = malloc(sizeof (PictFilterAliasRec));
-	if (!aliases)
-	    return FALSE;
-	ps->filterAliases = aliases;
-	ps->filterAliases[i].alias = PictureGetFilterName (alias_id);
-	ps->filterAliases[i].alias_id = alias_id;
-	ps->nfilterAliases++;
+        if (ps->filterAliases[i].alias_id == alias_id)
+            break;
+    if (i == ps->nfilterAliases) {
+        PictFilterAliasPtr aliases;
+
+        if (ps->filterAliases)
+            aliases = realloc(ps->filterAliases,
+                              (ps->nfilterAliases + 1) *
+                              sizeof(PictFilterAliasRec));
+        else
+            aliases = malloc(sizeof(PictFilterAliasRec));
+        if (!aliases)
+            return FALSE;
+        ps->filterAliases = aliases;
+        ps->filterAliases[i].alias = PictureGetFilterName(alias_id);
+        ps->filterAliases[i].alias_id = alias_id;
+        ps->nfilterAliases++;
     }
     ps->filterAliases[i].filter_id = filter_id;
     return TRUE;
 }
 
 PictFilterPtr
-PictureFindFilter (ScreenPtr pScreen, char *name, int len)
+PictureFindFilter(ScreenPtr pScreen, char *name, int len)
 {
-    PictureScreenPtr    ps = GetPictureScreen(pScreen);
-    int			id = PictureGetFilterId (name, len, FALSE);
-    int			i;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    int id = PictureGetFilterId(name, len, FALSE);
+    int i;
 
     if (id < 0)
-	return 0;
+        return 0;
     /* Check for an alias, allow them to recurse */
     for (i = 0; i < ps->nfilterAliases; i++)
-	if (ps->filterAliases[i].alias_id == id)
-	{
-	    id = ps->filterAliases[i].filter_id;
-	    i = 0;
-	}
+        if (ps->filterAliases[i].alias_id == id) {
+            id = ps->filterAliases[i].filter_id;
+            i = 0;
+        }
     /* find the filter */
     for (i = 0; i < ps->nfilters; i++)
-	if (ps->filters[i].id == id)
-	    return &ps->filters[i];
+        if (ps->filters[i].id == id)
+            return &ps->filters[i];
     return 0;
 }
 
 static Bool
-convolutionFilterValidateParams (ScreenPtr pScreen,
-                                 int	   filter,
-                                 xFixed	   *params,
-                                 int	   nparams,
-				 int       *width,
-				 int	   *height)
+convolutionFilterValidateParams(ScreenPtr pScreen,
+                                int filter,
+                                xFixed * params,
+                                int nparams, int *width, int *height)
 {
-    int	w, h;
+    int w, h;
+
     if (nparams < 3)
         return FALSE;
 
-    if (xFixedFrac (params[0]) || xFixedFrac (params[1]))
+    if (xFixedFrac(params[0]) || xFixedFrac(params[1]))
         return FALSE;
 
-    w = xFixedToInt (params[0]);
-    h = xFixedToInt (params[1]);
+    w = xFixedToInt(params[0]);
+    h = xFixedToInt(params[1]);
 
     nparams -= 2;
     if (w * h > nparams)
@@ -244,117 +241,117 @@ convolutionFilterValidateParams (ScreenPtr pScreen,
     return TRUE;
 }
 
-
 Bool
-PictureSetDefaultFilters (ScreenPtr pScreen)
+PictureSetDefaultFilters(ScreenPtr pScreen)
 {
     if (!filterNames)
-	if (!PictureSetDefaultIds ())
-	    return FALSE;
-    if (PictureAddFilter (pScreen, FilterNearest, 0, 1, 1) < 0)
-	return FALSE;
-    if (PictureAddFilter (pScreen, FilterBilinear, 0, 2, 2) < 0)
-	return FALSE;
-
-    if (!PictureSetFilterAlias (pScreen, FilterNearest, FilterFast))
-	return FALSE;
-    if (!PictureSetFilterAlias (pScreen, FilterBilinear, FilterGood))
-	return FALSE;
-    if (!PictureSetFilterAlias (pScreen, FilterBilinear, FilterBest))
-	return FALSE;
-
-    if (PictureAddFilter (pScreen, FilterConvolution, convolutionFilterValidateParams, 0, 0) < 0)
+        if (!PictureSetDefaultIds())
+            return FALSE;
+    if (PictureAddFilter(pScreen, FilterNearest, 0, 1, 1) < 0)
+        return FALSE;
+    if (PictureAddFilter(pScreen, FilterBilinear, 0, 2, 2) < 0)
+        return FALSE;
+
+    if (!PictureSetFilterAlias(pScreen, FilterNearest, FilterFast))
+        return FALSE;
+    if (!PictureSetFilterAlias(pScreen, FilterBilinear, FilterGood))
+        return FALSE;
+    if (!PictureSetFilterAlias(pScreen, FilterBilinear, FilterBest))
+        return FALSE;
+
+    if (PictureAddFilter
+        (pScreen, FilterConvolution, convolutionFilterValidateParams, 0, 0) < 0)
         return FALSE;
 
     return TRUE;
 }
 
 void
-PictureResetFilters (ScreenPtr pScreen)
+PictureResetFilters(ScreenPtr pScreen)
 {
-    PictureScreenPtr    ps = GetPictureScreen(pScreen);
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
 
     free(ps->filters);
     free(ps->filterAliases);
-    PictureFreeFilterIds ();
+    PictureFreeFilterIds();
 }
 
 int
-SetPictureFilter (PicturePtr pPicture, char *name, int len, xFixed *params, int nparams)
+SetPictureFilter(PicturePtr pPicture, char *name, int len, xFixed * params,
+                 int nparams)
 {
-    PictFilterPtr	pFilter;
-    ScreenPtr		pScreen;
+    PictFilterPtr pFilter;
+    ScreenPtr pScreen;
 
     if (pPicture->pDrawable != NULL)
-	pScreen = pPicture->pDrawable->pScreen;
+        pScreen = pPicture->pDrawable->pScreen;
     else
-	pScreen = screenInfo.screens[0];
+        pScreen = screenInfo.screens[0];
 
-    pFilter = PictureFindFilter (pScreen, name, len);
+    pFilter = PictureFindFilter(pScreen, name, len);
 
     if (!pFilter)
-	return BadName;
-
-    if (pPicture->pDrawable == NULL)
-    {
-	int s;
-	/* For source pictures, the picture isn't tied to a screen.  So, ensure
-	 * that all screens can handle a filter we set for the picture.
-	 */
-	for (s = 1; s < screenInfo.numScreens; s++)
-	{
-	    PictFilterPtr   pScreenFilter;
-	    pScreenFilter = PictureFindFilter (screenInfo.screens[s],
-					       name, len);
-	    if (!pScreenFilter || pScreenFilter->id != pFilter->id)
-		return BadMatch;
-	}
+        return BadName;
+
+    if (pPicture->pDrawable == NULL) {
+        int s;
+
+        /* For source pictures, the picture isn't tied to a screen.  So, ensure
+         * that all screens can handle a filter we set for the picture.
+         */
+        for (s = 1; s < screenInfo.numScreens; s++) {
+            PictFilterPtr pScreenFilter;
+
+            pScreenFilter = PictureFindFilter(screenInfo.screens[s], name, len);
+            if (!pScreenFilter || pScreenFilter->id != pFilter->id)
+                return BadMatch;
+        }
     }
-    return SetPicturePictFilter (pPicture, pFilter, params, nparams);
+    return SetPicturePictFilter(pPicture, pFilter, params, nparams);
 }
 
 int
-SetPicturePictFilter (PicturePtr pPicture, PictFilterPtr pFilter,
-		      xFixed *params, int nparams)
+SetPicturePictFilter(PicturePtr pPicture, PictFilterPtr pFilter,
+                     xFixed * params, int nparams)
 {
-    ScreenPtr	pScreen;
-    int		i;
+    ScreenPtr pScreen;
+    int i;
 
     if (pPicture->pDrawable)
-	pScreen = pPicture->pDrawable->pScreen;
+        pScreen = pPicture->pDrawable->pScreen;
     else
-	pScreen = screenInfo.screens[0];
+        pScreen = screenInfo.screens[0];
+
+    if (pFilter->ValidateParams) {
+        int width, height;
 
-    if (pFilter->ValidateParams)
-    {
-	int width, height;
-	if (!(*pFilter->ValidateParams) (pScreen, pFilter->id, params, nparams, &width, &height))
-	    return BadMatch;
+        if (!(*pFilter->ValidateParams)
+            (pScreen, pFilter->id, params, nparams, &width, &height))
+            return BadMatch;
     }
     else if (nparams)
-	return BadMatch;
-
-    if (nparams != pPicture->filter_nparams)
-    {
-	xFixed *new_params = malloc(nparams * sizeof (xFixed));
-	if (!new_params && nparams)
-	    return BadAlloc;
-	free(pPicture->filter_params);
-	pPicture->filter_params = new_params;
-	pPicture->filter_nparams = nparams;
+        return BadMatch;
+
+    if (nparams != pPicture->filter_nparams) {
+        xFixed *new_params = malloc(nparams * sizeof(xFixed));
+
+        if (!new_params && nparams)
+            return BadAlloc;
+        free(pPicture->filter_params);
+        pPicture->filter_params = new_params;
+        pPicture->filter_nparams = nparams;
     }
     for (i = 0; i < nparams; i++)
-	pPicture->filter_params[i] = params[i];
+        pPicture->filter_params[i] = params[i];
     pPicture->filter = pFilter->id;
 
-    if (pPicture->pDrawable)
-    {
-	PictureScreenPtr    ps = GetPictureScreen(pScreen);
-	int		    result;
+    if (pPicture->pDrawable) {
+        PictureScreenPtr ps = GetPictureScreen(pScreen);
+        int result;
 
-	result = (*ps->ChangePictureFilter) (pPicture, pPicture->filter,
-					     params, nparams);
-	return result;
+        result = (*ps->ChangePictureFilter) (pPicture, pPicture->filter,
+                                             params, nparams);
+        return result;
     }
     return Success;
 }
diff --git a/render/glyph.c b/render/glyph.c
index 7193d4763..a143e9eb5 100644
--- a/render/glyph.c
+++ b/render/glyph.c
@@ -51,194 +51,178 @@
  * free to avoid exponential performance degradation as the hash table fills
  */
 static GlyphHashSetRec glyphHashSets[] = {
-    { 32,		43,		41        },
-    { 64,		73,		71        },
-    { 128,		151,		149       },
-    { 256,		283,		281       },
-    { 512,		571,		569       },
-    { 1024,		1153,		1151      },
-    { 2048,		2269,		2267      },
-    { 4096,		4519,		4517      },
-    { 8192,		9013,		9011      },
-    { 16384,		18043,		18041     },
-    { 32768,		36109,		36107     },
-    { 65536,		72091,		72089     },
-    { 131072,		144409,		144407    },
-    { 262144,		288361,		288359    },
-    { 524288,		576883,		576881    },
-    { 1048576,		1153459,	1153457   },
-    { 2097152,		2307163,	2307161   },
-    { 4194304,		4613893,	4613891   },
-    { 8388608,		9227641,	9227639   },
-    { 16777216,		18455029,	18455027  },
-    { 33554432,		36911011,	36911009  },
-    { 67108864,		73819861,	73819859  },
-    { 134217728,	147639589,	147639587 },
-    { 268435456,	295279081,	295279079 },
-    { 536870912,	590559793,	590559791 }
+    {32, 43, 41},
+    {64, 73, 71},
+    {128, 151, 149},
+    {256, 283, 281},
+    {512, 571, 569},
+    {1024, 1153, 1151},
+    {2048, 2269, 2267},
+    {4096, 4519, 4517},
+    {8192, 9013, 9011},
+    {16384, 18043, 18041},
+    {32768, 36109, 36107},
+    {65536, 72091, 72089},
+    {131072, 144409, 144407},
+    {262144, 288361, 288359},
+    {524288, 576883, 576881},
+    {1048576, 1153459, 1153457},
+    {2097152, 2307163, 2307161},
+    {4194304, 4613893, 4613891},
+    {8388608, 9227641, 9227639},
+    {16777216, 18455029, 18455027},
+    {33554432, 36911011, 36911009},
+    {67108864, 73819861, 73819859},
+    {134217728, 147639589, 147639587},
+    {268435456, 295279081, 295279079},
+    {536870912, 590559793, 590559791}
 };
 
 #define NGLYPHHASHSETS	(sizeof(glyphHashSets)/sizeof(glyphHashSets[0]))
 
-static const CARD8	glyphDepths[GlyphFormatNum] = { 1, 4, 8, 16, 32 };
+static const CARD8 glyphDepths[GlyphFormatNum] = { 1, 4, 8, 16, 32 };
 
-static GlyphHashRec	globalGlyphs[GlyphFormatNum];
+static GlyphHashRec globalGlyphs[GlyphFormatNum];
 
 void
-GlyphUninit (ScreenPtr pScreen)
+GlyphUninit(ScreenPtr pScreen)
 {
-    PictureScreenPtr ps = GetPictureScreen (pScreen);
-    GlyphPtr	     glyph;
-    int		     fdepth, i;
-    int		     scrno = pScreen->myNum;
-
-    for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++)
-    {
-	if (!globalGlyphs[fdepth].hashSet)
-	    continue;
-	
-	for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++)
-	{
-	    glyph = globalGlyphs[fdepth].table[i].glyph;
-	    if (glyph && glyph != DeletedGlyph)
-	    {
-		if (GlyphPicture(glyph)[scrno])
-		{
-		    FreePicture ((pointer) GlyphPicture (glyph)[scrno], 0);
-		    GlyphPicture(glyph)[scrno] = NULL;
-		}
-		(*ps->UnrealizeGlyph) (pScreen, glyph);
-	    }
-	}
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    GlyphPtr glyph;
+    int fdepth, i;
+    int scrno = pScreen->myNum;
+
+    for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++) {
+        if (!globalGlyphs[fdepth].hashSet)
+            continue;
+
+        for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++) {
+            glyph = globalGlyphs[fdepth].table[i].glyph;
+            if (glyph && glyph != DeletedGlyph) {
+                if (GlyphPicture(glyph)[scrno]) {
+                    FreePicture((pointer) GlyphPicture(glyph)[scrno], 0);
+                    GlyphPicture(glyph)[scrno] = NULL;
+                }
+                (*ps->UnrealizeGlyph) (pScreen, glyph);
+            }
+        }
     }
 }
 
 GlyphHashSetPtr
-FindGlyphHashSet (CARD32 filled)
+FindGlyphHashSet(CARD32 filled)
 {
-    int	i;
+    int i;
 
     for (i = 0; i < NGLYPHHASHSETS; i++)
-	if (glyphHashSets[i].entries >= filled)
-	    return &glyphHashSets[i];
+        if (glyphHashSets[i].entries >= filled)
+            return &glyphHashSets[i];
     return 0;
 }
 
 GlyphRefPtr
-FindGlyphRef (GlyphHashPtr	hash,
-	      CARD32		signature,
-	      Bool		match,
-	      unsigned char	sha1[20])
+FindGlyphRef(GlyphHashPtr hash,
+             CARD32 signature, Bool match, unsigned char sha1[20])
 {
-    CARD32	elt, step, s;
-    GlyphPtr	glyph;
-    GlyphRefPtr	table, gr, del;
-    CARD32	tableSize = hash->hashSet->size;
+    CARD32 elt, step, s;
+    GlyphPtr glyph;
+    GlyphRefPtr table, gr, del;
+    CARD32 tableSize = hash->hashSet->size;
 
     table = hash->table;
     elt = signature % tableSize;
     step = 0;
     del = 0;
-    for (;;)
-    {
-	gr = &table[elt];
-	s = gr->signature;
-	glyph = gr->glyph;
-	if (!glyph)
-	{
-	    if (del)
-		gr = del;
-	    break;
-	}
-	if (glyph == DeletedGlyph)
-	{
-	    if (!del)
-		del = gr;
-	    else if (gr == del)
-		break;
-	}
-	else if (s == signature &&
-		 (!match || 
-		  memcmp (glyph->sha1, sha1, 20) == 0))
-	{
-	    break;
-	}
-	if (!step)
-	{
-	    step = signature % hash->hashSet->rehash;
-	    if (!step)
-		step = 1;
-	}
-	elt += step;
-	if (elt >= tableSize)
-	    elt -= tableSize;
+    for (;;) {
+        gr = &table[elt];
+        s = gr->signature;
+        glyph = gr->glyph;
+        if (!glyph) {
+            if (del)
+                gr = del;
+            break;
+        }
+        if (glyph == DeletedGlyph) {
+            if (!del)
+                del = gr;
+            else if (gr == del)
+                break;
+        }
+        else if (s == signature &&
+                 (!match || memcmp(glyph->sha1, sha1, 20) == 0)) {
+            break;
+        }
+        if (!step) {
+            step = signature % hash->hashSet->rehash;
+            if (!step)
+                step = 1;
+        }
+        elt += step;
+        if (elt >= tableSize)
+            elt -= tableSize;
     }
     return gr;
 }
 
 int
-HashGlyph (xGlyphInfo    *gi,
-	   CARD8	 *bits,
-	   unsigned long size,
-	   unsigned char sha1[20])
+HashGlyph(xGlyphInfo * gi,
+          CARD8 *bits, unsigned long size, unsigned char sha1[20])
 {
     void *ctx = x_sha1_init();
     int success;
 
     if (!ctx)
-	return BadAlloc;
+        return BadAlloc;
 
     success = x_sha1_update(ctx, gi, sizeof(xGlyphInfo));
     if (!success)
-	return BadAlloc;
+        return BadAlloc;
     success = x_sha1_update(ctx, bits, size);
     if (!success)
-	return BadAlloc;
+        return BadAlloc;
     success = x_sha1_final(ctx, sha1);
     if (!success)
-	return BadAlloc;
+        return BadAlloc;
     return Success;
 }
 
 GlyphPtr
-FindGlyphByHash (unsigned char sha1[20], int format)
+FindGlyphByHash(unsigned char sha1[20], int format)
 {
     GlyphRefPtr gr;
     CARD32 signature = *(CARD32 *) sha1;
 
     if (!globalGlyphs[format].hashSet)
-	return NULL;
+        return NULL;
 
-    gr = FindGlyphRef (&globalGlyphs[format],
-		       signature, TRUE, sha1);
+    gr = FindGlyphRef(&globalGlyphs[format], signature, TRUE, sha1);
 
     if (gr->glyph && gr->glyph != DeletedGlyph)
-	return gr->glyph;
+        return gr->glyph;
     else
-	return NULL;
+        return NULL;
 }
 
 #ifdef CHECK_DUPLICATES
 void
-DuplicateRef (GlyphPtr glyph, char *where)
+DuplicateRef(GlyphPtr glyph, char *where)
 {
-    ErrorF ("Duplicate Glyph 0x%x from %s\n", glyph, where);
+    ErrorF("Duplicate Glyph 0x%x from %s\n", glyph, where);
 }
 
 void
-CheckDuplicates (GlyphHashPtr hash, char *where)
+CheckDuplicates(GlyphHashPtr hash, char *where)
 {
-    GlyphPtr	g;
-    int		i, j;
-
-    for (i = 0; i < hash->hashSet->size; i++)
-    {
-	g = hash->table[i].glyph;
-	if (!g || g == DeletedGlyph)
-	    continue;
-	for (j = i + 1; j < hash->hashSet->size; j++)
-	    if (hash->table[j].glyph == g)
-		DuplicateRef (g, where);
+    GlyphPtr g;
+    int i, j;
+
+    for (i = 0; i < hash->hashSet->size; i++) {
+        g = hash->table[i].glyph;
+        if (!g || g == DeletedGlyph)
+            continue;
+        for (j = i + 1; j < hash->hashSet->size; j++)
+            if (hash->table[j].glyph == g)
+                DuplicateRef(g, where);
     }
 }
 #else
@@ -252,497 +236,451 @@ FreeGlyphPicture(GlyphPtr glyph)
     PictureScreenPtr ps;
     int i;
 
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
+    for (i = 0; i < screenInfo.numScreens; i++) {
         ScreenPtr pScreen = screenInfo.screens[i];
 
         if (GlyphPicture(glyph)[i])
-            FreePicture ((pointer) GlyphPicture (glyph)[i], 0);
+            FreePicture((pointer) GlyphPicture(glyph)[i], 0);
 
-        ps = GetPictureScreenIfSet (pScreen);
+        ps = GetPictureScreenIfSet(pScreen);
         if (ps)
             (*ps->UnrealizeGlyph) (pScreen, glyph);
     }
 }
 
-
 void
-FreeGlyph (GlyphPtr glyph, int format)
+FreeGlyph(GlyphPtr glyph, int format)
 {
-    CheckDuplicates (&globalGlyphs[format], "FreeGlyph");
-    if (--glyph->refcnt == 0)
-    {
-	GlyphRefPtr      gr;
-	int	         i;
-	int	         first;
-	CARD32		 signature;
-
-	first = -1;
-	for (i = 0; i < globalGlyphs[format].hashSet->size; i++)
-	    if (globalGlyphs[format].table[i].glyph == glyph)
-	    {
-		if (first != -1)
-		    DuplicateRef (glyph, "FreeGlyph check");
-		first = i;
-	    }
-
-	signature = *(CARD32 *) glyph->sha1;
-	gr = FindGlyphRef (&globalGlyphs[format], signature,
-			   TRUE, glyph->sha1);
-	if (gr - globalGlyphs[format].table != first)
-	    DuplicateRef (glyph, "Found wrong one");
-	if (gr->glyph && gr->glyph != DeletedGlyph)
-	{
-	    gr->glyph = DeletedGlyph;
-	    gr->signature = 0;
-	    globalGlyphs[format].tableEntries--;
-	}
-
-	FreeGlyphPicture(glyph);
-	dixFreeObjectWithPrivates(glyph, PRIVATE_GLYPH);
+    CheckDuplicates(&globalGlyphs[format], "FreeGlyph");
+    if (--glyph->refcnt == 0) {
+        GlyphRefPtr gr;
+        int i;
+        int first;
+        CARD32 signature;
+
+        first = -1;
+        for (i = 0; i < globalGlyphs[format].hashSet->size; i++)
+            if (globalGlyphs[format].table[i].glyph == glyph) {
+                if (first != -1)
+                    DuplicateRef(glyph, "FreeGlyph check");
+                first = i;
+            }
+
+        signature = *(CARD32 *) glyph->sha1;
+        gr = FindGlyphRef(&globalGlyphs[format], signature, TRUE, glyph->sha1);
+        if (gr - globalGlyphs[format].table != first)
+            DuplicateRef(glyph, "Found wrong one");
+        if (gr->glyph && gr->glyph != DeletedGlyph) {
+            gr->glyph = DeletedGlyph;
+            gr->signature = 0;
+            globalGlyphs[format].tableEntries--;
+        }
+
+        FreeGlyphPicture(glyph);
+        dixFreeObjectWithPrivates(glyph, PRIVATE_GLYPH);
     }
 }
 
 void
-AddGlyph (GlyphSetPtr glyphSet, GlyphPtr glyph, Glyph id)
+AddGlyph(GlyphSetPtr glyphSet, GlyphPtr glyph, Glyph id)
 {
-    GlyphRefPtr	    gr;
-    CARD32	    signature;
+    GlyphRefPtr gr;
+    CARD32 signature;
 
-    CheckDuplicates (&globalGlyphs[glyphSet->fdepth], "AddGlyph top global");
+    CheckDuplicates(&globalGlyphs[glyphSet->fdepth], "AddGlyph top global");
     /* Locate existing matching glyph */
     signature = *(CARD32 *) glyph->sha1;
-    gr = FindGlyphRef (&globalGlyphs[glyphSet->fdepth], signature,
-		       TRUE, glyph->sha1);
-    if (gr->glyph && gr->glyph != DeletedGlyph && gr->glyph != glyph)
-    {
-	FreeGlyphPicture(glyph);
-	dixFreeObjectWithPrivates(glyph, PRIVATE_GLYPH);
-	glyph = gr->glyph;
+    gr = FindGlyphRef(&globalGlyphs[glyphSet->fdepth], signature,
+                      TRUE, glyph->sha1);
+    if (gr->glyph && gr->glyph != DeletedGlyph && gr->glyph != glyph) {
+        FreeGlyphPicture(glyph);
+        dixFreeObjectWithPrivates(glyph, PRIVATE_GLYPH);
+        glyph = gr->glyph;
     }
-    else if (gr->glyph != glyph)
-    {
-	gr->glyph = glyph;
-	gr->signature = signature;
-	globalGlyphs[glyphSet->fdepth].tableEntries++;
+    else if (gr->glyph != glyph) {
+        gr->glyph = glyph;
+        gr->signature = signature;
+        globalGlyphs[glyphSet->fdepth].tableEntries++;
     }
-    
+
     /* Insert/replace glyphset value */
-    gr = FindGlyphRef (&glyphSet->hash, id, FALSE, 0);
+    gr = FindGlyphRef(&glyphSet->hash, id, FALSE, 0);
     ++glyph->refcnt;
     if (gr->glyph && gr->glyph != DeletedGlyph)
-	FreeGlyph (gr->glyph, glyphSet->fdepth);
+        FreeGlyph(gr->glyph, glyphSet->fdepth);
     else
-	glyphSet->hash.tableEntries++;
+        glyphSet->hash.tableEntries++;
     gr->glyph = glyph;
     gr->signature = id;
-    CheckDuplicates (&globalGlyphs[glyphSet->fdepth], "AddGlyph bottom");
+    CheckDuplicates(&globalGlyphs[glyphSet->fdepth], "AddGlyph bottom");
 }
 
 Bool
-DeleteGlyph (GlyphSetPtr glyphSet, Glyph id)
+DeleteGlyph(GlyphSetPtr glyphSet, Glyph id)
 {
-    GlyphRefPtr     gr;
-    GlyphPtr	    glyph;
+    GlyphRefPtr gr;
+    GlyphPtr glyph;
 
-    gr = FindGlyphRef (&glyphSet->hash, id, FALSE, 0);
+    gr = FindGlyphRef(&glyphSet->hash, id, FALSE, 0);
     glyph = gr->glyph;
-    if (glyph && glyph != DeletedGlyph)
-    {
-	gr->glyph = DeletedGlyph;
-	glyphSet->hash.tableEntries--;
-	FreeGlyph (glyph, glyphSet->fdepth);
-	return TRUE;
+    if (glyph && glyph != DeletedGlyph) {
+        gr->glyph = DeletedGlyph;
+        glyphSet->hash.tableEntries--;
+        FreeGlyph(glyph, glyphSet->fdepth);
+        return TRUE;
     }
     return FALSE;
 }
 
 GlyphPtr
-FindGlyph (GlyphSetPtr glyphSet, Glyph id)
+FindGlyph(GlyphSetPtr glyphSet, Glyph id)
 {
-    GlyphPtr        glyph;
+    GlyphPtr glyph;
 
-    glyph = FindGlyphRef (&glyphSet->hash, id, FALSE, 0)->glyph;
+    glyph = FindGlyphRef(&glyphSet->hash, id, FALSE, 0)->glyph;
     if (glyph == DeletedGlyph)
-	glyph = 0;
+        glyph = 0;
     return glyph;
 }
 
 GlyphPtr
-AllocateGlyph (xGlyphInfo *gi, int fdepth)
+AllocateGlyph(xGlyphInfo * gi, int fdepth)
 {
     PictureScreenPtr ps;
-    int		     size;
-    GlyphPtr	     glyph;
-    int		     i;
-    int		     head_size;
+    int size;
+    GlyphPtr glyph;
+    int i;
+    int head_size;
 
-    head_size = sizeof (GlyphRec) + screenInfo.numScreens * sizeof (PicturePtr);
+    head_size = sizeof(GlyphRec) + screenInfo.numScreens * sizeof(PicturePtr);
     size = (head_size + dixPrivatesSize(PRIVATE_GLYPH));
-    glyph = (GlyphPtr) malloc (size);
+    glyph = (GlyphPtr) malloc(size);
     if (!glyph)
-	return 0;
+        return 0;
     glyph->refcnt = 0;
-    glyph->size = size + sizeof (xGlyphInfo);
+    glyph->size = size + sizeof(xGlyphInfo);
     glyph->info = *gi;
     dixInitPrivates(glyph, (char *) glyph + head_size, PRIVATE_GLYPH);
 
-    for (i = 0; i < screenInfo.numScreens; i++)
-    {
-	GlyphPicture(glyph)[i] = NULL;
-	ps = GetPictureScreenIfSet (screenInfo.screens[i]);
+    for (i = 0; i < screenInfo.numScreens; i++) {
+        GlyphPicture(glyph)[i] = NULL;
+        ps = GetPictureScreenIfSet(screenInfo.screens[i]);
 
-	if (ps)
-	{
-	    if (!(*ps->RealizeGlyph) (screenInfo.screens[i], glyph))
-		goto bail;
-	}
+        if (ps) {
+            if (!(*ps->RealizeGlyph) (screenInfo.screens[i], glyph))
+                goto bail;
+        }
     }
-    
+
     return glyph;
 
-bail:
-    while (i--)
-    {
-	ps = GetPictureScreenIfSet (screenInfo.screens[i]);
-	if (ps)
-	    (*ps->UnrealizeGlyph) (screenInfo.screens[i], glyph);
+ bail:
+    while (i--) {
+        ps = GetPictureScreenIfSet(screenInfo.screens[i]);
+        if (ps)
+            (*ps->UnrealizeGlyph) (screenInfo.screens[i], glyph);
     }
 
     dixFreeObjectWithPrivates(glyph, PRIVATE_GLYPH);
     return 0;
 }
-    
+
 Bool
-AllocateGlyphHash (GlyphHashPtr hash, GlyphHashSetPtr hashSet)
+AllocateGlyphHash(GlyphHashPtr hash, GlyphHashSetPtr hashSet)
 {
-    hash->table = calloc(hashSet->size, sizeof (GlyphRefRec));
+    hash->table = calloc(hashSet->size, sizeof(GlyphRefRec));
     if (!hash->table)
-	return FALSE;
+        return FALSE;
     hash->hashSet = hashSet;
     hash->tableEntries = 0;
     return TRUE;
 }
 
 Bool
-ResizeGlyphHash (GlyphHashPtr hash, CARD32 change, Bool global)
+ResizeGlyphHash(GlyphHashPtr hash, CARD32 change, Bool global)
 {
-    CARD32	    tableEntries;
+    CARD32 tableEntries;
     GlyphHashSetPtr hashSet;
-    GlyphHashRec    newHash;
-    GlyphRefPtr	    gr;
-    GlyphPtr	    glyph;
-    int		    i;
-    int		    oldSize;
-    CARD32	    s;
+    GlyphHashRec newHash;
+    GlyphRefPtr gr;
+    GlyphPtr glyph;
+    int i;
+    int oldSize;
+    CARD32 s;
 
     tableEntries = hash->tableEntries + change;
-    hashSet = FindGlyphHashSet (tableEntries);
+    hashSet = FindGlyphHashSet(tableEntries);
     if (hashSet == hash->hashSet)
-	return TRUE;
+        return TRUE;
     if (global)
-	CheckDuplicates (hash, "ResizeGlyphHash top");
-    if (!AllocateGlyphHash (&newHash, hashSet))
-	return FALSE;
-    if (hash->table)
-    {
-	oldSize = hash->hashSet->size;
-	for (i = 0; i < oldSize; i++)
-	{
-	    glyph = hash->table[i].glyph;
-	    if (glyph && glyph != DeletedGlyph)
-	    {
-		s = hash->table[i].signature;
-		gr = FindGlyphRef (&newHash, s, global, glyph->sha1);
-		gr->signature = s;
-		gr->glyph = glyph;
-		++newHash.tableEntries;
-	    }
-	}
-	free(hash->table);
+        CheckDuplicates(hash, "ResizeGlyphHash top");
+    if (!AllocateGlyphHash(&newHash, hashSet))
+        return FALSE;
+    if (hash->table) {
+        oldSize = hash->hashSet->size;
+        for (i = 0; i < oldSize; i++) {
+            glyph = hash->table[i].glyph;
+            if (glyph && glyph != DeletedGlyph) {
+                s = hash->table[i].signature;
+                gr = FindGlyphRef(&newHash, s, global, glyph->sha1);
+
+                gr->signature = s;
+                gr->glyph = glyph;
+                ++newHash.tableEntries;
+            }
+        }
+        free(hash->table);
     }
     *hash = newHash;
     if (global)
-	CheckDuplicates (hash, "ResizeGlyphHash bottom");
+        CheckDuplicates(hash, "ResizeGlyphHash bottom");
     return TRUE;
 }
 
 Bool
-ResizeGlyphSet (GlyphSetPtr glyphSet, CARD32 change)
+ResizeGlyphSet(GlyphSetPtr glyphSet, CARD32 change)
 {
-    return (ResizeGlyphHash (&glyphSet->hash, change, FALSE) &&
-	    ResizeGlyphHash (&globalGlyphs[glyphSet->fdepth], change, TRUE));
+    return (ResizeGlyphHash(&glyphSet->hash, change, FALSE) &&
+            ResizeGlyphHash(&globalGlyphs[glyphSet->fdepth], change, TRUE));
 }
-			    
+
 GlyphSetPtr
-AllocateGlyphSet (int fdepth, PictFormatPtr format)
+AllocateGlyphSet(int fdepth, PictFormatPtr format)
 {
-    GlyphSetPtr	glyphSet;
-    
-    if (!globalGlyphs[fdepth].hashSet)
-    {
-	if (!AllocateGlyphHash (&globalGlyphs[fdepth], &glyphHashSets[0]))
-	    return FALSE;
+    GlyphSetPtr glyphSet;
+
+    if (!globalGlyphs[fdepth].hashSet) {
+        if (!AllocateGlyphHash(&globalGlyphs[fdepth], &glyphHashSets[0]))
+            return FALSE;
     }
 
     glyphSet = dixAllocateObjectWithPrivates(GlyphSetRec, PRIVATE_GLYPHSET);
     if (!glyphSet)
-	return FALSE;
+        return FALSE;
 
-    if (!AllocateGlyphHash (&glyphSet->hash, &glyphHashSets[0]))
-    {
-	free(glyphSet);
-	return FALSE;
+    if (!AllocateGlyphHash(&glyphSet->hash, &glyphHashSets[0])) {
+        free(glyphSet);
+        return FALSE;
     }
     glyphSet->refcnt = 1;
     glyphSet->fdepth = fdepth;
     glyphSet->format = format;
-    return glyphSet;	
+    return glyphSet;
 }
 
 int
-FreeGlyphSet (pointer	value,
-	      XID       gid)
+FreeGlyphSet(pointer value, XID gid)
 {
-    GlyphSetPtr	glyphSet = (GlyphSetPtr) value;
-    
-    if (--glyphSet->refcnt == 0)
-    {
-	CARD32	    i, tableSize = glyphSet->hash.hashSet->size;
-	GlyphRefPtr table = glyphSet->hash.table;
-	GlyphPtr    glyph;
-    
-	for (i = 0; i < tableSize; i++)
-	{
-	    glyph = table[i].glyph;
-	    if (glyph && glyph != DeletedGlyph)
-		FreeGlyph (glyph, glyphSet->fdepth);
-	}
-	if (!globalGlyphs[glyphSet->fdepth].tableEntries)
-	{
-	    free(globalGlyphs[glyphSet->fdepth].table);
-	    globalGlyphs[glyphSet->fdepth].table = 0;
-	    globalGlyphs[glyphSet->fdepth].hashSet = 0;
-	}
-	else
-	    ResizeGlyphHash (&globalGlyphs[glyphSet->fdepth], 0, TRUE);
-	free(table);
-	dixFreeObjectWithPrivates(glyphSet, PRIVATE_GLYPHSET);
+    GlyphSetPtr glyphSet = (GlyphSetPtr) value;
+
+    if (--glyphSet->refcnt == 0) {
+        CARD32 i, tableSize = glyphSet->hash.hashSet->size;
+        GlyphRefPtr table = glyphSet->hash.table;
+        GlyphPtr glyph;
+
+        for (i = 0; i < tableSize; i++) {
+            glyph = table[i].glyph;
+            if (glyph && glyph != DeletedGlyph)
+                FreeGlyph(glyph, glyphSet->fdepth);
+        }
+        if (!globalGlyphs[glyphSet->fdepth].tableEntries) {
+            free(globalGlyphs[glyphSet->fdepth].table);
+            globalGlyphs[glyphSet->fdepth].table = 0;
+            globalGlyphs[glyphSet->fdepth].hashSet = 0;
+        }
+        else
+            ResizeGlyphHash(&globalGlyphs[glyphSet->fdepth], 0, TRUE);
+        free(table);
+        dixFreeObjectWithPrivates(glyphSet, PRIVATE_GLYPHSET);
     }
     return Success;
 }
 
 static void
-GlyphExtents (int		nlist,
-		GlyphListPtr	list,
-		GlyphPtr	*glyphs,
-		BoxPtr		extents)
+GlyphExtents(int nlist, GlyphListPtr list, GlyphPtr * glyphs, BoxPtr extents)
 {
-    int		x1, x2, y1, y2;
-    int		n;
-    GlyphPtr	glyph;
-    int		x, y;
-    
+    int x1, x2, y1, y2;
+    int n;
+    GlyphPtr glyph;
+    int x, y;
+
     x = 0;
     y = 0;
     extents->x1 = MAXSHORT;
     extents->x2 = MINSHORT;
     extents->y1 = MAXSHORT;
     extents->y2 = MINSHORT;
-    while (nlist--)
-    {
-	x += list->xOff;
-	y += list->yOff;
-	n = list->len;
-	list++;
-	while (n--)
-	{
-	    glyph = *glyphs++;
-	    x1 = x - glyph->info.x;
-	    if (x1 < MINSHORT)
-		x1 = MINSHORT;
-	    y1 = y - glyph->info.y;
-	    if (y1 < MINSHORT)
-		y1 = MINSHORT;
-	    x2 = x1 + glyph->info.width;
-	    if (x2 > MAXSHORT)
-		x2 = MAXSHORT;
-	    y2 = y1 + glyph->info.height;
-	    if (y2 > MAXSHORT)
-		y2 = MAXSHORT;
-	    if (x1 < extents->x1)
-		extents->x1 = x1;
-	    if (x2 > extents->x2)
-		extents->x2 = x2;
-	    if (y1 < extents->y1)
-		extents->y1 = y1;
-	    if (y2 > extents->y2)
-		extents->y2 = y2;
-	    x += glyph->info.xOff;
-	    y += glyph->info.yOff;
-	}
+    while (nlist--) {
+        x += list->xOff;
+        y += list->yOff;
+        n = list->len;
+        list++;
+        while (n--) {
+            glyph = *glyphs++;
+            x1 = x - glyph->info.x;
+            if (x1 < MINSHORT)
+                x1 = MINSHORT;
+            y1 = y - glyph->info.y;
+            if (y1 < MINSHORT)
+                y1 = MINSHORT;
+            x2 = x1 + glyph->info.width;
+            if (x2 > MAXSHORT)
+                x2 = MAXSHORT;
+            y2 = y1 + glyph->info.height;
+            if (y2 > MAXSHORT)
+                y2 = MAXSHORT;
+            if (x1 < extents->x1)
+                extents->x1 = x1;
+            if (x2 > extents->x2)
+                extents->x2 = x2;
+            if (y1 < extents->y1)
+                extents->y1 = y1;
+            if (y2 > extents->y2)
+                extents->y2 = y2;
+            x += glyph->info.xOff;
+            y += glyph->info.yOff;
+        }
     }
 }
 
 #define NeedsComponent(f) (PICT_FORMAT_A(f) != 0 && PICT_FORMAT_RGB(f) != 0)
 
 void
-CompositeGlyphs (CARD8		op,
-		 PicturePtr	pSrc,
-		 PicturePtr	pDst,
-		 PictFormatPtr	maskFormat,
-		 INT16		xSrc,
-		 INT16		ySrc,
-		 int		nlist,
-		 GlyphListPtr	lists,
-		 GlyphPtr	*glyphs)
+CompositeGlyphs(CARD8 op,
+                PicturePtr pSrc,
+                PicturePtr pDst,
+                PictFormatPtr maskFormat,
+                INT16 xSrc,
+                INT16 ySrc, int nlist, GlyphListPtr lists, GlyphPtr * glyphs)
 {
-    PictureScreenPtr	ps = GetPictureScreen(pDst->pDrawable->pScreen);
+    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);
 
-    ValidatePicture (pSrc);
-    ValidatePicture (pDst);
-    (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, lists, glyphs);
+    ValidatePicture(pSrc);
+    ValidatePicture(pDst);
+    (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, lists,
+                   glyphs);
 }
 
 Bool
-miRealizeGlyph (ScreenPtr pScreen,
-		GlyphPtr  glyph)
+miRealizeGlyph(ScreenPtr pScreen, GlyphPtr glyph)
 {
     return TRUE;
 }
 
 void
-miUnrealizeGlyph (ScreenPtr pScreen,
-		  GlyphPtr  glyph)
+miUnrealizeGlyph(ScreenPtr pScreen, GlyphPtr glyph)
 {
 }
 
 void
-miGlyphs (CARD8		op,
-	  PicturePtr	pSrc,
-	  PicturePtr	pDst,
-	  PictFormatPtr	maskFormat,
-	  INT16		xSrc,
-	  INT16		ySrc,
-	  int		nlist,
-	  GlyphListPtr	list,
-	  GlyphPtr	*glyphs)
+miGlyphs(CARD8 op,
+         PicturePtr pSrc,
+         PicturePtr pDst,
+         PictFormatPtr maskFormat,
+         INT16 xSrc,
+         INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
 {
-    PicturePtr	pPicture;
-    PixmapPtr   pMaskPixmap = 0;
-    PicturePtr  pMask;
-    ScreenPtr   pScreen = pDst->pDrawable->pScreen;
-    int		width = 0, height = 0;
-    int		x, y;
-    int		xDst = list->xOff, yDst = list->yOff;
-    int		n;
-    GlyphPtr	glyph;
-    int		error;
-    BoxRec	extents = {0, 0, 0, 0};
-    CARD32	component_alpha;
-
-    if (maskFormat)
-    {
-	GCPtr	    pGC;
-	xRectangle  rect;
-
-	GlyphExtents (nlist, list, glyphs, &extents);
-
-	if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
-	    return;
-	width = extents.x2 - extents.x1;
-	height = extents.y2 - extents.y1;
-	pMaskPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
-						maskFormat->depth,
-						CREATE_PIXMAP_USAGE_SCRATCH);
-	if (!pMaskPixmap)
-	    return;
-	component_alpha = NeedsComponent(maskFormat->format);
-	pMask = CreatePicture (0, &pMaskPixmap->drawable,
-			       maskFormat, CPComponentAlpha, &component_alpha,
-			       serverClient, &error);
-	if (!pMask)
-	{
-	    (*pScreen->DestroyPixmap) (pMaskPixmap);
-	    return;
-	}
-	pGC = GetScratchGC (pMaskPixmap->drawable.depth, pScreen);
-	ValidateGC (&pMaskPixmap->drawable, pGC);
-	rect.x = 0;
-	rect.y = 0;
-	rect.width = width;
-	rect.height = height;
-	(*pGC->ops->PolyFillRect) (&pMaskPixmap->drawable, pGC, 1, &rect);
-	FreeScratchGC (pGC);
-	x = -extents.x1;
-	y = -extents.y1;
+    PicturePtr pPicture;
+    PixmapPtr pMaskPixmap = 0;
+    PicturePtr pMask;
+    ScreenPtr pScreen = pDst->pDrawable->pScreen;
+    int width = 0, height = 0;
+    int x, y;
+    int xDst = list->xOff, yDst = list->yOff;
+    int n;
+    GlyphPtr glyph;
+    int error;
+    BoxRec extents = { 0, 0, 0, 0 };
+    CARD32 component_alpha;
+
+    if (maskFormat) {
+        GCPtr pGC;
+        xRectangle rect;
+
+        GlyphExtents(nlist, list, glyphs, &extents);
+
+        if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
+            return;
+        width = extents.x2 - extents.x1;
+        height = extents.y2 - extents.y1;
+        pMaskPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
+                                                maskFormat->depth,
+                                                CREATE_PIXMAP_USAGE_SCRATCH);
+        if (!pMaskPixmap)
+            return;
+        component_alpha = NeedsComponent(maskFormat->format);
+        pMask = CreatePicture(0, &pMaskPixmap->drawable,
+                              maskFormat, CPComponentAlpha, &component_alpha,
+                              serverClient, &error);
+        if (!pMask) {
+            (*pScreen->DestroyPixmap) (pMaskPixmap);
+            return;
+        }
+        pGC = GetScratchGC(pMaskPixmap->drawable.depth, pScreen);
+        ValidateGC(&pMaskPixmap->drawable, pGC);
+        rect.x = 0;
+        rect.y = 0;
+        rect.width = width;
+        rect.height = height;
+        (*pGC->ops->PolyFillRect) (&pMaskPixmap->drawable, pGC, 1, &rect);
+        FreeScratchGC(pGC);
+        x = -extents.x1;
+        y = -extents.y1;
     }
-    else
-    {
-	pMask = pDst;
-	x = 0;
-	y = 0;
+    else {
+        pMask = pDst;
+        x = 0;
+        y = 0;
     }
-    while (nlist--)
-    {
-	x += list->xOff;
-	y += list->yOff;
-	n = list->len;
-	while (n--)
-	{
-	    glyph = *glyphs++;
-	    pPicture = GlyphPicture (glyph)[pScreen->myNum];
-
-	    if (pPicture)
-	    {
-		if (maskFormat)
-		{
-			CompositePicture (PictOpAdd,
-					  pPicture,
-					  None,
-					  pMask,
-					  0, 0,
-					  0, 0,
-					  x - glyph->info.x,
-					  y - glyph->info.y,
-					  glyph->info.width,
-					  glyph->info.height);
-		}
-		else
-		{
-		    CompositePicture (op,
-				      pSrc,
-				      pPicture,
-				      pDst,
-				      xSrc + (x - glyph->info.x) - xDst,
-				      ySrc + (y - glyph->info.y) - yDst,
-				      0, 0,
-				      x - glyph->info.x,
-				      y - glyph->info.y,
-				      glyph->info.width,
-				      glyph->info.height);
-		}
-	    }
-
-	    x += glyph->info.xOff;
-	    y += glyph->info.yOff;
-	}
-	list++;
+    while (nlist--) {
+        x += list->xOff;
+        y += list->yOff;
+        n = list->len;
+        while (n--) {
+            glyph = *glyphs++;
+            pPicture = GlyphPicture(glyph)[pScreen->myNum];
+
+            if (pPicture) {
+                if (maskFormat) {
+                    CompositePicture(PictOpAdd,
+                                     pPicture,
+                                     None,
+                                     pMask,
+                                     0, 0,
+                                     0, 0,
+                                     x - glyph->info.x,
+                                     y - glyph->info.y,
+                                     glyph->info.width, glyph->info.height);
+                }
+                else {
+                    CompositePicture(op,
+                                     pSrc,
+                                     pPicture,
+                                     pDst,
+                                     xSrc + (x - glyph->info.x) - xDst,
+                                     ySrc + (y - glyph->info.y) - yDst,
+                                     0, 0,
+                                     x - glyph->info.x,
+                                     y - glyph->info.y,
+                                     glyph->info.width, glyph->info.height);
+                }
+            }
+
+            x += glyph->info.xOff;
+            y += glyph->info.yOff;
+        }
+        list++;
     }
-    if (maskFormat)
-    {
-	x = extents.x1;
-	y = extents.y1;
-	CompositePicture (op,
-			  pSrc,
-			  pMask,
-			  pDst,
-			  xSrc + x - xDst,
-			  ySrc + y - yDst,
-			  0, 0,
-			  x, y,
-			  width, height);
-	FreePicture ((pointer) pMask, (XID) 0);
-	(*pScreen->DestroyPixmap) (pMaskPixmap);
+    if (maskFormat) {
+        x = extents.x1;
+        y = extents.y1;
+        CompositePicture(op,
+                         pSrc,
+                         pMask,
+                         pDst,
+                         xSrc + x - xDst,
+                         ySrc + y - yDst, 0, 0, x, y, width, height);
+        FreePicture((pointer) pMask, (XID) 0);
+        (*pScreen->DestroyPixmap) (pMaskPixmap);
     }
 }
diff --git a/render/glyphstr.h b/render/glyphstr.h
index 49b4b54dd..cbc4751f0 100644
--- a/render/glyphstr.h
+++ b/render/glyphstr.h
@@ -40,41 +40,41 @@
 #define GlyphFormatNum	5
 
 typedef struct _Glyph {
-    CARD32	    refcnt;
-    PrivateRec	*devPrivates;
-    unsigned char   sha1[20];
-    CARD32	    size; /* info + bitmap */
-    xGlyphInfo	    info;
+    CARD32 refcnt;
+    PrivateRec *devPrivates;
+    unsigned char sha1[20];
+    CARD32 size;                /* info + bitmap */
+    xGlyphInfo info;
     /* per-screen pixmaps follow */
 } GlyphRec, *GlyphPtr;
 
 #define GlyphPicture(glyph) ((PicturePtr *) ((glyph) + 1))
 
 typedef struct _GlyphRef {
-    CARD32	signature;
-    GlyphPtr	glyph;
+    CARD32 signature;
+    GlyphPtr glyph;
 } GlyphRefRec, *GlyphRefPtr;
 
 #define DeletedGlyph	((GlyphPtr) 1)
 
 typedef struct _GlyphHashSet {
-    CARD32	entries;
-    CARD32	size;
-    CARD32	rehash;
+    CARD32 entries;
+    CARD32 size;
+    CARD32 rehash;
 } GlyphHashSetRec, *GlyphHashSetPtr;
 
 typedef struct _GlyphHash {
-    GlyphRefPtr	    table;
+    GlyphRefPtr table;
     GlyphHashSetPtr hashSet;
-    CARD32	    tableEntries;
+    CARD32 tableEntries;
 } GlyphHashRec, *GlyphHashPtr;
 
 typedef struct _GlyphSet {
-    CARD32	    refcnt;
-    int		    fdepth;
-    PictFormatPtr   format;
-    GlyphHashRec    hash;
-    PrivateRec      *devPrivates;
+    CARD32 refcnt;
+    int fdepth;
+    PictFormatPtr format;
+    GlyphHashRec hash;
+    PrivateRec *devPrivates;
 } GlyphSetRec, *GlyphSetPtr;
 
 #define GlyphSetGetPrivate(pGlyphSet,k)					\
@@ -84,64 +84,53 @@ typedef struct _GlyphSet {
     dixSetPrivate(&(pGlyphSet)->devPrivates, k, ptr)
 
 typedef struct _GlyphList {
-    INT16	    xOff;
-    INT16	    yOff;
-    CARD8	    len;
-    PictFormatPtr   format;
+    INT16 xOff;
+    INT16 yOff;
+    CARD8 len;
+    PictFormatPtr format;
 } GlyphListRec, *GlyphListPtr;
 
 extern _X_EXPORT void
-GlyphUninit (ScreenPtr pScreen);
+ GlyphUninit(ScreenPtr pScreen);
 
-extern _X_EXPORT GlyphHashSetPtr
-FindGlyphHashSet (CARD32 filled);
+extern _X_EXPORT GlyphHashSetPtr FindGlyphHashSet(CARD32 filled);
 
 extern _X_EXPORT GlyphRefPtr
-FindGlyphRef (GlyphHashPtr	hash,
-	      CARD32		signature,
-	      Bool		match,
-	      unsigned char	sha1[20]);
+FindGlyphRef(GlyphHashPtr hash,
+             CARD32 signature, Bool match, unsigned char sha1[20]);
 
-extern _X_EXPORT GlyphPtr
-FindGlyphByHash (unsigned char sha1[20], int format);
+extern _X_EXPORT GlyphPtr FindGlyphByHash(unsigned char sha1[20], int format);
 
 extern _X_EXPORT int
-HashGlyph (xGlyphInfo    *gi,
-	   CARD8	 *bits,
-	   unsigned long size,
-	   unsigned char sha1[20]);
+
+HashGlyph(xGlyphInfo * gi,
+          CARD8 *bits, unsigned long size, unsigned char sha1[20]);
 
 extern _X_EXPORT void
-FreeGlyph (GlyphPtr glyph, int format);
+ FreeGlyph(GlyphPtr glyph, int format);
 
 extern _X_EXPORT void
-AddGlyph (GlyphSetPtr glyphSet, GlyphPtr glyph, Glyph id);
+ AddGlyph(GlyphSetPtr glyphSet, GlyphPtr glyph, Glyph id);
 
 extern _X_EXPORT Bool
-DeleteGlyph (GlyphSetPtr glyphSet, Glyph id);
+ DeleteGlyph(GlyphSetPtr glyphSet, Glyph id);
 
-extern _X_EXPORT GlyphPtr
-FindGlyph (GlyphSetPtr glyphSet, Glyph id);
+extern _X_EXPORT GlyphPtr FindGlyph(GlyphSetPtr glyphSet, Glyph id);
 
-extern _X_EXPORT GlyphPtr
-AllocateGlyph (xGlyphInfo *gi, int format);
+extern _X_EXPORT GlyphPtr AllocateGlyph(xGlyphInfo * gi, int format);
 
 extern _X_EXPORT Bool
-AllocateGlyphHash (GlyphHashPtr hash, GlyphHashSetPtr hashSet);
+ AllocateGlyphHash(GlyphHashPtr hash, GlyphHashSetPtr hashSet);
 
 extern _X_EXPORT Bool
-ResizeGlyphHash (GlyphHashPtr hash, CARD32 change, Bool global);
+ ResizeGlyphHash(GlyphHashPtr hash, CARD32 change, Bool global);
 
 extern _X_EXPORT Bool
-ResizeGlyphSet (GlyphSetPtr glyphSet, CARD32 change);
+ ResizeGlyphSet(GlyphSetPtr glyphSet, CARD32 change);
 
-extern _X_EXPORT GlyphSetPtr
-AllocateGlyphSet (int fdepth, PictFormatPtr format);
+extern _X_EXPORT GlyphSetPtr AllocateGlyphSet(int fdepth, PictFormatPtr format);
 
 extern _X_EXPORT int
-FreeGlyphSet (pointer   value,
-	      XID       gid);
-
-
+ FreeGlyphSet(pointer value, XID gid);
 
-#endif /* _GLYPHSTR_H_ */
+#endif                          /* _GLYPHSTR_H_ */
diff --git a/render/matrix.c b/render/matrix.c
index eccb90270..83cd66c43 100644
--- a/render/matrix.c
+++ b/render/matrix.c
@@ -40,8 +40,8 @@
 #include "picturestr.h"
 
 void
-PictTransform_from_xRenderTransform (PictTransformPtr pict,
-				     xRenderTransform *render)
+PictTransform_from_xRenderTransform(PictTransformPtr pict,
+                                    xRenderTransform * render)
 {
     pict->matrix[0][0] = render->matrix11;
     pict->matrix[0][1] = render->matrix12;
@@ -57,8 +57,8 @@ PictTransform_from_xRenderTransform (PictTransformPtr pict,
 }
 
 void
-xRenderTransform_from_PictTransform (xRenderTransform *render,
-				     PictTransformPtr pict)
+xRenderTransform_from_PictTransform(xRenderTransform * render,
+                                    PictTransformPtr pict)
 {
     render->matrix11 = pict->matrix[0][0];
     render->matrix12 = pict->matrix[0][1];
@@ -74,15 +74,13 @@ xRenderTransform_from_PictTransform (xRenderTransform *render,
 }
 
 Bool
-PictureTransformPoint (PictTransformPtr transform,
-		       PictVectorPtr	vector)
+PictureTransformPoint(PictTransformPtr transform, PictVectorPtr vector)
 {
-	return pixman_transform_point(transform, vector);
+    return pixman_transform_point(transform, vector);
 }
 
 Bool
-PictureTransformPoint3d (PictTransformPtr transform,
-                         PictVectorPtr	vector)
+PictureTransformPoint3d(PictTransformPtr transform, PictVectorPtr vector)
 {
-	return pixman_transform_point_3d(transform, vector);
+    return pixman_transform_point_3d(transform, vector);
 }
diff --git a/render/miindex.c b/render/miindex.c
index 4603136a4..0375e8f88 100644
--- a/render/miindex.c
+++ b/render/miindex.c
@@ -41,254 +41,240 @@
 #define NUM_GRAY_LEVELS	13
 
 static Bool
-miBuildRenderColormap (ColormapPtr  pColormap, Pixel *pixels, int *nump)
+miBuildRenderColormap(ColormapPtr pColormap, Pixel * pixels, int *nump)
 {
-    int		r, g, b;
-    unsigned short  red, green, blue;
-    Pixel	pixel;
-    Bool	used[MI_MAX_INDEXED];
-    int		needed;
-    int		policy;
-    int		cube, gray;
-    int		i, n;
-    
-    if (pColormap->mid != pColormap->pScreen->defColormap)
-    {
-	policy = PictureCmapPolicyAll;
+    int r, g, b;
+    unsigned short red, green, blue;
+    Pixel pixel;
+    Bool used[MI_MAX_INDEXED];
+    int needed;
+    int policy;
+    int cube, gray;
+    int i, n;
+
+    if (pColormap->mid != pColormap->pScreen->defColormap) {
+        policy = PictureCmapPolicyAll;
     }
-    else
-    {
-	int	avail = pColormap->pVisual->ColormapEntries;
-	policy = PictureCmapPolicy;
-	if (policy == PictureCmapPolicyDefault)
-	{
-	    if (avail >= 256 && (pColormap->pVisual->class|DynamicClass) == PseudoColor)
-		policy = PictureCmapPolicyColor;
-	    else if (avail >= 64)
-		policy = PictureCmapPolicyGray;
-	    else
-		policy = PictureCmapPolicyMono;
-	}
+    else {
+        int avail = pColormap->pVisual->ColormapEntries;
+
+        policy = PictureCmapPolicy;
+        if (policy == PictureCmapPolicyDefault) {
+            if (avail >= 256 &&
+                (pColormap->pVisual->class | DynamicClass) == PseudoColor)
+                policy = PictureCmapPolicyColor;
+            else if (avail >= 64)
+                policy = PictureCmapPolicyGray;
+            else
+                policy = PictureCmapPolicyMono;
+        }
     }
     /*
      * Make sure enough cells are free for the chosen policy
      */
-    for (;;)
-    {
-	switch (policy) {
-	case PictureCmapPolicyAll:
-	    needed = 0;
-	    break;
-	case PictureCmapPolicyColor:
-	    needed = 71;
-	    break;
-	case PictureCmapPolicyGray:
-	    needed = 11;
-	    break;
-	case PictureCmapPolicyMono:
-	default:
-	    needed = 0;
-	    break;
-	}
-	if (needed <= pColormap->freeRed)
-	    break;
-	policy--;
-    } 
-    
+    for (;;) {
+        switch (policy) {
+        case PictureCmapPolicyAll:
+            needed = 0;
+            break;
+        case PictureCmapPolicyColor:
+            needed = 71;
+            break;
+        case PictureCmapPolicyGray:
+            needed = 11;
+            break;
+        case PictureCmapPolicyMono:
+        default:
+            needed = 0;
+            break;
+        }
+        if (needed <= pColormap->freeRed)
+            break;
+        policy--;
+    }
+
     /*
      * Compute size of cube and gray ramps
      */
     cube = gray = 0;
     switch (policy) {
     case PictureCmapPolicyAll:
-	/*
-	 * Allocate as big a cube as possible
-	 */
-	if ((pColormap->pVisual->class|DynamicClass) == PseudoColor)
-	{
-	    for (cube = 1; cube * cube * cube < pColormap->pVisual->ColormapEntries; cube++)
-		;
-	    cube--;
-	    if (cube == 1)
-		cube = 0;
-	}
-	else
-	    cube = 0;
-	/*
-	 * Figure out how many gray levels to use so that they
-	 * line up neatly with the cube
-	 */
-	if (cube)
-	{
-	    needed = pColormap->pVisual->ColormapEntries - (cube*cube*cube);
-	    /* levels to fill in with */
-	    gray = needed / (cube - 1);
-	    /* total levels */
-	    gray = (gray + 1) * (cube - 1) + 1;
-	}
-	else
-	    gray = pColormap->pVisual->ColormapEntries;
-	break;
-		
+        /*
+         * Allocate as big a cube as possible
+         */
+        if ((pColormap->pVisual->class | DynamicClass) == PseudoColor) {
+            for (cube = 1;
+                 cube * cube * cube < pColormap->pVisual->ColormapEntries;
+                 cube++);
+            cube--;
+            if (cube == 1)
+                cube = 0;
+        }
+        else
+            cube = 0;
+        /*
+         * Figure out how many gray levels to use so that they
+         * line up neatly with the cube
+         */
+        if (cube) {
+            needed = pColormap->pVisual->ColormapEntries - (cube * cube * cube);
+            /* levels to fill in with */
+            gray = needed / (cube - 1);
+            /* total levels */
+            gray = (gray + 1) * (cube - 1) + 1;
+        }
+        else
+            gray = pColormap->pVisual->ColormapEntries;
+        break;
+
     case PictureCmapPolicyColor:
-	cube = NUM_CUBE_LEVELS;
-	/* fall through ... */
+        cube = NUM_CUBE_LEVELS;
+        /* fall through ... */
     case PictureCmapPolicyGray:
-	gray = NUM_GRAY_LEVELS;
-	break;
+        gray = NUM_GRAY_LEVELS;
+        break;
     case PictureCmapPolicyMono:
     default:
-	gray = 2;
-	break;
+        gray = 2;
+        break;
     }
-    
-    memset (used, '\0', pColormap->pVisual->ColormapEntries * sizeof (Bool));
+
+    memset(used, '\0', pColormap->pVisual->ColormapEntries * sizeof(Bool));
     for (r = 0; r < cube; r++)
-	for (g = 0; g < cube; g++)
-	    for (b = 0; b < cube; b++)
-	    {
-		pixel = 0;
-		red = (r * 65535 + (cube-1)/2) / (cube - 1);
-		green = (g * 65535 + (cube-1)/2) / (cube - 1);
-		blue = (b * 65535 + (cube-1)/2) / (cube - 1);
-		if (AllocColor (pColormap, &red, &green, 
-				&blue, &pixel, 0) != Success)
-		    return FALSE;
-		used[pixel] = TRUE;
-	    }
-    for (g = 0; g < gray; g++)
-    {
-	pixel = 0;
-	red = green = blue = (g * 65535 + (gray-1)/2) / (gray - 1);
-	if (AllocColor (pColormap, &red, &green, &blue, &pixel, 0) != Success)
-	    return FALSE;
-	used[pixel] = TRUE;
+        for (g = 0; g < cube; g++)
+            for (b = 0; b < cube; b++) {
+                pixel = 0;
+                red = (r * 65535 + (cube - 1) / 2) / (cube - 1);
+                green = (g * 65535 + (cube - 1) / 2) / (cube - 1);
+                blue = (b * 65535 + (cube - 1) / 2) / (cube - 1);
+                if (AllocColor(pColormap, &red, &green,
+                               &blue, &pixel, 0) != Success)
+                    return FALSE;
+                used[pixel] = TRUE;
+            }
+    for (g = 0; g < gray; g++) {
+        pixel = 0;
+        red = green = blue = (g * 65535 + (gray - 1) / 2) / (gray - 1);
+        if (AllocColor(pColormap, &red, &green, &blue, &pixel, 0) != Success)
+            return FALSE;
+        used[pixel] = TRUE;
     }
     n = 0;
     for (i = 0; i < pColormap->pVisual->ColormapEntries; i++)
-	if (used[i])
-	    pixels[n++] = i;
+        if (used[i])
+            pixels[n++] = i;
 
     *nump = n;
-    
+
     return TRUE;
 }
 
 /* 0 <= red, green, blue < 32 */
 static Pixel
-FindBestColor (miIndexedPtr pIndexed, Pixel *pixels, int num,
-	       int red, int green, int blue)
+FindBestColor(miIndexedPtr pIndexed, Pixel * pixels, int num,
+              int red, int green, int blue)
 {
-    Pixel   best = pixels[0];
-    int	    bestDist = 1 << 30;
-    int	    dist;
-    int	    dr, dg, db;
-    while (num--)
-    {
-	Pixel	pixel = *pixels++;
-	CARD32	v = pIndexed->rgba[pixel];
+    Pixel best = pixels[0];
+    int bestDist = 1 << 30;
+    int dist;
+    int dr, dg, db;
 
-	dr = ((v >> 19) & 0x1f);
-	dg = ((v >> 11) & 0x1f);
-	db = ((v >> 3) & 0x1f);
-	dr = dr - red;
-	dg = dg - green;
-	db = db - blue;
-	dist = dr * dr + dg * dg + db * db;
-	if (dist < bestDist)
-	{
-	    bestDist = dist;
-	    best = pixel;
-	}
+    while (num--) {
+        Pixel pixel = *pixels++;
+        CARD32 v = pIndexed->rgba[pixel];
+
+        dr = ((v >> 19) & 0x1f);
+        dg = ((v >> 11) & 0x1f);
+        db = ((v >> 3) & 0x1f);
+        dr = dr - red;
+        dg = dg - green;
+        db = db - blue;
+        dist = dr * dr + dg * dg + db * db;
+        if (dist < bestDist) {
+            bestDist = dist;
+            best = pixel;
+        }
     }
     return best;
 }
 
 /* 0 <= gray < 32768 */
 static Pixel
-FindBestGray (miIndexedPtr pIndexed, Pixel *pixels, int num, int gray)
+FindBestGray(miIndexedPtr pIndexed, Pixel * pixels, int num, int gray)
 {
-    Pixel   best = pixels[0];
-    int	    bestDist = 1 << 30;
-    int	    dist;
-    int	    dr;
-    int	    r;
-    
-    while (num--)
-    {
-	Pixel   pixel = *pixels++;
-	CARD32	v = pIndexed->rgba[pixel];
+    Pixel best = pixels[0];
+    int bestDist = 1 << 30;
+    int dist;
+    int dr;
+    int r;
+
+    while (num--) {
+        Pixel pixel = *pixels++;
+        CARD32 v = pIndexed->rgba[pixel];
 
-	r = v & 0xff;
-	r = r | (r << 8);
-	dr = gray - (r >> 1);
-	dist = dr * dr;
-	if (dist < bestDist)
-	{
-	    bestDist = dist;
-	    best = pixel;
-	}
+        r = v & 0xff;
+        r = r | (r << 8);
+        dr = gray - (r >> 1);
+        dist = dr * dr;
+        if (dist < bestDist) {
+            bestDist = dist;
+            best = pixel;
+        }
     }
     return best;
 }
 
 Bool
-miInitIndexed (ScreenPtr	pScreen,
-	       PictFormatPtr	pFormat)
+miInitIndexed(ScreenPtr pScreen, PictFormatPtr pFormat)
 {
-    ColormapPtr	    pColormap = pFormat->index.pColormap;
-    VisualPtr	    pVisual = pColormap->pVisual;
-    miIndexedPtr    pIndexed;
-    Pixel	    pixels[MI_MAX_INDEXED];
-    xrgb	    rgb[MI_MAX_INDEXED];
-    int		    num;
-    int		    i;
-    Pixel	    p, r, g, b;
+    ColormapPtr pColormap = pFormat->index.pColormap;
+    VisualPtr pVisual = pColormap->pVisual;
+    miIndexedPtr pIndexed;
+    Pixel pixels[MI_MAX_INDEXED];
+    xrgb rgb[MI_MAX_INDEXED];
+    int num;
+    int i;
+    Pixel p, r, g, b;
 
     if (pVisual->ColormapEntries > MI_MAX_INDEXED)
-	return FALSE;
-    
-    if (pVisual->class & DynamicClass)
-    {
-	if (!miBuildRenderColormap (pColormap, pixels, &num))
-	    return FALSE;
+        return FALSE;
+
+    if (pVisual->class & DynamicClass) {
+        if (!miBuildRenderColormap(pColormap, pixels, &num))
+            return FALSE;
     }
-    else
-    {
-	num = pVisual->ColormapEntries;
-	for (p = 0; p < num; p++)
-	    pixels[p] = p;
+    else {
+        num = pVisual->ColormapEntries;
+        for (p = 0; p < num; p++)
+            pixels[p] = p;
     }
-    
-    pIndexed = malloc(sizeof (miIndexedRec));
+
+    pIndexed = malloc(sizeof(miIndexedRec));
     if (!pIndexed)
-	return FALSE;
-    
+        return FALSE;
+
     pFormat->index.nvalues = num;
-    pFormat->index.pValues = malloc(num * sizeof (xIndexValue));
-    if (!pFormat->index.pValues)
-    {
-	free(pIndexed);
-	return FALSE;
+    pFormat->index.pValues = malloc(num * sizeof(xIndexValue));
+    if (!pFormat->index.pValues) {
+        free(pIndexed);
+        return FALSE;
     }
-    
-    
+
     /*
      * Build mapping from pixel value to ARGB
      */
-    QueryColors (pColormap, num, pixels, rgb, serverClient);
-    for (i = 0; i < num; i++)
-    {
-	p = pixels[i];
-	pFormat->index.pValues[i].pixel = p;
-	pFormat->index.pValues[i].red   = rgb[i].red;
-	pFormat->index.pValues[i].green = rgb[i].green;
-	pFormat->index.pValues[i].blue  = rgb[i].blue;
-	pFormat->index.pValues[i].alpha = 0xffff;
-	pIndexed->rgba[p] = (0xff000000 |
-			     ((rgb[i].red   & 0xff00) << 8) |
-			     ((rgb[i].green & 0xff00)     ) |
-			     ((rgb[i].blue  & 0xff00) >> 8));
+    QueryColors(pColormap, num, pixels, rgb, serverClient);
+    for (i = 0; i < num; i++) {
+        p = pixels[i];
+        pFormat->index.pValues[i].pixel = p;
+        pFormat->index.pValues[i].red = rgb[i].red;
+        pFormat->index.pValues[i].green = rgb[i].green;
+        pFormat->index.pValues[i].blue = rgb[i].blue;
+        pFormat->index.pValues[i].alpha = 0xffff;
+        pIndexed->rgba[p] = (0xff000000 |
+                             ((rgb[i].red & 0xff00) << 8) |
+                             ((rgb[i].green & 0xff00)) |
+                             ((rgb[i].blue & 0xff00) >> 8));
     }
 
     /*
@@ -297,30 +283,28 @@ miInitIndexed (ScreenPtr	pScreen,
      */
     switch (pVisual->class | DynamicClass) {
     case GrayScale:
-	pIndexed->color = FALSE;
-	for (r = 0; r < 32768; r++)
-	    pIndexed->ent[r] = FindBestGray (pIndexed, pixels, num, r);
-	break;
+        pIndexed->color = FALSE;
+        for (r = 0; r < 32768; r++)
+            pIndexed->ent[r] = FindBestGray(pIndexed, pixels, num, r);
+        break;
     case PseudoColor:
-	pIndexed->color = TRUE;
-	p = 0;
-	for (r = 0; r < 32; r++)
-	    for (g = 0; g < 32; g++)
-		for (b = 0; b < 32; b++)
-		{
-		    pIndexed->ent[p] = FindBestColor (pIndexed, pixels, num,
-						      r, g, b);
-		    p++;
-		}
-	break;
+        pIndexed->color = TRUE;
+        p = 0;
+        for (r = 0; r < 32; r++)
+            for (g = 0; g < 32; g++)
+                for (b = 0; b < 32; b++) {
+                    pIndexed->ent[p] = FindBestColor(pIndexed, pixels, num,
+                                                     r, g, b);
+                    p++;
+                }
+        break;
     }
     pFormat->index.devPrivate = pIndexed;
     return TRUE;
 }
 
 void
-miCloseIndexed (ScreenPtr	pScreen,
-		PictFormatPtr	pFormat)
+miCloseIndexed(ScreenPtr pScreen, PictFormatPtr pFormat)
 {
     free(pFormat->index.devPrivate);
     pFormat->index.devPrivate = NULL;
@@ -329,24 +313,20 @@ miCloseIndexed (ScreenPtr	pScreen,
 }
 
 void
-miUpdateIndexed (ScreenPtr	pScreen,
-		 PictFormatPtr	pFormat,
-		 int		ndef,
-		 xColorItem	*pdef)
+miUpdateIndexed(ScreenPtr pScreen,
+                PictFormatPtr pFormat, int ndef, xColorItem * pdef)
 {
     miIndexedPtr pIndexed = pFormat->index.devPrivate;
 
-    if (pIndexed)
-    {
-	while (ndef--)
-	{
-	    pIndexed->rgba[pdef->pixel] = (0xff000000 |
-					   ((pdef->red   & 0xff00) << 8) |
-					   ((pdef->green & 0xff00)     ) |
-					   ((pdef->blue  & 0xff00) >> 8));
-	    pdef++;
-	}
+    if (pIndexed) {
+        while (ndef--) {
+            pIndexed->rgba[pdef->pixel] = (0xff000000 |
+                                           ((pdef->red & 0xff00) << 8) |
+                                           ((pdef->green & 0xff00)) |
+                                           ((pdef->blue & 0xff00) >> 8));
+            pdef++;
+        }
     }
 }
 
-#endif /* _MIINDEX_H_ */
+#endif                          /* _MIINDEX_H_ */
diff --git a/render/mipict.c b/render/mipict.c
index 0b86bee34..2e64b20ff 100644
--- a/render/mipict.c
+++ b/render/mipict.c
@@ -34,76 +34,72 @@
 #include "mipict.h"
 
 int
-miCreatePicture (PicturePtr pPicture)
+miCreatePicture(PicturePtr pPicture)
 {
     return Success;
 }
 
 void
-miDestroyPicture (PicturePtr pPicture)
+miDestroyPicture(PicturePtr pPicture)
 {
     if (pPicture->freeCompClip)
-	RegionDestroy(pPicture->pCompositeClip);
+        RegionDestroy(pPicture->pCompositeClip);
 }
 
 void
-miDestroyPictureClip (PicturePtr pPicture)
+miDestroyPictureClip(PicturePtr pPicture)
 {
     switch (pPicture->clientClipType) {
     case CT_NONE:
-	return;
+        return;
     case CT_PIXMAP:
-	(*pPicture->pDrawable->pScreen->DestroyPixmap) ((PixmapPtr) (pPicture->clientClip));
-	break;
+        (*pPicture->pDrawable->pScreen->
+         DestroyPixmap) ((PixmapPtr) (pPicture->clientClip));
+        break;
     default:
-	/*
-	 * we know we'll never have a list of rectangles, since ChangeClip
-	 * immediately turns them into a region
-	 */
-	RegionDestroy(pPicture->clientClip);
-	break;
+        /*
+         * we know we'll never have a list of rectangles, since ChangeClip
+         * immediately turns them into a region
+         */
+        RegionDestroy(pPicture->clientClip);
+        break;
     }
     pPicture->clientClip = NULL;
     pPicture->clientClipType = CT_NONE;
-}    
+}
 
 int
-miChangePictureClip (PicturePtr    pPicture,
-		     int	   type,
-		     pointer	   value,
-		     int	   n)
+miChangePictureClip(PicturePtr pPicture, int type, pointer value, int n)
 {
-    ScreenPtr		pScreen = pPicture->pDrawable->pScreen;
-    PictureScreenPtr    ps = GetPictureScreen(pScreen);
-    pointer		clientClip;
-    int			clientClipType;
-    
+    ScreenPtr pScreen = pPicture->pDrawable->pScreen;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    pointer clientClip;
+    int clientClipType;
+
     switch (type) {
     case CT_PIXMAP:
-	/* convert the pixmap to a region */
-	clientClip = (pointer) BitmapToRegion(pScreen, (PixmapPtr) value);
-	if (!clientClip)
-	    return BadAlloc;
-	clientClipType = CT_REGION;
-	(*pScreen->DestroyPixmap) ((PixmapPtr) value);
-	break;
+        /* convert the pixmap to a region */
+        clientClip = (pointer) BitmapToRegion(pScreen, (PixmapPtr) value);
+        if (!clientClip)
+            return BadAlloc;
+        clientClipType = CT_REGION;
+        (*pScreen->DestroyPixmap) ((PixmapPtr) value);
+        break;
     case CT_REGION:
-	clientClip = value;
-	clientClipType = CT_REGION;
-	break;
+        clientClip = value;
+        clientClipType = CT_REGION;
+        break;
     case CT_NONE:
-	clientClip = 0;
-	clientClipType = CT_NONE;
-	break;
+        clientClip = 0;
+        clientClipType = CT_NONE;
+        break;
     default:
-	clientClip = (pointer) RegionFromRects(n,
-					       (xRectangle *) value,
-					       type);
-	if (!clientClip)
-	    return BadAlloc;
-	clientClipType = CT_REGION;
-	free(value);
-	break;
+        clientClip = (pointer) RegionFromRects(n, (xRectangle *) value, type);
+        if (!clientClip)
+            return BadAlloc;
+        clientClipType = CT_REGION;
+        free(value);
+        break;
     }
     (*ps->DestroyPictureClip) (pPicture);
     pPicture->clientClip = clientClip;
@@ -113,149 +109,137 @@ miChangePictureClip (PicturePtr    pPicture,
 }
 
 void
-miChangePicture (PicturePtr pPicture,
-		 Mask       mask)
+miChangePicture(PicturePtr pPicture, Mask mask)
 {
     return;
 }
 
 void
-miValidatePicture (PicturePtr pPicture,
-		   Mask       mask)
+miValidatePicture(PicturePtr pPicture, Mask mask)
 {
-    DrawablePtr	    pDrawable = pPicture->pDrawable;
-
-    if ((mask & (CPClipXOrigin|CPClipYOrigin|CPClipMask|CPSubwindowMode)) ||
-	(pDrawable->serialNumber != (pPicture->serialNumber & DRAWABLE_SERIAL_BITS)))
-    {
-	if (pDrawable->type == DRAWABLE_WINDOW)
-	{
-	    WindowPtr       pWin = (WindowPtr) pDrawable;
-	    RegionPtr       pregWin;
-	    Bool            freeTmpClip, freeCompClip;
-
-	    if (pPicture->subWindowMode == IncludeInferiors)
-	    {
-		pregWin = NotClippedByChildren(pWin);
-		freeTmpClip = TRUE;
-	    }
-	    else
-	    {
-		pregWin = &pWin->clipList;
-		freeTmpClip = FALSE;
-	    }
-	    freeCompClip = pPicture->freeCompClip;
-
-	    /*
-	     * if there is no client clip, we can get by with just keeping the
-	     * pointer we got, and remembering whether or not should destroy
-	     * (or maybe re-use) it later.  this way, we avoid unnecessary
-	     * copying of regions.  (this wins especially if many clients clip
-	     * by children and have no client clip.)
-	     */
-	    if (pPicture->clientClipType == CT_NONE)
-	    {
-		if (freeCompClip)
-		    RegionDestroy(pPicture->pCompositeClip);
-		pPicture->pCompositeClip = pregWin;
-		pPicture->freeCompClip = freeTmpClip;
-	    }
-	    else
-	    {
-		/*
-		 * we need one 'real' region to put into the composite clip. if
-		 * pregWin the current composite clip are real, we can get rid of
-		 * one. if pregWin is real and the current composite clip isn't,
-		 * use pregWin for the composite clip. if the current composite
-		 * clip is real and pregWin isn't, use the current composite
-		 * clip. if neither is real, create a new region.
-		 */
-
-		RegionTranslate(pPicture->clientClip,
-				 pDrawable->x + pPicture->clipOrigin.x,
-				 pDrawable->y + pPicture->clipOrigin.y);
-
-		if (freeCompClip)
-		{
-		    RegionIntersect(pPicture->pCompositeClip,
-				     pregWin, pPicture->clientClip);
-		    if (freeTmpClip)
-			RegionDestroy(pregWin);
-		}
-		else if (freeTmpClip)
-		{
-		    RegionIntersect(pregWin, pregWin, pPicture->clientClip);
-		    pPicture->pCompositeClip = pregWin;
-		}
-		else
-		{
-		    pPicture->pCompositeClip = RegionCreate(NullBox, 0);
-		    RegionIntersect(pPicture->pCompositeClip,
-				     pregWin, pPicture->clientClip);
-		}
-		pPicture->freeCompClip = TRUE;
-		RegionTranslate(pPicture->clientClip,
-				 -(pDrawable->x + pPicture->clipOrigin.x),
-				 -(pDrawable->y + pPicture->clipOrigin.y));
-	    }
-	}	/* end of composite clip for a window */
-	else
-	{
-	    BoxRec          pixbounds;
-
-	    /* XXX should we translate by drawable.x/y here ? */
-	    /* If you want pixmaps in offscreen memory, yes */
-	    pixbounds.x1 = pDrawable->x;
-	    pixbounds.y1 = pDrawable->y;
-	    pixbounds.x2 = pDrawable->x + pDrawable->width;
-	    pixbounds.y2 = pDrawable->y + pDrawable->height;
-
-	    if (pPicture->freeCompClip)
-	    {
-		RegionReset(pPicture->pCompositeClip, &pixbounds);
-	    }
-	    else
-	    {
-		pPicture->freeCompClip = TRUE;
-		pPicture->pCompositeClip = RegionCreate(&pixbounds, 1);
-	    }
-
-	    if (pPicture->clientClipType == CT_REGION)
-	    {
-		if(pDrawable->x || pDrawable->y) {
-		    RegionTranslate(pPicture->clientClip,
-				     pDrawable->x + pPicture->clipOrigin.x, 
-				     pDrawable->y + pPicture->clipOrigin.y);
-		    RegionIntersect(pPicture->pCompositeClip,
-				     pPicture->pCompositeClip, pPicture->clientClip);
-		    RegionTranslate(pPicture->clientClip,
-				     -(pDrawable->x + pPicture->clipOrigin.x), 
-				     -(pDrawable->y + pPicture->clipOrigin.y));
-		} else {
-		    RegionTranslate(pPicture->pCompositeClip,
-				     -pPicture->clipOrigin.x, -pPicture->clipOrigin.y);
-		    RegionIntersect(pPicture->pCompositeClip,
-				     pPicture->pCompositeClip, pPicture->clientClip);
-		    RegionTranslate(pPicture->pCompositeClip,
-				     pPicture->clipOrigin.x, pPicture->clipOrigin.y);
-		}
-	    }
-	}	/* end of composite clip for pixmap */
+    DrawablePtr pDrawable = pPicture->pDrawable;
+
+    if ((mask & (CPClipXOrigin | CPClipYOrigin | CPClipMask | CPSubwindowMode))
+        || (pDrawable->serialNumber !=
+            (pPicture->serialNumber & DRAWABLE_SERIAL_BITS))) {
+        if (pDrawable->type == DRAWABLE_WINDOW) {
+            WindowPtr pWin = (WindowPtr) pDrawable;
+            RegionPtr pregWin;
+            Bool freeTmpClip, freeCompClip;
+
+            if (pPicture->subWindowMode == IncludeInferiors) {
+                pregWin = NotClippedByChildren(pWin);
+                freeTmpClip = TRUE;
+            }
+            else {
+                pregWin = &pWin->clipList;
+                freeTmpClip = FALSE;
+            }
+            freeCompClip = pPicture->freeCompClip;
+
+            /*
+             * if there is no client clip, we can get by with just keeping the
+             * pointer we got, and remembering whether or not should destroy
+             * (or maybe re-use) it later.  this way, we avoid unnecessary
+             * copying of regions.  (this wins especially if many clients clip
+             * by children and have no client clip.)
+             */
+            if (pPicture->clientClipType == CT_NONE) {
+                if (freeCompClip)
+                    RegionDestroy(pPicture->pCompositeClip);
+                pPicture->pCompositeClip = pregWin;
+                pPicture->freeCompClip = freeTmpClip;
+            }
+            else {
+                /*
+                 * we need one 'real' region to put into the composite clip. if
+                 * pregWin the current composite clip are real, we can get rid of
+                 * one. if pregWin is real and the current composite clip isn't,
+                 * use pregWin for the composite clip. if the current composite
+                 * clip is real and pregWin isn't, use the current composite
+                 * clip. if neither is real, create a new region.
+                 */
+
+                RegionTranslate(pPicture->clientClip,
+                                pDrawable->x + pPicture->clipOrigin.x,
+                                pDrawable->y + pPicture->clipOrigin.y);
+
+                if (freeCompClip) {
+                    RegionIntersect(pPicture->pCompositeClip,
+                                    pregWin, pPicture->clientClip);
+                    if (freeTmpClip)
+                        RegionDestroy(pregWin);
+                }
+                else if (freeTmpClip) {
+                    RegionIntersect(pregWin, pregWin, pPicture->clientClip);
+                    pPicture->pCompositeClip = pregWin;
+                }
+                else {
+                    pPicture->pCompositeClip = RegionCreate(NullBox, 0);
+                    RegionIntersect(pPicture->pCompositeClip,
+                                    pregWin, pPicture->clientClip);
+                }
+                pPicture->freeCompClip = TRUE;
+                RegionTranslate(pPicture->clientClip,
+                                -(pDrawable->x + pPicture->clipOrigin.x),
+                                -(pDrawable->y + pPicture->clipOrigin.y));
+            }
+        }                       /* end of composite clip for a window */
+        else {
+            BoxRec pixbounds;
+
+            /* XXX should we translate by drawable.x/y here ? */
+            /* If you want pixmaps in offscreen memory, yes */
+            pixbounds.x1 = pDrawable->x;
+            pixbounds.y1 = pDrawable->y;
+            pixbounds.x2 = pDrawable->x + pDrawable->width;
+            pixbounds.y2 = pDrawable->y + pDrawable->height;
+
+            if (pPicture->freeCompClip) {
+                RegionReset(pPicture->pCompositeClip, &pixbounds);
+            }
+            else {
+                pPicture->freeCompClip = TRUE;
+                pPicture->pCompositeClip = RegionCreate(&pixbounds, 1);
+            }
+
+            if (pPicture->clientClipType == CT_REGION) {
+                if (pDrawable->x || pDrawable->y) {
+                    RegionTranslate(pPicture->clientClip,
+                                    pDrawable->x + pPicture->clipOrigin.x,
+                                    pDrawable->y + pPicture->clipOrigin.y);
+                    RegionIntersect(pPicture->pCompositeClip,
+                                    pPicture->pCompositeClip,
+                                    pPicture->clientClip);
+                    RegionTranslate(pPicture->clientClip,
+                                    -(pDrawable->x + pPicture->clipOrigin.x),
+                                    -(pDrawable->y + pPicture->clipOrigin.y));
+                }
+                else {
+                    RegionTranslate(pPicture->pCompositeClip,
+                                    -pPicture->clipOrigin.x,
+                                    -pPicture->clipOrigin.y);
+                    RegionIntersect(pPicture->pCompositeClip,
+                                    pPicture->pCompositeClip,
+                                    pPicture->clientClip);
+                    RegionTranslate(pPicture->pCompositeClip,
+                                    pPicture->clipOrigin.x,
+                                    pPicture->clipOrigin.y);
+                }
+            }
+        }                       /* end of composite clip for pixmap */
     }
 }
 
 int
-miChangePictureTransform (PicturePtr	pPicture,
-			  PictTransform *transform)
+miChangePictureTransform(PicturePtr pPicture, PictTransform * transform)
 {
     return Success;
 }
 
 int
-miChangePictureFilter (PicturePtr pPicture,
-		       int	  filter,
-		       xFixed     *params,
-		       int	  nparams)
+miChangePictureFilter(PicturePtr pPicture,
+                      int filter, xFixed * params, int nparams)
 {
     return Success;
 }
@@ -263,96 +247,85 @@ miChangePictureFilter (PicturePtr pPicture,
 #define BOUND(v)	(INT16) ((v) < MINSHORT ? MINSHORT : (v) > MAXSHORT ? MAXSHORT : (v))
 
 static inline pixman_bool_t
-miClipPictureReg (pixman_region16_t *	pRegion,
-		  pixman_region16_t *	pClip,
-		  int		dx,
-		  int		dy)
+miClipPictureReg(pixman_region16_t * pRegion,
+                 pixman_region16_t * pClip, int dx, int dy)
 {
     if (pixman_region_n_rects(pRegion) == 1 &&
-	pixman_region_n_rects(pClip) == 1)
-    {
-	pixman_box16_t *  pRbox = pixman_region_rectangles(pRegion, NULL);
-	pixman_box16_t *  pCbox = pixman_region_rectangles(pClip, NULL);
-	int	v;
-	
-	if (pRbox->x1 < (v = pCbox->x1 + dx))
-	    pRbox->x1 = BOUND(v);
-	if (pRbox->x2 > (v = pCbox->x2 + dx))
-	    pRbox->x2 = BOUND(v);
-	if (pRbox->y1 < (v = pCbox->y1 + dy))
-	    pRbox->y1 = BOUND(v);
-	if (pRbox->y2 > (v = pCbox->y2 + dy))
-	    pRbox->y2 = BOUND(v);
-	if (pRbox->x1 >= pRbox->x2 ||
-	    pRbox->y1 >= pRbox->y2)
-	{
-	    pixman_region_init (pRegion);
-	}
+        pixman_region_n_rects(pClip) == 1) {
+        pixman_box16_t *pRbox = pixman_region_rectangles(pRegion, NULL);
+        pixman_box16_t *pCbox = pixman_region_rectangles(pClip, NULL);
+        int v;
+
+        if (pRbox->x1 < (v = pCbox->x1 + dx))
+            pRbox->x1 = BOUND(v);
+        if (pRbox->x2 > (v = pCbox->x2 + dx))
+            pRbox->x2 = BOUND(v);
+        if (pRbox->y1 < (v = pCbox->y1 + dy))
+            pRbox->y1 = BOUND(v);
+        if (pRbox->y2 > (v = pCbox->y2 + dy))
+            pRbox->y2 = BOUND(v);
+        if (pRbox->x1 >= pRbox->x2 || pRbox->y1 >= pRbox->y2) {
+            pixman_region_init(pRegion);
+        }
     }
-    else if (!pixman_region_not_empty (pClip))
-	return FALSE;
-    else
-    {
-	if (dx || dy)
-	    pixman_region_translate (pRegion, -dx, -dy);
-	if (!pixman_region_intersect (pRegion, pRegion, pClip))
-	    return FALSE;
-	if (dx || dy)
-	    pixman_region_translate(pRegion, dx, dy);
+    else if (!pixman_region_not_empty(pClip))
+        return FALSE;
+    else {
+        if (dx || dy)
+            pixman_region_translate(pRegion, -dx, -dy);
+        if (!pixman_region_intersect(pRegion, pRegion, pClip))
+            return FALSE;
+        if (dx || dy)
+            pixman_region_translate(pRegion, dx, dy);
     }
     return pixman_region_not_empty(pRegion);
 }
 
 static inline Bool
-miClipPictureSrc (RegionPtr	pRegion,
-		  PicturePtr	pPicture,
-		  int		dx,
-		  int		dy)
+miClipPictureSrc(RegionPtr pRegion, PicturePtr pPicture, int dx, int dy)
 {
-    if (pPicture->clientClipType != CT_NONE)
-    {
-	Bool result;
-	
-	pixman_region_translate ( pPicture->clientClip,
-				  pPicture->clipOrigin.x + dx,
-				  pPicture->clipOrigin.y + dy);
-
-	result = RegionIntersect(pRegion, pRegion, pPicture->clientClip);
-	
-	pixman_region_translate ( pPicture->clientClip,
-				  - (pPicture->clipOrigin.x + dx),
-				  - (pPicture->clipOrigin.y + dy));
-
-	if (!result)
-	    return FALSE;
+    if (pPicture->clientClipType != CT_NONE) {
+        Bool result;
+
+        pixman_region_translate(pPicture->clientClip,
+                                pPicture->clipOrigin.x + dx,
+                                pPicture->clipOrigin.y + dy);
+
+        result = RegionIntersect(pRegion, pRegion, pPicture->clientClip);
+
+        pixman_region_translate(pPicture->clientClip,
+                                -(pPicture->clipOrigin.x + dx),
+                                -(pPicture->clipOrigin.y + dy));
+
+        if (!result)
+            return FALSE;
     }
     return TRUE;
 }
 
 static void
-SourceValidateOnePicture (PicturePtr pPicture)
+SourceValidateOnePicture(PicturePtr pPicture)
 {
-    DrawablePtr	pDrawable = pPicture->pDrawable;
-    ScreenPtr	pScreen;
+    DrawablePtr pDrawable = pPicture->pDrawable;
+    ScreenPtr pScreen;
 
     if (!pDrawable)
         return;
 
     pScreen = pDrawable->pScreen;
 
-    if (pScreen->SourceValidate)
-    {
-	pScreen->SourceValidate (
-	    pDrawable, 0, 0, pDrawable->width, pDrawable->height, pPicture->subWindowMode);
+    if (pScreen->SourceValidate) {
+        pScreen->SourceValidate(pDrawable, 0, 0, pDrawable->width,
+                                pDrawable->height, pPicture->subWindowMode);
     }
 }
 
 void
-miCompositeSourceValidate (PicturePtr pPicture)
+miCompositeSourceValidate(PicturePtr pPicture)
 {
-    SourceValidateOnePicture (pPicture);
+    SourceValidateOnePicture(pPicture);
     if (pPicture->alphaMap)
-	SourceValidateOnePicture (pPicture->alphaMap);
+        SourceValidateOnePicture(pPicture->alphaMap);
 }
 
 /*
@@ -361,21 +334,18 @@ miCompositeSourceValidate (PicturePtr pPicture)
  */
 
 Bool
-miComputeCompositeRegion (RegionPtr	pRegion,
-			  PicturePtr	pSrc,
-			  PicturePtr	pMask,
-			  PicturePtr	pDst,
-			  INT16		xSrc,
-			  INT16		ySrc,
-			  INT16		xMask,
-			  INT16		yMask,
-			  INT16		xDst,
-			  INT16		yDst,
-			  CARD16	width,
-			  CARD16	height)
+miComputeCompositeRegion(RegionPtr pRegion,
+                         PicturePtr pSrc,
+                         PicturePtr pMask,
+                         PicturePtr pDst,
+                         INT16 xSrc,
+                         INT16 ySrc,
+                         INT16 xMask,
+                         INT16 yMask,
+                         INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
 {
-    
-    int		v;
+
+    int v;
 
     pRegion->extents.x1 = xDst;
     v = xDst + width;
@@ -386,254 +356,226 @@ miComputeCompositeRegion (RegionPtr	pRegion,
     pRegion->data = 0;
     /* Check for empty operation */
     if (pRegion->extents.x1 >= pRegion->extents.x2 ||
-	pRegion->extents.y1 >= pRegion->extents.y2)
-    {
-	pixman_region_init (pRegion);
-	return FALSE;
+        pRegion->extents.y1 >= pRegion->extents.y2) {
+        pixman_region_init(pRegion);
+        return FALSE;
     }
     /* clip against dst */
-    if (!miClipPictureReg (pRegion, pDst->pCompositeClip, 0, 0))
-    {
-	pixman_region_fini (pRegion);
-	return FALSE;
+    if (!miClipPictureReg(pRegion, pDst->pCompositeClip, 0, 0)) {
+        pixman_region_fini(pRegion);
+        return FALSE;
     }
-    if (pDst->alphaMap)
-    {
-	if (!miClipPictureReg (pRegion, pDst->alphaMap->pCompositeClip,
-			       -pDst->alphaOrigin.x,
-			       -pDst->alphaOrigin.y))
-	{
-	    pixman_region_fini (pRegion);
-	    return FALSE;
-	}
+    if (pDst->alphaMap) {
+        if (!miClipPictureReg(pRegion, pDst->alphaMap->pCompositeClip,
+                              -pDst->alphaOrigin.x, -pDst->alphaOrigin.y)) {
+            pixman_region_fini(pRegion);
+            return FALSE;
+        }
     }
     /* clip against src */
-    if (!miClipPictureSrc (pRegion, pSrc, xDst - xSrc, yDst - ySrc))
-    {
-	pixman_region_fini (pRegion);
-	return FALSE;
+    if (!miClipPictureSrc(pRegion, pSrc, xDst - xSrc, yDst - ySrc)) {
+        pixman_region_fini(pRegion);
+        return FALSE;
     }
-    if (pSrc->alphaMap)
-    {
-	if (!miClipPictureSrc (pRegion, pSrc->alphaMap,
-			       xDst - (xSrc - pSrc->alphaOrigin.x),
-			       yDst - (ySrc - pSrc->alphaOrigin.y)))
-	{
-	    pixman_region_fini (pRegion);
-	    return FALSE;
-	}
+    if (pSrc->alphaMap) {
+        if (!miClipPictureSrc(pRegion, pSrc->alphaMap,
+                              xDst - (xSrc - pSrc->alphaOrigin.x),
+                              yDst - (ySrc - pSrc->alphaOrigin.y))) {
+            pixman_region_fini(pRegion);
+            return FALSE;
+        }
     }
     /* clip against mask */
-    if (pMask)
-    {
-	if (!miClipPictureSrc (pRegion, pMask, xDst - xMask, yDst - yMask))
-	{
-	    pixman_region_fini (pRegion);
-	    return FALSE;
-	}	
-	if (pMask->alphaMap)
-	{
-	    if (!miClipPictureSrc (pRegion, pMask->alphaMap,
-				   xDst - (xMask - pMask->alphaOrigin.x),
-				   yDst - (yMask - pMask->alphaOrigin.y)))
-	    {
-		pixman_region_fini (pRegion);
-		return FALSE;
-	    }
-	}
+    if (pMask) {
+        if (!miClipPictureSrc(pRegion, pMask, xDst - xMask, yDst - yMask)) {
+            pixman_region_fini(pRegion);
+            return FALSE;
+        }
+        if (pMask->alphaMap) {
+            if (!miClipPictureSrc(pRegion, pMask->alphaMap,
+                                  xDst - (xMask - pMask->alphaOrigin.x),
+                                  yDst - (yMask - pMask->alphaOrigin.y))) {
+                pixman_region_fini(pRegion);
+                return FALSE;
+            }
+        }
     }
 
-    
-    miCompositeSourceValidate (pSrc);
+    miCompositeSourceValidate(pSrc);
     if (pMask)
-	miCompositeSourceValidate (pMask);
+        miCompositeSourceValidate(pMask);
 
     return TRUE;
 }
 
 void
-miRenderColorToPixel (PictFormatPtr format,
-		      xRenderColor  *color,
-		      CARD32	    *pixel)
+miRenderColorToPixel(PictFormatPtr format, xRenderColor * color, CARD32 *pixel)
 {
-    CARD32	    r, g, b, a;
-    miIndexedPtr    pIndexed;
+    CARD32 r, g, b, a;
+    miIndexedPtr pIndexed;
 
     switch (format->type) {
     case PictTypeDirect:
-	r = color->red >> (16 - Ones (format->direct.redMask));
-	g = color->green >> (16 - Ones (format->direct.greenMask));
-	b = color->blue >> (16 - Ones (format->direct.blueMask));
-	a = color->alpha >> (16 - Ones (format->direct.alphaMask));
-	r = r << format->direct.red;
-	g = g << format->direct.green;
-	b = b << format->direct.blue;
-	a = a << format->direct.alpha;
-	*pixel = r|g|b|a;
-	break;
+        r = color->red >> (16 - Ones(format->direct.redMask));
+        g = color->green >> (16 - Ones(format->direct.greenMask));
+        b = color->blue >> (16 - Ones(format->direct.blueMask));
+        a = color->alpha >> (16 - Ones(format->direct.alphaMask));
+        r = r << format->direct.red;
+        g = g << format->direct.green;
+        b = b << format->direct.blue;
+        a = a << format->direct.alpha;
+        *pixel = r | g | b | a;
+        break;
     case PictTypeIndexed:
-	pIndexed = (miIndexedPtr) (format->index.devPrivate);
-	if (pIndexed->color)
-	{
-	    r = color->red >> 11;
-	    g = color->green >> 11;
-	    b = color->blue >> 11;
-	    *pixel = miIndexToEnt15 (pIndexed, (r << 10) | (g << 5) | b);
-	}
-	else
-	{
-	    r = color->red >> 8;
-	    g = color->green >> 8;
-	    b = color->blue >> 8;
-	    *pixel = miIndexToEntY24 (pIndexed, (r << 16) | (g << 8) | b);
-	}
-	break;
+        pIndexed = (miIndexedPtr) (format->index.devPrivate);
+        if (pIndexed->color) {
+            r = color->red >> 11;
+            g = color->green >> 11;
+            b = color->blue >> 11;
+            *pixel = miIndexToEnt15(pIndexed, (r << 10) | (g << 5) | b);
+        }
+        else {
+            r = color->red >> 8;
+            g = color->green >> 8;
+            b = color->blue >> 8;
+            *pixel = miIndexToEntY24(pIndexed, (r << 16) | (g << 8) | b);
+        }
+        break;
     }
 }
 
 static CARD16
-miFillColor (CARD32 pixel, int bits)
+miFillColor(CARD32 pixel, int bits)
 {
-    while (bits < 16)
-    {
-	pixel |= pixel << bits;
-	bits <<= 1;
+    while (bits < 16) {
+        pixel |= pixel << bits;
+        bits <<= 1;
     }
     return (CARD16) pixel;
 }
 
 Bool
-miIsSolidAlpha (PicturePtr pSrc)
+miIsSolidAlpha(PicturePtr pSrc)
 {
-    ScreenPtr	pScreen;
-    char	line[1];
+    ScreenPtr pScreen;
+    char line[1];
 
     if (!pSrc->pDrawable)
         return FALSE;
 
     pScreen = pSrc->pDrawable->pScreen;
-    
+
     /* Alpha-only */
-    if (PICT_FORMAT_TYPE (pSrc->format) != PICT_TYPE_A)
-	return FALSE;
+    if (PICT_FORMAT_TYPE(pSrc->format) != PICT_TYPE_A)
+        return FALSE;
     /* repeat */
     if (!pSrc->repeat)
-	return FALSE;
+        return FALSE;
     /* 1x1 */
     if (pSrc->pDrawable->width != 1 || pSrc->pDrawable->height != 1)
-	return FALSE;
+        return FALSE;
     line[0] = 1;
     (*pScreen->GetImage) (pSrc->pDrawable, 0, 0, 1, 1, ZPixmap, ~0L, line);
     switch (pSrc->pDrawable->bitsPerPixel) {
     case 1:
-	return (CARD8) line[0] == 1 || (CARD8) line[0] == 0x80;
+        return (CARD8) line[0] == 1 || (CARD8) line[0] == 0x80;
     case 4:
-	return (CARD8) line[0] == 0xf || (CARD8) line[0] == 0xf0;
+        return (CARD8) line[0] == 0xf || (CARD8) line[0] == 0xf0;
     case 8:
-	return (CARD8) line[0] == 0xff;
+        return (CARD8) line[0] == 0xff;
     default:
-	return FALSE;
+        return FALSE;
     }
 }
 
 void
-miRenderPixelToColor (PictFormatPtr format,
-		      CARD32	    pixel,
-		      xRenderColor  *color)
+miRenderPixelToColor(PictFormatPtr format, CARD32 pixel, xRenderColor * color)
 {
-    CARD32	    r, g, b, a;
-    miIndexedPtr    pIndexed;
-    
+    CARD32 r, g, b, a;
+    miIndexedPtr pIndexed;
+
     switch (format->type) {
     case PictTypeDirect:
-	r = (pixel >> format->direct.red) & format->direct.redMask;
-	g = (pixel >> format->direct.green) & format->direct.greenMask;
-	b = (pixel >> format->direct.blue) & format->direct.blueMask;
-	a = (pixel >> format->direct.alpha) & format->direct.alphaMask;
-	color->red = miFillColor (r, Ones (format->direct.redMask));
-	color->green = miFillColor (g, Ones (format->direct.greenMask));
-	color->blue = miFillColor (b, Ones (format->direct.blueMask));
-	color->alpha = miFillColor (a, Ones (format->direct.alphaMask));
-	break;
+        r = (pixel >> format->direct.red) & format->direct.redMask;
+        g = (pixel >> format->direct.green) & format->direct.greenMask;
+        b = (pixel >> format->direct.blue) & format->direct.blueMask;
+        a = (pixel >> format->direct.alpha) & format->direct.alphaMask;
+        color->red = miFillColor(r, Ones(format->direct.redMask));
+        color->green = miFillColor(g, Ones(format->direct.greenMask));
+        color->blue = miFillColor(b, Ones(format->direct.blueMask));
+        color->alpha = miFillColor(a, Ones(format->direct.alphaMask));
+        break;
     case PictTypeIndexed:
-	pIndexed = (miIndexedPtr) (format->index.devPrivate);
-	pixel = pIndexed->rgba[pixel & (MI_MAX_INDEXED-1)];
-	r = (pixel >> 16) & 0xff;
-	g = (pixel >>  8) & 0xff;
-	b = (pixel      ) & 0xff;
-	color->red = miFillColor (r, 8);
-	color->green = miFillColor (g, 8);
-	color->blue = miFillColor (b, 8);
-	color->alpha = 0xffff;
-	break;
+        pIndexed = (miIndexedPtr) (format->index.devPrivate);
+        pixel = pIndexed->rgba[pixel & (MI_MAX_INDEXED - 1)];
+        r = (pixel >> 16) & 0xff;
+        g = (pixel >> 8) & 0xff;
+        b = (pixel) & 0xff;
+        color->red = miFillColor(r, 8);
+        color->green = miFillColor(g, 8);
+        color->blue = miFillColor(b, 8);
+        color->alpha = 0xffff;
+        break;
     }
 }
 
 void
-miTriStrip (CARD8	    op,
-	    PicturePtr	    pSrc,
-	    PicturePtr	    pDst,
-	    PictFormatPtr  maskFormat,
-	    INT16	    xSrc,
-	    INT16	    ySrc,
-	    int		    npoints,
-	    xPointFixed    *points)
+miTriStrip(CARD8 op,
+           PicturePtr pSrc,
+           PicturePtr pDst,
+           PictFormatPtr maskFormat,
+           INT16 xSrc, INT16 ySrc, int npoints, xPointFixed * points)
 {
-    xTriangle           *tris, *tri;
-    int                 ntri;
+    xTriangle *tris, *tri;
+    int ntri;
 
     ntri = npoints - 2;
-    tris = malloc(ntri * sizeof (xTriangle));
+    tris = malloc(ntri * sizeof(xTriangle));
     if (!tris)
         return;
 
-    for (tri = tris; npoints >= 3; npoints--, points++, tri++)
-    {
+    for (tri = tris; npoints >= 3; npoints--, points++, tri++) {
         tri->p1 = points[0];
         tri->p2 = points[1];
         tri->p3 = points[2];
     }
-    CompositeTriangles (op, pSrc, pDst, maskFormat, xSrc, ySrc, ntri, tris);
+    CompositeTriangles(op, pSrc, pDst, maskFormat, xSrc, ySrc, ntri, tris);
     free(tris);
 }
 
 void
-miTriFan (CARD8		op,
-	  PicturePtr	pSrc,
-	  PicturePtr	pDst,
-	  PictFormatPtr	maskFormat,
-	  INT16		xSrc,
-	  INT16		ySrc,
-	  int		npoints,
-	  xPointFixed	*points)
+miTriFan(CARD8 op,
+         PicturePtr pSrc,
+         PicturePtr pDst,
+         PictFormatPtr maskFormat,
+         INT16 xSrc, INT16 ySrc, int npoints, xPointFixed * points)
 {
-    xTriangle		*tris, *tri;
-    xPointFixed		*first;
-    int			ntri;
+    xTriangle *tris, *tri;
+    xPointFixed *first;
+    int ntri;
 
     ntri = npoints - 2;
-    tris = malloc(ntri * sizeof (xTriangle));
+    tris = malloc(ntri * sizeof(xTriangle));
     if (!tris)
-	return;
+        return;
 
     first = points++;
-    for (tri = tris; npoints >= 3; npoints--, points++, tri++)
-    {
-	tri->p1 = *first;
-	tri->p2 = points[0];
-	tri->p3 = points[1];
+    for (tri = tris; npoints >= 3; npoints--, points++, tri++) {
+        tri->p1 = *first;
+        tri->p2 = points[0];
+        tri->p3 = points[1];
     }
-    CompositeTriangles (op, pSrc, pDst, maskFormat, xSrc, ySrc, ntri, tris);
+    CompositeTriangles(op, pSrc, pDst, maskFormat, xSrc, ySrc, ntri, tris);
     free(tris);
 }
 
 Bool
-miPictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
+miPictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats)
 {
-    PictureScreenPtr    ps;
-    
-    if (!PictureInit (pScreen, formats, nformats))
-	return FALSE;
+    PictureScreenPtr ps;
+
+    if (!PictureInit(pScreen, formats, nformats))
+        return FALSE;
     ps = GetPictureScreen(pScreen);
     ps->CreatePicture = miCreatePicture;
     ps->DestroyPicture = miDestroyPicture;
@@ -650,18 +592,18 @@ miPictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
     ps->UnrealizeGlyph = miUnrealizeGlyph;
 
     /* MI rendering routines */
-    ps->Composite	= 0;			/* requires DDX support */
-    ps->Glyphs		= miGlyphs;
-    ps->CompositeRects	= miCompositeRects;
-    ps->Trapezoids	= 0;
-    ps->Triangles	= 0;
-    
-    ps->RasterizeTrapezoid = 0;			/* requires DDX support */
-    ps->AddTraps	= 0;			/* requires DDX support */
-    ps->AddTriangles	= 0;			/* requires DDX support */
-
-    ps->TriStrip	= miTriStrip; /* converts call to CompositeTriangles */
-    ps->TriFan		= miTriFan;
+    ps->Composite = 0;          /* requires DDX support */
+    ps->Glyphs = miGlyphs;
+    ps->CompositeRects = miCompositeRects;
+    ps->Trapezoids = 0;
+    ps->Triangles = 0;
+
+    ps->RasterizeTrapezoid = 0; /* requires DDX support */
+    ps->AddTraps = 0;           /* requires DDX support */
+    ps->AddTriangles = 0;       /* requires DDX support */
+
+    ps->TriStrip = miTriStrip;  /* converts call to CompositeTriangles */
+    ps->TriFan = miTriFan;
 
     return TRUE;
 }
diff --git a/render/mipict.h b/render/mipict.h
index 4399a6fad..943622888 100644
--- a/render/mipict.h
+++ b/render/mipict.h
@@ -27,16 +27,16 @@
 
 #include "picturestr.h"
 
-#define MI_MAX_INDEXED	256 /* XXX depth must be <= 8 */
+#define MI_MAX_INDEXED	256     /* XXX depth must be <= 8 */
 
 #if MI_MAX_INDEXED <= 256
 typedef CARD8 miIndexType;
 #endif
 
 typedef struct _miIndexed {
-    Bool	color;
-    CARD32	rgba[MI_MAX_INDEXED];
-    miIndexType	ent[32768];
+    Bool color;
+    CARD32 rgba[MI_MAX_INDEXED];
+    miIndexType ent[32768];
 } miIndexedRec, *miIndexedPtr;
 
 #define miCvtR8G8B8to15(s) ((((s) >> 3) & 0x001f) | \
@@ -48,138 +48,113 @@ typedef struct _miIndexed {
 #define miIndexToEntY24(mif,rgb24) ((mif)->ent[CvtR8G8B8toY15(rgb24)])
 
 extern _X_EXPORT int
-miCreatePicture (PicturePtr pPicture);
+ miCreatePicture(PicturePtr pPicture);
 
 extern _X_EXPORT void
-miDestroyPicture (PicturePtr pPicture);
+ miDestroyPicture(PicturePtr pPicture);
 
 extern _X_EXPORT void
-miDestroyPictureClip (PicturePtr pPicture);
+ miDestroyPictureClip(PicturePtr pPicture);
 
 extern _X_EXPORT int
-miChangePictureClip (PicturePtr    pPicture,
-		     int	   type,
-		     pointer	   value,
-		     int	   n);
+ miChangePictureClip(PicturePtr pPicture, int type, pointer value, int n);
 
 extern _X_EXPORT void
-miChangePicture (PicturePtr pPicture,
-		 Mask       mask);
+ miChangePicture(PicturePtr pPicture, Mask mask);
 
 extern _X_EXPORT void
-miValidatePicture (PicturePtr pPicture,
-		   Mask       mask);
+ miValidatePicture(PicturePtr pPicture, Mask mask);
 
 extern _X_EXPORT int
-miChangePictureTransform (PicturePtr	pPicture,
-			  PictTransform *transform);
+ miChangePictureTransform(PicturePtr pPicture, PictTransform * transform);
 
 extern _X_EXPORT int
-miChangePictureFilter (PicturePtr pPicture,
-		       int	  filter,
-		       xFixed     *params,
-		       int	  nparams);
+
+miChangePictureFilter(PicturePtr pPicture,
+                      int filter, xFixed * params, int nparams);
 
 extern _X_EXPORT void
-miCompositeSourceValidate (PicturePtr pPicture);
+ miCompositeSourceValidate(PicturePtr pPicture);
 
 extern _X_EXPORT Bool
-miComputeCompositeRegion (RegionPtr	pRegion,
-			  PicturePtr	pSrc,
-			  PicturePtr	pMask,
-			  PicturePtr	pDst,
-			  INT16		xSrc,
-			  INT16		ySrc,
-			  INT16		xMask,
-			  INT16		yMask,
-			  INT16		xDst,
-			  INT16		yDst,
-			  CARD16	width,
-			  CARD16	height);
+
+miComputeCompositeRegion(RegionPtr pRegion,
+                         PicturePtr pSrc,
+                         PicturePtr pMask,
+                         PicturePtr pDst,
+                         INT16 xSrc,
+                         INT16 ySrc,
+                         INT16 xMask,
+                         INT16 yMask,
+                         INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
 
 extern _X_EXPORT Bool
-miPictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats);
+ miPictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats);
 
 extern _X_EXPORT Bool
-miRealizeGlyph (ScreenPtr pScreen,
-		GlyphPtr  glyph);
+ miRealizeGlyph(ScreenPtr pScreen, GlyphPtr glyph);
 
 extern _X_EXPORT void
-miUnrealizeGlyph (ScreenPtr pScreen,
-		  GlyphPtr  glyph);
+ miUnrealizeGlyph(ScreenPtr pScreen, GlyphPtr glyph);
 
 extern _X_EXPORT void
-miGlyphs (CARD8		op,
-	  PicturePtr	pSrc,
-	  PicturePtr	pDst,
-	  PictFormatPtr	maskFormat,
-	  INT16		xSrc,
-	  INT16		ySrc,
-	  int		nlist,
-	  GlyphListPtr	list,
-	  GlyphPtr	*glyphs);
+
+miGlyphs(CARD8 op,
+         PicturePtr pSrc,
+         PicturePtr pDst,
+         PictFormatPtr maskFormat,
+         INT16 xSrc,
+         INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs);
 
 extern _X_EXPORT void
-miRenderColorToPixel (PictFormatPtr pPict,
-		      xRenderColor  *color,
-		      CARD32	    *pixel);
+ miRenderColorToPixel(PictFormatPtr pPict, xRenderColor * color, CARD32 *pixel);
 
 extern _X_EXPORT void
-miRenderPixelToColor (PictFormatPtr pPict,
-		      CARD32	    pixel,
-		      xRenderColor  *color);
+ miRenderPixelToColor(PictFormatPtr pPict, CARD32 pixel, xRenderColor * color);
 
 extern _X_EXPORT Bool
-miIsSolidAlpha (PicturePtr pSrc);
+ miIsSolidAlpha(PicturePtr pSrc);
 
 extern _X_EXPORT void
-miCompositeRects (CARD8		op,
-		  PicturePtr	pDst,
-		  xRenderColor  *color,
-		  int		nRect,
-		  xRectangle    *rects);
+
+miCompositeRects(CARD8 op,
+                 PicturePtr pDst,
+                 xRenderColor * color, int nRect, xRectangle *rects);
 
 extern _X_EXPORT void
-miTriStrip (CARD8	    op,
-	    PicturePtr	    pSrc,
-	    PicturePtr	    pDst,
-	    PictFormatPtr  maskFormat,
-	    INT16	    xSrc,
-	    INT16	    ySrc,
-	    int		    npoints,
-	    xPointFixed    *points);
+
+miTriStrip(CARD8 op,
+           PicturePtr pSrc,
+           PicturePtr pDst,
+           PictFormatPtr maskFormat,
+           INT16 xSrc, INT16 ySrc, int npoints, xPointFixed * points);
 
 extern _X_EXPORT void
-miTriFan (CARD8		op,
-	  PicturePtr	pSrc,
-	  PicturePtr	pDst,
-	  PictFormatPtr	maskFormat,
-	  INT16		xSrc,
-	  INT16		ySrc,
-	  int		npoints,
-	  xPointFixed	*points);
+
+miTriFan(CARD8 op,
+         PicturePtr pSrc,
+         PicturePtr pDst,
+         PictFormatPtr maskFormat,
+         INT16 xSrc, INT16 ySrc, int npoints, xPointFixed * points);
 
 extern _X_EXPORT void
-miTrapezoidBounds (int ntrap, xTrapezoid *traps, BoxPtr box);
+ miTrapezoidBounds(int ntrap, xTrapezoid * traps, BoxPtr box);
 
 extern _X_EXPORT void
-miPointFixedBounds (int npoint, xPointFixed *points, BoxPtr bounds);
-    
+ miPointFixedBounds(int npoint, xPointFixed * points, BoxPtr bounds);
+
 extern _X_EXPORT void
-miTriangleBounds (int ntri, xTriangle *tris, BoxPtr bounds);
+ miTriangleBounds(int ntri, xTriangle * tris, BoxPtr bounds);
 
 extern _X_EXPORT Bool
-miInitIndexed (ScreenPtr	pScreen,
-	       PictFormatPtr	pFormat);
+ miInitIndexed(ScreenPtr pScreen, PictFormatPtr pFormat);
 
 extern _X_EXPORT void
-miCloseIndexed (ScreenPtr	pScreen,
-		PictFormatPtr	pFormat);
+ miCloseIndexed(ScreenPtr pScreen, PictFormatPtr pFormat);
 
 extern _X_EXPORT void
-miUpdateIndexed (ScreenPtr	pScreen,
-		 PictFormatPtr	pFormat,
-		 int		ndef,
-		 xColorItem	*pdef);
 
-#endif /* _MIPICT_H_ */
+miUpdateIndexed(ScreenPtr pScreen,
+                PictFormatPtr pFormat, int ndef, xColorItem * pdef);
+
+#endif                          /* _MIPICT_H_ */
diff --git a/render/mirect.c b/render/mirect.c
index 4fb347a93..357d52860 100644
--- a/render/mirect.c
+++ b/render/mirect.c
@@ -34,152 +34,135 @@
 #include "mipict.h"
 
 static void
-miColorRects (PicturePtr    pDst,
-	      PicturePtr    pClipPict,
-	      xRenderColor  *color,
-	      int	    nRect,
-	      xRectangle    *rects,
-	      int	    xoff,
-	      int	    yoff)
+miColorRects(PicturePtr pDst,
+             PicturePtr pClipPict,
+             xRenderColor * color,
+             int nRect, xRectangle *rects, int xoff, int yoff)
 {
-    CARD32		pixel;
-    GCPtr		pGC;
-    ChangeGCVal		tmpval[5];
-    RegionPtr		pClip;
-    unsigned long	mask;
+    CARD32 pixel;
+    GCPtr pGC;
+    ChangeGCVal tmpval[5];
+    RegionPtr pClip;
+    unsigned long mask;
 
-    miRenderColorToPixel (pDst->pFormat, color, &pixel);
+    miRenderColorToPixel(pDst->pFormat, color, &pixel);
 
-    pGC = GetScratchGC (pDst->pDrawable->depth, pDst->pDrawable->pScreen);
+    pGC = GetScratchGC(pDst->pDrawable->depth, pDst->pDrawable->pScreen);
     if (!pGC)
-	return;
+        return;
     tmpval[0].val = GXcopy;
     tmpval[1].val = pixel;
     tmpval[2].val = pDst->subWindowMode;
     mask = GCFunction | GCForeground | GCSubwindowMode;
-    if (pClipPict->clientClipType == CT_REGION)
-    {
-	tmpval[3].val = pDst->clipOrigin.x - xoff;
-	tmpval[4].val = pDst->clipOrigin.y - yoff;
-	mask |= GCClipXOrigin|GCClipYOrigin;
-	
-	pClip = RegionCreate(NULL, 1);
-	RegionCopy(pClip,
-		     (RegionPtr) pClipPict->clientClip);
-	(*pGC->funcs->ChangeClip) (pGC, CT_REGION, pClip, 0);
+    if (pClipPict->clientClipType == CT_REGION) {
+        tmpval[3].val = pDst->clipOrigin.x - xoff;
+        tmpval[4].val = pDst->clipOrigin.y - yoff;
+        mask |= GCClipXOrigin | GCClipYOrigin;
+
+        pClip = RegionCreate(NULL, 1);
+        RegionCopy(pClip, (RegionPtr) pClipPict->clientClip);
+        (*pGC->funcs->ChangeClip) (pGC, CT_REGION, pClip, 0);
     }
 
-    ChangeGC (NullClient, pGC, mask, tmpval);
-    ValidateGC (pDst->pDrawable, pGC);
-    if (xoff || yoff)
-    {
-	int	i;
-	for (i = 0; i < nRect; i++)
-	{
-	    rects[i].x -= xoff;
-	    rects[i].y -= yoff;
-	}
+    ChangeGC(NullClient, pGC, mask, tmpval);
+    ValidateGC(pDst->pDrawable, pGC);
+    if (xoff || yoff) {
+        int i;
+
+        for (i = 0; i < nRect; i++) {
+            rects[i].x -= xoff;
+            rects[i].y -= yoff;
+        }
     }
     (*pGC->ops->PolyFillRect) (pDst->pDrawable, pGC, nRect, rects);
-    if (xoff || yoff)
-    {
-	int	i;
-	for (i = 0; i < nRect; i++)
-	{
-	    rects[i].x += xoff;
-	    rects[i].y += yoff;
-	}
+    if (xoff || yoff) {
+        int i;
+
+        for (i = 0; i < nRect; i++) {
+            rects[i].x += xoff;
+            rects[i].y += yoff;
+        }
     }
-    FreeScratchGC (pGC);
+    FreeScratchGC(pGC);
 }
 
 void
-miCompositeRects (CARD8		op,
-		  PicturePtr	pDst,
-		  xRenderColor  *color,
-		  int		nRect,
-		  xRectangle    *rects)
+miCompositeRects(CARD8 op,
+                 PicturePtr pDst,
+                 xRenderColor * color, int nRect, xRectangle *rects)
 {
-    ScreenPtr		pScreen = pDst->pDrawable->pScreen;
-    
-    if (color->alpha == 0xffff)
-    {
-	if (op == PictOpOver)
-	    op = PictOpSrc;
+    ScreenPtr pScreen = pDst->pDrawable->pScreen;
+
+    if (color->alpha == 0xffff) {
+        if (op == PictOpOver)
+            op = PictOpSrc;
     }
     if (op == PictOpClear)
-	color->red = color->green = color->blue = color->alpha = 0;
-    
-    if (op == PictOpSrc || op == PictOpClear)
-    {
-	miColorRects (pDst, pDst, color, nRect, rects, 0, 0);
-	if (pDst->alphaMap)
-	    miColorRects (pDst->alphaMap, pDst,
-			  color, nRect, rects,
-			  pDst->alphaOrigin.x,
-			  pDst->alphaOrigin.y);
+        color->red = color->green = color->blue = color->alpha = 0;
+
+    if (op == PictOpSrc || op == PictOpClear) {
+        miColorRects(pDst, pDst, color, nRect, rects, 0, 0);
+        if (pDst->alphaMap)
+            miColorRects(pDst->alphaMap, pDst,
+                         color, nRect, rects,
+                         pDst->alphaOrigin.x, pDst->alphaOrigin.y);
     }
-    else
-    {
-	PictFormatPtr	rgbaFormat;
-	PixmapPtr	pPixmap;
-	PicturePtr	pSrc;
-	xRectangle	one;
-	int		error;
-	Pixel		pixel;
-	GCPtr		pGC;
-	ChangeGCVal	gcvals[2];
-	XID		tmpval[1];
-
-	rgbaFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
-	if (!rgbaFormat)
-	    goto bail1;
-	
-	pPixmap = (*pScreen->CreatePixmap) (pScreen, 1, 1, rgbaFormat->depth,
-					    CREATE_PIXMAP_USAGE_SCRATCH);
-	if (!pPixmap)
-	    goto bail2;
-	
-	miRenderColorToPixel (rgbaFormat, color, &pixel);
-
-	pGC = GetScratchGC (rgbaFormat->depth, pScreen);
-	if (!pGC)
-	    goto bail3;
-	gcvals[0].val = GXcopy;
-	gcvals[1].val = pixel;
-
-	ChangeGC (NullClient, pGC, GCFunction | GCForeground, gcvals);
-	ValidateGC (&pPixmap->drawable, pGC);
-	one.x = 0;
-	one.y = 0;
-	one.width = 1;
-	one.height = 1;
-	(*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &one);
-	
-	tmpval[0] = xTrue;
-	pSrc = CreatePicture (0, &pPixmap->drawable, rgbaFormat,
-			      CPRepeat, tmpval, serverClient, &error);
-			      
-	if (!pSrc)
-	    goto bail4;
-
-	while (nRect--)
-	{
-	    CompositePicture (op, pSrc, 0, pDst, 0, 0, 0, 0, 
-			      rects->x,
-			      rects->y,
-			      rects->width,
-			      rects->height);
-	    rects++;
-	}
-
-	FreePicture ((pointer) pSrc, 0);
-bail4:
-	FreeScratchGC (pGC);
-bail3:
-	(*pScreen->DestroyPixmap) (pPixmap);
-bail2:
-bail1:
-	;
+    else {
+        PictFormatPtr rgbaFormat;
+        PixmapPtr pPixmap;
+        PicturePtr pSrc;
+        xRectangle one;
+        int error;
+        Pixel pixel;
+        GCPtr pGC;
+        ChangeGCVal gcvals[2];
+        XID tmpval[1];
+
+        rgbaFormat = PictureMatchFormat(pScreen, 32, PICT_a8r8g8b8);
+        if (!rgbaFormat)
+            goto bail1;
+
+        pPixmap = (*pScreen->CreatePixmap) (pScreen, 1, 1, rgbaFormat->depth,
+                                            CREATE_PIXMAP_USAGE_SCRATCH);
+        if (!pPixmap)
+            goto bail2;
+
+        miRenderColorToPixel(rgbaFormat, color, &pixel);
+
+        pGC = GetScratchGC(rgbaFormat->depth, pScreen);
+        if (!pGC)
+            goto bail3;
+        gcvals[0].val = GXcopy;
+        gcvals[1].val = pixel;
+
+        ChangeGC(NullClient, pGC, GCFunction | GCForeground, gcvals);
+        ValidateGC(&pPixmap->drawable, pGC);
+        one.x = 0;
+        one.y = 0;
+        one.width = 1;
+        one.height = 1;
+        (*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &one);
+
+        tmpval[0] = xTrue;
+        pSrc = CreatePicture(0, &pPixmap->drawable, rgbaFormat,
+                             CPRepeat, tmpval, serverClient, &error);
+
+        if (!pSrc)
+            goto bail4;
+
+        while (nRect--) {
+            CompositePicture(op, pSrc, 0, pDst, 0, 0, 0, 0,
+                             rects->x, rects->y, rects->width, rects->height);
+            rects++;
+        }
+
+        FreePicture((pointer) pSrc, 0);
+ bail4:
+        FreeScratchGC(pGC);
+ bail3:
+        (*pScreen->DestroyPixmap) (pPixmap);
+ bail2:
+ bail1:
+        ;
     }
 }
diff --git a/render/mitrap.c b/render/mitrap.c
index 445f23630..17b6dcd1c 100644
--- a/render/mitrap.c
+++ b/render/mitrap.c
@@ -35,45 +35,47 @@
 #include "mipict.h"
 
 static xFixed
-miLineFixedX (xLineFixed *l, xFixed y, Bool ceil)
+miLineFixedX(xLineFixed * l, xFixed y, Bool ceil)
 {
-    xFixed	    dx = l->p2.x - l->p1.x;
-    xFixed_32_32    ex = (xFixed_32_32) (y - l->p1.y) * dx;
-    xFixed	    dy = l->p2.y - l->p1.y;
+    xFixed dx = l->p2.x - l->p1.x;
+    xFixed_32_32 ex = (xFixed_32_32) (y - l->p1.y) * dx;
+    xFixed dy = l->p2.y - l->p1.y;
+
     if (ceil)
-	ex += (dy - 1);
+        ex += (dy - 1);
     return l->p1.x + (xFixed) (ex / dy);
 }
 
 void
-miTrapezoidBounds (int ntrap, xTrapezoid *traps, BoxPtr box)
+miTrapezoidBounds(int ntrap, xTrapezoid * traps, BoxPtr box)
 {
     box->y1 = MAXSHORT;
     box->y2 = MINSHORT;
     box->x1 = MAXSHORT;
     box->x2 = MINSHORT;
-    for (; ntrap; ntrap--, traps++)
-    {
-	INT16 x1, y1, x2, y2;
+    for (; ntrap; ntrap--, traps++) {
+        INT16 x1, y1, x2, y2;
+
+        if (!xTrapezoidValid(traps))
+            continue;
+        y1 = xFixedToInt(traps->top);
+        if (y1 < box->y1)
+            box->y1 = y1;
+
+        y2 = xFixedToInt(xFixedCeil(traps->bottom));
+        if (y2 > box->y2)
+            box->y2 = y2;
+
+        x1 = xFixedToInt(min(miLineFixedX(&traps->left, traps->top, FALSE),
+                             miLineFixedX(&traps->left, traps->bottom, FALSE)));
+        if (x1 < box->x1)
+            box->x1 = x1;
 
-	if (!xTrapezoidValid(traps))
-	    continue;
-	y1 = xFixedToInt (traps->top);
-	if (y1 < box->y1)
-	    box->y1 = y1;
-	
-	y2 = xFixedToInt (xFixedCeil (traps->bottom));
-	if (y2 > box->y2)
-	    box->y2 = y2;
-	
-	x1 = xFixedToInt (min (miLineFixedX (&traps->left, traps->top, FALSE),
-			       miLineFixedX (&traps->left, traps->bottom, FALSE)));
-	if (x1 < box->x1)
-	    box->x1 = x1;
-	
-	x2 = xFixedToInt (xFixedCeil (max (miLineFixedX (&traps->right, traps->top, TRUE),
-					   miLineFixedX (&traps->right, traps->bottom, TRUE))));
-	if (x2 > box->x2)
-	    box->x2 = x2;
+        x2 = xFixedToInt(xFixedCeil
+                         (max
+                          (miLineFixedX(&traps->right, traps->top, TRUE),
+                           miLineFixedX(&traps->right, traps->bottom, TRUE))));
+        if (x2 > box->x2)
+            box->x2 = x2;
     }
 }
diff --git a/render/mitri.c b/render/mitri.c
index b322a7c62..922f22a6a 100644
--- a/render/mitri.c
+++ b/render/mitri.c
@@ -34,35 +34,34 @@
 #include "mipict.h"
 
 void
-miPointFixedBounds (int npoint, xPointFixed *points, BoxPtr bounds)
+miPointFixedBounds(int npoint, xPointFixed * points, BoxPtr bounds)
 {
-    bounds->x1 = xFixedToInt (points->x);
-    bounds->x2 = xFixedToInt (xFixedCeil (points->x));
-    bounds->y1 = xFixedToInt (points->y);
-    bounds->y2 = xFixedToInt (xFixedCeil (points->y));
+    bounds->x1 = xFixedToInt(points->x);
+    bounds->x2 = xFixedToInt(xFixedCeil(points->x));
+    bounds->y1 = xFixedToInt(points->y);
+    bounds->y2 = xFixedToInt(xFixedCeil(points->y));
     points++;
     npoint--;
-    while (npoint-- > 0)
-    {
-	INT16	x1 = xFixedToInt (points->x);
-	INT16	x2 = xFixedToInt (xFixedCeil (points->x));
-	INT16	y1 = xFixedToInt (points->y);
-	INT16	y2 = xFixedToInt (xFixedCeil (points->y));
+    while (npoint-- > 0) {
+        INT16 x1 = xFixedToInt(points->x);
+        INT16 x2 = xFixedToInt(xFixedCeil(points->x));
+        INT16 y1 = xFixedToInt(points->y);
+        INT16 y2 = xFixedToInt(xFixedCeil(points->y));
 
-	if (x1 < bounds->x1)
-	    bounds->x1 = x1;
-	else if (x2 > bounds->x2)
-	    bounds->x2 = x2;
-	if (y1 < bounds->y1)
-	    bounds->y1 = y1;
-	else if (y2 > bounds->y2)
-	    bounds->y2 = y2;
-	points++;
+        if (x1 < bounds->x1)
+            bounds->x1 = x1;
+        else if (x2 > bounds->x2)
+            bounds->x2 = x2;
+        if (y1 < bounds->y1)
+            bounds->y1 = y1;
+        else if (y2 > bounds->y2)
+            bounds->y2 = y2;
+        points++;
     }
 }
 
 void
-miTriangleBounds (int ntri, xTriangle *tris, BoxPtr bounds)
+miTriangleBounds(int ntri, xTriangle * tris, BoxPtr bounds)
 {
-    miPointFixedBounds (ntri * 3, (xPointFixed *) tris, bounds);
+    miPointFixedBounds(ntri * 3, (xPointFixed *) tris, bounds);
 }
diff --git a/render/picture.c b/render/picture.c
index f13459665..2fd13fc37 100644
--- a/render/picture.c
+++ b/render/picture.c
@@ -44,26 +44,25 @@
 
 DevPrivateKeyRec PictureScreenPrivateKeyRec;
 DevPrivateKeyRec PictureWindowPrivateKeyRec;
-static int	PictureGeneration;
-RESTYPE		PictureType;
-RESTYPE		PictFormatType;
-RESTYPE		GlyphSetType;
-int		PictureCmapPolicy = PictureCmapPolicyDefault;
+static int PictureGeneration;
+RESTYPE PictureType;
+RESTYPE PictFormatType;
+RESTYPE GlyphSetType;
+int PictureCmapPolicy = PictureCmapPolicyDefault;
 
 Bool
-PictureDestroyWindow (WindowPtr pWindow)
+PictureDestroyWindow(WindowPtr pWindow)
 {
-    ScreenPtr		pScreen = pWindow->drawable.pScreen;
-    PicturePtr		pPicture;
-    PictureScreenPtr    ps = GetPictureScreen(pScreen);
-    Bool		ret;
-
-    while ((pPicture = GetPictureWindow(pWindow)))
-    {
-	SetPictureWindow(pWindow, pPicture->pNext);
-	if (pPicture->id)
-	    FreeResource (pPicture->id, PictureType);
-	FreePicture ((pointer) pPicture, pPicture->id);
+    ScreenPtr pScreen = pWindow->drawable.pScreen;
+    PicturePtr pPicture;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    Bool ret;
+
+    while ((pPicture = GetPictureWindow(pWindow))) {
+        SetPictureWindow(pWindow, pPicture->pNext);
+        if (pPicture->id)
+            FreeResource(pPicture->id, PictureType);
+        FreePicture((pointer) pPicture, pPicture->id);
     }
     pScreen->DestroyWindow = ps->DestroyWindow;
     ret = (*pScreen->DestroyWindow) (pWindow);
@@ -73,19 +72,19 @@ PictureDestroyWindow (WindowPtr pWindow)
 }
 
 Bool
-PictureCloseScreen (int index, ScreenPtr pScreen)
+PictureCloseScreen(int index, ScreenPtr pScreen)
 {
-    PictureScreenPtr    ps = GetPictureScreen(pScreen);
-    Bool                ret;
-    int			n;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    Bool ret;
+    int n;
 
     pScreen->CloseScreen = ps->CloseScreen;
     ret = (*pScreen->CloseScreen) (index, pScreen);
-    PictureResetFilters (pScreen);
+    PictureResetFilters(pScreen);
     for (n = 0; n < ps->nformats; n++)
-	if (ps->formats[n].type == PictTypeIndexed)
-	    (*ps->CloseIndexed) (pScreen, &ps->formats[n]);
-    GlyphUninit (pScreen);
+        if (ps->formats[n].type == PictTypeIndexed)
+            (*ps->CloseIndexed) (pScreen, &ps->formats[n]);
+    GlyphUninit(pScreen);
     SetPictureScreen(pScreen, 0);
     free(ps->formats);
     free(ps);
@@ -93,66 +92,59 @@ PictureCloseScreen (int index, ScreenPtr pScreen)
 }
 
 void
-PictureStoreColors (ColormapPtr pColormap, int ndef, xColorItem *pdef)
+PictureStoreColors(ColormapPtr pColormap, int ndef, xColorItem * pdef)
 {
-    ScreenPtr		pScreen = pColormap->pScreen;
-    PictureScreenPtr    ps = GetPictureScreen(pScreen);
+    ScreenPtr pScreen = pColormap->pScreen;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
 
     pScreen->StoreColors = ps->StoreColors;
     (*pScreen->StoreColors) (pColormap, ndef, pdef);
     ps->StoreColors = pScreen->StoreColors;
     pScreen->StoreColors = PictureStoreColors;
 
-    if (pColormap->class == PseudoColor || pColormap->class == GrayScale)
-    {
-	PictFormatPtr	format = ps->formats;
-	int		nformats = ps->nformats;
-
-	while (nformats--)
-	{
-	    if (format->type == PictTypeIndexed &&
-		format->index.pColormap == pColormap)
-	    {
-		(*ps->UpdateIndexed) (pScreen, format, ndef, pdef);
-		break;
-	    }
-	    format++;
-	}
+    if (pColormap->class == PseudoColor || pColormap->class == GrayScale) {
+        PictFormatPtr format = ps->formats;
+        int nformats = ps->nformats;
+
+        while (nformats--) {
+            if (format->type == PictTypeIndexed &&
+                format->index.pColormap == pColormap) {
+                (*ps->UpdateIndexed) (pScreen, format, ndef, pdef);
+                break;
+            }
+            format++;
+        }
     }
 }
 
 static int
-visualDepth (ScreenPtr pScreen, VisualPtr pVisual)
+visualDepth(ScreenPtr pScreen, VisualPtr pVisual)
 {
-    int		d, v;
-    DepthPtr	pDepth;
-
-    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;
+    int d, v;
+    DepthPtr pDepth;
+
+    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;
 }
 
 typedef struct _formatInit {
-    CARD32  format;
-    CARD8   depth;
+    CARD32 format;
+    CARD8 depth;
 } FormatInitRec, *FormatInitPtr;
 
 static int
-addFormat (FormatInitRec    formats[256],
-	   int		    nformat,
-	   CARD32	    format,
-	   CARD8	    depth)
+addFormat(FormatInitRec formats[256], int nformat, CARD32 format, CARD8 depth)
 {
-    int	n;
+    int n;
 
     for (n = 0; n < nformat; n++)
-	if (formats[n].format == format && formats[n].depth == depth)
-	    return nformat;
+        if (formats[n].format == format && formats[n].depth == depth)
+            return nformat;
     formats[nformat].format = format;
     formats[nformat].depth = depth;
     return ++nformat;
@@ -161,20 +153,20 @@ addFormat (FormatInitRec    formats[256],
 #define Mask(n) ((1 << (n)) - 1)
 
 PictFormatPtr
-PictureCreateDefaultFormats (ScreenPtr pScreen, int *nformatp)
+PictureCreateDefaultFormats(ScreenPtr pScreen, int *nformatp)
 {
-    int		    nformats, f;
-    PictFormatPtr   pFormats;
-    FormatInitRec   formats[1024];
-    CARD32	    format;
-    CARD8	    depth;
-    VisualPtr	    pVisual;
-    int		    v;
-    int		    bpp;
-    int		    type;
-    int		    r, g, b;
-    int		    d;
-    DepthPtr	    pDepth;
+    int nformats, f;
+    PictFormatPtr pFormats;
+    FormatInitRec formats[1024];
+    CARD32 format;
+    CARD8 depth;
+    VisualPtr pVisual;
+    int v;
+    int bpp;
+    int type;
+    int r, g, b;
+    int d;
+    DepthPtr pDepth;
 
     nformats = 0;
     /* formats required by protocol */
@@ -182,13 +174,11 @@ PictureCreateDefaultFormats (ScreenPtr pScreen, int *nformatp)
     formats[nformats].depth = 1;
     nformats++;
     formats[nformats].format = PICT_FORMAT(BitsPerPixel(8),
-					   PICT_TYPE_A,
-					   8, 0, 0, 0);
+                                           PICT_TYPE_A, 8, 0, 0, 0);
     formats[nformats].depth = 8;
     nformats++;
     formats[nformats].format = PICT_FORMAT(BitsPerPixel(4),
-					   PICT_TYPE_A,
-					   4, 0, 0, 0);
+                                           PICT_TYPE_A, 4, 0, 0, 0);
     formats[nformats].depth = 4;
     nformats++;
     formats[nformats].format = PICT_a8r8g8b8;
@@ -205,233 +195,233 @@ PictureCreateDefaultFormats (ScreenPtr pScreen, int *nformatp)
     nformats++;
 
     /* now look through the depths and visuals adding other formats */
-    for (v = 0; v < pScreen->numVisuals; v++)
-    {
-	pVisual = &pScreen->visuals[v];
-	depth = visualDepth (pScreen, pVisual);
-	if (!depth)
-	    continue;
-    	bpp = BitsPerPixel (depth);
-	switch (pVisual->class) {
-	case DirectColor:
-	case TrueColor:
-	    r = Ones (pVisual->redMask);
-	    g = Ones (pVisual->greenMask);
-	    b = Ones (pVisual->blueMask);
-	    type = PICT_TYPE_OTHER;
-	    /*
-	     * Current rendering code supports only three direct formats,
-	     * fields must be packed together at the bottom of the pixel
-	     */
-	    if (pVisual->offsetBlue == 0 &&
-		pVisual->offsetGreen == b &&
-		pVisual->offsetRed == b + g)
-	    {
-		type = PICT_TYPE_ARGB;
-	    }
-	    else if (pVisual->offsetRed == 0 &&
-		     pVisual->offsetGreen == r && 
-		     pVisual->offsetBlue == r + g)
-	    {
-		type = PICT_TYPE_ABGR;
-	    }
-	    else if (pVisual->offsetRed == pVisual->offsetGreen - r &&
-		     pVisual->offsetGreen == pVisual->offsetBlue - g && 
-		     pVisual->offsetBlue == bpp - b)
-	    {
-		type = PICT_TYPE_BGRA;
-	    }
-	    if (type != PICT_TYPE_OTHER)
-	    {
-		format = PICT_FORMAT(bpp, type, 0, r, g, b);
-		nformats = addFormat (formats, nformats, format, depth);
-	    }
-	    break;
-	case StaticColor:
-	case PseudoColor:
-	    format = PICT_VISFORMAT (bpp, PICT_TYPE_COLOR, v);
-	    nformats = addFormat (formats, nformats, format, depth);
-	    break;
-	case StaticGray:
-	case GrayScale:
-	    format = PICT_VISFORMAT (bpp, PICT_TYPE_GRAY, v);
-	    nformats = addFormat (formats, nformats, format, depth);
-	    break;
-	}
+    for (v = 0; v < pScreen->numVisuals; v++) {
+        pVisual = &pScreen->visuals[v];
+        depth = visualDepth(pScreen, pVisual);
+        if (!depth)
+            continue;
+        bpp = BitsPerPixel(depth);
+        switch (pVisual->class) {
+        case DirectColor:
+        case TrueColor:
+            r = Ones(pVisual->redMask);
+            g = Ones(pVisual->greenMask);
+            b = Ones(pVisual->blueMask);
+            type = PICT_TYPE_OTHER;
+            /*
+             * Current rendering code supports only three direct formats,
+             * fields must be packed together at the bottom of the pixel
+             */
+            if (pVisual->offsetBlue == 0 &&
+                pVisual->offsetGreen == b && pVisual->offsetRed == b + g) {
+                type = PICT_TYPE_ARGB;
+            }
+            else if (pVisual->offsetRed == 0 &&
+                     pVisual->offsetGreen == r &&
+                     pVisual->offsetBlue == r + g) {
+                type = PICT_TYPE_ABGR;
+            }
+            else if (pVisual->offsetRed == pVisual->offsetGreen - r &&
+                     pVisual->offsetGreen == pVisual->offsetBlue - g &&
+                     pVisual->offsetBlue == bpp - b) {
+                type = PICT_TYPE_BGRA;
+            }
+            if (type != PICT_TYPE_OTHER) {
+                format = PICT_FORMAT(bpp, type, 0, r, g, b);
+                nformats = addFormat(formats, nformats, format, depth);
+            }
+            break;
+        case StaticColor:
+        case PseudoColor:
+            format = PICT_VISFORMAT(bpp, PICT_TYPE_COLOR, v);
+            nformats = addFormat(formats, nformats, format, depth);
+            break;
+        case StaticGray:
+        case GrayScale:
+            format = PICT_VISFORMAT(bpp, PICT_TYPE_GRAY, v);
+            nformats = addFormat(formats, nformats, format, depth);
+            break;
+        }
     }
     /*
      * Walk supported depths and add useful Direct formats
      */
-    for (d = 0; d < pScreen->numDepths; d++)
-    {
-	pDepth = &pScreen->allowedDepths[d];
-	bpp = BitsPerPixel (pDepth->depth);
-	format = 0;
-	switch (bpp) {
-	case 16:
-	    /* depth 12 formats */
-	    if (pDepth->depth >= 12)
-	    {
-		nformats = addFormat (formats, nformats,
-				      PICT_x4r4g4b4, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_x4b4g4r4, pDepth->depth);
-	    }
-	    /* depth 15 formats */
-	    if (pDepth->depth >= 15)
-	    {
-		nformats = addFormat (formats, nformats,
-				      PICT_x1r5g5b5, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_x1b5g5r5, pDepth->depth);
-	    }
-	    /* depth 16 formats */
-	    if (pDepth->depth >= 16) 
-	    {
-		nformats = addFormat (formats, nformats,
-				      PICT_a1r5g5b5, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_a1b5g5r5, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_r5g6b5, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_b5g6r5, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_a4r4g4b4, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_a4b4g4r4, pDepth->depth);
-	    }
-	    break;
-	case 24:
-	    if (pDepth->depth >= 24)
-	    {
-		nformats = addFormat (formats, nformats,
-				      PICT_r8g8b8, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_b8g8r8, pDepth->depth);
-	    }
-	    break;
-	case 32:
-	    if (pDepth->depth >= 24)
-	    {
-		nformats = addFormat (formats, nformats,
-				      PICT_x8r8g8b8, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_x8b8g8r8, pDepth->depth);
-	    }
-	    if (pDepth->depth >= 30)
-	    {
-		nformats = addFormat (formats, nformats,
-				      PICT_a2r10g10b10, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_x2r10g10b10, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_a2b10g10r10, pDepth->depth);
-		nformats = addFormat (formats, nformats,
-				      PICT_x2b10g10r10, pDepth->depth);
-	    }
-	    break;
-	}
+    for (d = 0; d < pScreen->numDepths; d++) {
+        pDepth = &pScreen->allowedDepths[d];
+        bpp = BitsPerPixel(pDepth->depth);
+        format = 0;
+        switch (bpp) {
+        case 16:
+            /* depth 12 formats */
+            if (pDepth->depth >= 12) {
+                nformats = addFormat(formats, nformats,
+                                     PICT_x4r4g4b4, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_x4b4g4r4, pDepth->depth);
+            }
+            /* depth 15 formats */
+            if (pDepth->depth >= 15) {
+                nformats = addFormat(formats, nformats,
+                                     PICT_x1r5g5b5, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_x1b5g5r5, pDepth->depth);
+            }
+            /* depth 16 formats */
+            if (pDepth->depth >= 16) {
+                nformats = addFormat(formats, nformats,
+                                     PICT_a1r5g5b5, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_a1b5g5r5, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_r5g6b5, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_b5g6r5, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_a4r4g4b4, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_a4b4g4r4, pDepth->depth);
+            }
+            break;
+        case 24:
+            if (pDepth->depth >= 24) {
+                nformats = addFormat(formats, nformats,
+                                     PICT_r8g8b8, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_b8g8r8, pDepth->depth);
+            }
+            break;
+        case 32:
+            if (pDepth->depth >= 24) {
+                nformats = addFormat(formats, nformats,
+                                     PICT_x8r8g8b8, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_x8b8g8r8, pDepth->depth);
+            }
+            if (pDepth->depth >= 30) {
+                nformats = addFormat(formats, nformats,
+                                     PICT_a2r10g10b10, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_x2r10g10b10, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_a2b10g10r10, pDepth->depth);
+                nformats = addFormat(formats, nformats,
+                                     PICT_x2b10g10r10, pDepth->depth);
+            }
+            break;
+        }
     }
-    
 
-    pFormats = calloc(nformats, sizeof (PictFormatRec));
+    pFormats = calloc(nformats, sizeof(PictFormatRec));
     if (!pFormats)
-	return 0;
-    for (f = 0; f < nformats; f++)
-    {
-        pFormats[f].id = FakeClientID (0);
-	pFormats[f].depth = formats[f].depth;
-	format = formats[f].format;
-	pFormats[f].format = format;
-	switch (PICT_FORMAT_TYPE(format)) {
-	case PICT_TYPE_ARGB:
-	    pFormats[f].type = PictTypeDirect;
-	    
-	    pFormats[f].direct.alphaMask = Mask(PICT_FORMAT_A(format));
-	    if (pFormats[f].direct.alphaMask)
-		pFormats[f].direct.alpha = (PICT_FORMAT_R(format) +
-					    PICT_FORMAT_G(format) +
-					    PICT_FORMAT_B(format));
-	    
-	    pFormats[f].direct.redMask = Mask(PICT_FORMAT_R(format));
-	    pFormats[f].direct.red = (PICT_FORMAT_G(format) + 
-				      PICT_FORMAT_B(format));
-	    
-	    pFormats[f].direct.greenMask = Mask(PICT_FORMAT_G(format));
-	    pFormats[f].direct.green = PICT_FORMAT_B(format);
-	    
-	    pFormats[f].direct.blueMask = Mask(PICT_FORMAT_B(format));
-	    pFormats[f].direct.blue = 0;
-	    break;
-
-	case PICT_TYPE_ABGR:
-	    pFormats[f].type = PictTypeDirect;
-	    
-	    pFormats[f].direct.alphaMask = Mask(PICT_FORMAT_A(format));
-	    if (pFormats[f].direct.alphaMask)
-		pFormats[f].direct.alpha = (PICT_FORMAT_B(format) +
-					    PICT_FORMAT_G(format) +
-					    PICT_FORMAT_R(format));
-	    
-	    pFormats[f].direct.blueMask = Mask(PICT_FORMAT_B(format));
-	    pFormats[f].direct.blue = (PICT_FORMAT_G(format) + 
-				       PICT_FORMAT_R(format));
-	    
-	    pFormats[f].direct.greenMask = Mask(PICT_FORMAT_G(format));
-	    pFormats[f].direct.green = PICT_FORMAT_R(format);
-	    
-	    pFormats[f].direct.redMask = Mask(PICT_FORMAT_R(format));
-	    pFormats[f].direct.red = 0;
-	    break;
-
-	case PICT_TYPE_BGRA:
-	    pFormats[f].type = PictTypeDirect;
-	    
-	    pFormats[f].direct.blueMask = Mask(PICT_FORMAT_B(format));
-	    pFormats[f].direct.blue = (PICT_FORMAT_BPP(format) - PICT_FORMAT_B(format));
-
-	    pFormats[f].direct.greenMask = Mask(PICT_FORMAT_G(format));
-	    pFormats[f].direct.green = (PICT_FORMAT_BPP(format) - PICT_FORMAT_B(format) -
-					PICT_FORMAT_G(format));
-
-	    pFormats[f].direct.redMask = Mask(PICT_FORMAT_R(format));
-	    pFormats[f].direct.red = (PICT_FORMAT_BPP(format) - PICT_FORMAT_B(format) -
-				      PICT_FORMAT_G(format) - PICT_FORMAT_R(format));
-
-	    pFormats[f].direct.alphaMask = Mask(PICT_FORMAT_A(format));
-	    pFormats[f].direct.alpha = 0;
-	    break;
-
-	case PICT_TYPE_A:
-	    pFormats[f].type = PictTypeDirect;
-
-	    pFormats[f].direct.alpha = 0;
-	    pFormats[f].direct.alphaMask = Mask(PICT_FORMAT_A(format));
-
-	    /* remaining fields already set to zero */
-	    break;
-	    
-	case PICT_TYPE_COLOR:
-	case PICT_TYPE_GRAY:
-	    pFormats[f].type = PictTypeIndexed;
-	    pFormats[f].index.vid = pScreen->visuals[PICT_FORMAT_VIS(format)].vid;
-	    break;
-	}
+        return 0;
+    for (f = 0; f < nformats; f++) {
+        pFormats[f].id = FakeClientID(0);
+        pFormats[f].depth = formats[f].depth;
+        format = formats[f].format;
+        pFormats[f].format = format;
+        switch (PICT_FORMAT_TYPE(format)) {
+        case PICT_TYPE_ARGB:
+            pFormats[f].type = PictTypeDirect;
+
+            pFormats[f].direct.alphaMask = Mask (PICT_FORMAT_A(format));
+
+            if (pFormats[f].direct.alphaMask)
+                pFormats[f].direct.alpha = (PICT_FORMAT_R(format) +
+                                            PICT_FORMAT_G(format) +
+                                            PICT_FORMAT_B(format));
+
+            pFormats[f].direct.redMask = Mask (PICT_FORMAT_R(format));
+
+            pFormats[f].direct.red = (PICT_FORMAT_G(format) +
+                                      PICT_FORMAT_B(format));
+
+            pFormats[f].direct.greenMask = Mask (PICT_FORMAT_G(format));
+
+            pFormats[f].direct.green = PICT_FORMAT_B(format);
+
+            pFormats[f].direct.blueMask = Mask (PICT_FORMAT_B(format));
+
+            pFormats[f].direct.blue = 0;
+            break;
+
+        case PICT_TYPE_ABGR:
+            pFormats[f].type = PictTypeDirect;
+
+            pFormats[f].direct.alphaMask = Mask (PICT_FORMAT_A(format));
+
+            if (pFormats[f].direct.alphaMask)
+                pFormats[f].direct.alpha = (PICT_FORMAT_B(format) +
+                                            PICT_FORMAT_G(format) +
+                                            PICT_FORMAT_R(format));
+
+            pFormats[f].direct.blueMask = Mask (PICT_FORMAT_B(format));
+
+            pFormats[f].direct.blue = (PICT_FORMAT_G(format) +
+                                       PICT_FORMAT_R(format));
+
+            pFormats[f].direct.greenMask = Mask (PICT_FORMAT_G(format));
+
+            pFormats[f].direct.green = PICT_FORMAT_R(format);
+
+            pFormats[f].direct.redMask = Mask (PICT_FORMAT_R(format));
+
+            pFormats[f].direct.red = 0;
+            break;
+
+        case PICT_TYPE_BGRA:
+            pFormats[f].type = PictTypeDirect;
+
+            pFormats[f].direct.blueMask = Mask (PICT_FORMAT_B(format));
+
+            pFormats[f].direct.blue =
+                (PICT_FORMAT_BPP(format) - PICT_FORMAT_B(format));
+
+            pFormats[f].direct.greenMask = Mask (PICT_FORMAT_G(format));
+
+            pFormats[f].direct.green =
+                (PICT_FORMAT_BPP(format) - PICT_FORMAT_B(format) -
+                 PICT_FORMAT_G(format));
+
+            pFormats[f].direct.redMask = Mask (PICT_FORMAT_R(format));
+
+            pFormats[f].direct.red =
+                (PICT_FORMAT_BPP(format) - PICT_FORMAT_B(format) -
+                 PICT_FORMAT_G(format) - PICT_FORMAT_R(format));
+
+            pFormats[f].direct.alphaMask = Mask (PICT_FORMAT_A(format));
+
+            pFormats[f].direct.alpha = 0;
+            break;
+
+        case PICT_TYPE_A:
+            pFormats[f].type = PictTypeDirect;
+
+            pFormats[f].direct.alpha = 0;
+            pFormats[f].direct.alphaMask = Mask (PICT_FORMAT_A(format));
+
+            /* remaining fields already set to zero */
+            break;
+
+        case PICT_TYPE_COLOR:
+        case PICT_TYPE_GRAY:
+            pFormats[f].type = PictTypeIndexed;
+            pFormats[f].index.vid =
+                pScreen->visuals[PICT_FORMAT_VIS(format)].vid;
+            break;
+        }
     }
     *nformatp = nformats;
     return pFormats;
 }
 
 static VisualPtr
-PictureFindVisual (ScreenPtr pScreen, VisualID visual)
+PictureFindVisual(ScreenPtr pScreen, VisualID visual)
 {
-    int         i;
-    VisualPtr   pVisual;
+    int i;
+    VisualPtr pVisual;
+
     for (i = 0, pVisual = pScreen->visuals;
-         i < pScreen->numVisuals;
-         i++, pVisual++)
-    {
+         i < pScreen->numVisuals; i++, pVisual++) {
         if (pVisual->vid == visual)
             return pVisual;
     }
@@ -444,88 +434,89 @@ PictureInitIndexedFormat(ScreenPtr pScreen, PictFormatPtr format)
     PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
 
     if (format->type != PictTypeIndexed || format->index.pColormap)
-	return TRUE;
+        return TRUE;
 
     if (format->index.vid == pScreen->rootVisual) {
-	dixLookupResourceByType((pointer *)&format->index.pColormap,
-				pScreen->defColormap, RT_COLORMAP,
-				serverClient, DixGetAttrAccess);
-    } else {
-	VisualPtr pVisual = PictureFindVisual(pScreen, format->index.vid);
-	if (CreateColormap(FakeClientID (0), pScreen, pVisual,
-		    &format->index.pColormap, AllocNone, 0)
-		!= Success)
-	    return FALSE;
+        dixLookupResourceByType((pointer *) &format->index.pColormap,
+                                pScreen->defColormap, RT_COLORMAP,
+                                serverClient, DixGetAttrAccess);
+    }
+    else {
+        VisualPtr pVisual = PictureFindVisual(pScreen, format->index.vid);
+
+        if (CreateColormap(FakeClientID(0), pScreen, pVisual,
+                           &format->index.pColormap, AllocNone, 0)
+            != Success)
+            return FALSE;
     }
     if (!ps->InitIndexed(pScreen, format))
-	return FALSE;
+        return FALSE;
     return TRUE;
 }
 
 static Bool
-PictureInitIndexedFormats (ScreenPtr pScreen)
+PictureInitIndexedFormats(ScreenPtr pScreen)
 {
-    PictureScreenPtr    ps = GetPictureScreenIfSet(pScreen);
-    PictFormatPtr	format;
-    int			nformat;
+    PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
+    PictFormatPtr format;
+    int nformat;
 
     if (!ps)
-	return FALSE;
+        return FALSE;
     format = ps->formats;
     nformat = ps->nformats;
     while (nformat--)
-	if (!PictureInitIndexedFormat(pScreen, format++))
-	    return FALSE;
+        if (!PictureInitIndexedFormat(pScreen, format++))
+            return FALSE;
     return TRUE;
 }
 
 Bool
-PictureFinishInit (void)
+PictureFinishInit(void)
 {
-    int	    s;
+    int s;
 
-    for (s = 0; s < screenInfo.numScreens; s++)
-    {
-	if (!PictureInitIndexedFormats (screenInfo.screens[s]))
-	    return FALSE;
-	(void) AnimCurInit (screenInfo.screens[s]);
+    for (s = 0; s < screenInfo.numScreens; s++) {
+        if (!PictureInitIndexedFormats(screenInfo.screens[s]))
+            return FALSE;
+        (void) AnimCurInit(screenInfo.screens[s]);
     }
 
     return TRUE;
 }
 
 Bool
-PictureSetSubpixelOrder (ScreenPtr pScreen, int subpixel)
+PictureSetSubpixelOrder(ScreenPtr pScreen, int subpixel)
 {
-    PictureScreenPtr    ps = GetPictureScreenIfSet(pScreen);
+    PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
 
     if (!ps)
-	return FALSE;
+        return FALSE;
     ps->subpixel = subpixel;
     return TRUE;
-    
+
 }
 
 int
-PictureGetSubpixelOrder (ScreenPtr pScreen)
+PictureGetSubpixelOrder(ScreenPtr pScreen)
 {
-    PictureScreenPtr    ps = GetPictureScreenIfSet(pScreen);
+    PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
 
     if (!ps)
-	return SubPixelUnknown;
+        return SubPixelUnknown;
     return ps->subpixel;
 }
-    
+
 PictFormatPtr
-PictureMatchVisual (ScreenPtr pScreen, int depth, VisualPtr pVisual)
+PictureMatchVisual(ScreenPtr pScreen, int depth, VisualPtr pVisual)
 {
-    PictureScreenPtr    ps = GetPictureScreenIfSet(pScreen);
-    PictFormatPtr	format;
-    int			nformat;
-    int			type;
+    PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
+    PictFormatPtr format;
+    int nformat;
+    int type;
 
     if (!ps)
-	return 0;
+        return 0;
     format = ps->formats;
     nformat = ps->nformats;
     switch (pVisual->class) {
@@ -533,158 +524,146 @@ PictureMatchVisual (ScreenPtr pScreen, int depth, VisualPtr pVisual)
     case GrayScale:
     case StaticColor:
     case PseudoColor:
-	type = PictTypeIndexed;
-	break;
+        type = PictTypeIndexed;
+        break;
     case TrueColor:
     case DirectColor:
-	type = PictTypeDirect;
-	break;
+        type = PictTypeDirect;
+        break;
     default:
-	return 0;
+        return 0;
     }
-    while (nformat--)
-    {
-	if (format->depth == depth && format->type == type)
-	{
-	    if (type == PictTypeIndexed)
-	    {
-		if (format->index.vid == pVisual->vid)
-		    return format;
-	    }
-	    else
-	    {
-		if (format->direct.redMask << format->direct.red == 
-		    pVisual->redMask &&
-		    format->direct.greenMask << format->direct.green == 
-		    pVisual->greenMask &&
-		    format->direct.blueMask << format->direct.blue == 
-		    pVisual->blueMask)
-		{
-		    return format;
-		}
-	    }
-	}
-	format++;
+    while (nformat--) {
+        if (format->depth == depth && format->type == type) {
+            if (type == PictTypeIndexed) {
+                if (format->index.vid == pVisual->vid)
+                    return format;
+            }
+            else {
+                if (format->direct.redMask << format->direct.red ==
+                    pVisual->redMask &&
+                    format->direct.greenMask << format->direct.green ==
+                    pVisual->greenMask &&
+                    format->direct.blueMask << format->direct.blue ==
+                    pVisual->blueMask) {
+                    return format;
+                }
+            }
+        }
+        format++;
     }
     return 0;
 }
 
 PictFormatPtr
-PictureMatchFormat (ScreenPtr pScreen, int depth, CARD32 f)
+PictureMatchFormat(ScreenPtr pScreen, int depth, CARD32 f)
 {
-    PictureScreenPtr    ps = GetPictureScreenIfSet(pScreen);
-    PictFormatPtr	format;
-    int			nformat;
+    PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
+    PictFormatPtr format;
+    int nformat;
 
     if (!ps)
-	return 0;
+        return 0;
     format = ps->formats;
     nformat = ps->nformats;
-    while (nformat--)
-    {
-	if (format->depth == depth && format->format == (f & 0xffffff))
-	    return format;
-	format++;
+    while (nformat--) {
+        if (format->depth == depth && format->format == (f & 0xffffff))
+            return format;
+        format++;
     }
     return 0;
 }
 
 int
-PictureParseCmapPolicy (const char *name)
+PictureParseCmapPolicy(const char *name)
 {
-    if ( strcmp (name, "default" ) == 0)
-	return PictureCmapPolicyDefault;
-    else if ( strcmp (name, "mono" ) == 0)
-	return PictureCmapPolicyMono;
-    else if ( strcmp (name, "gray" ) == 0)
-	return PictureCmapPolicyGray;
-    else if ( strcmp (name, "color" ) == 0)
-	return PictureCmapPolicyColor;
-    else if ( strcmp (name, "all" ) == 0)
-	return PictureCmapPolicyAll;
+    if (strcmp(name, "default") == 0)
+        return PictureCmapPolicyDefault;
+    else if (strcmp(name, "mono") == 0)
+        return PictureCmapPolicyMono;
+    else if (strcmp(name, "gray") == 0)
+        return PictureCmapPolicyGray;
+    else if (strcmp(name, "color") == 0)
+        return PictureCmapPolicyColor;
+    else if (strcmp(name, "all") == 0)
+        return PictureCmapPolicyAll;
     else
-	return PictureCmapPolicyInvalid;
+        return PictureCmapPolicyInvalid;
 }
 
 Bool
-PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
+PictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats)
 {
-    PictureScreenPtr	ps;
-    int			n;
-    CARD32		type, a, r, g, b;
-    
-    if (PictureGeneration != serverGeneration)
-    {
-	PictureType = CreateNewResourceType (FreePicture, "PICTURE");
-	if (!PictureType)
-	    return FALSE;
-	PictFormatType = CreateNewResourceType (FreePictFormat, "PICTFORMAT");
-	if (!PictFormatType)
-	    return FALSE;
-	GlyphSetType = CreateNewResourceType (FreeGlyphSet, "GLYPHSET");
-	if (!GlyphSetType)
-	    return FALSE;
-	PictureGeneration = serverGeneration;
+    PictureScreenPtr ps;
+    int n;
+    CARD32 type, a, r, g, b;
+
+    if (PictureGeneration != serverGeneration) {
+        PictureType = CreateNewResourceType(FreePicture, "PICTURE");
+        if (!PictureType)
+            return FALSE;
+        PictFormatType = CreateNewResourceType(FreePictFormat, "PICTFORMAT");
+        if (!PictFormatType)
+            return FALSE;
+        GlyphSetType = CreateNewResourceType(FreeGlyphSet, "GLYPHSET");
+        if (!GlyphSetType)
+            return FALSE;
+        PictureGeneration = serverGeneration;
     }
     if (!dixRegisterPrivateKey(&PictureScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
+        return FALSE;
 
     if (!dixRegisterPrivateKey(&PictureWindowPrivateKeyRec, PRIVATE_WINDOW, 0))
-	return FALSE;
+        return FALSE;
 
-    if (!formats)
-    {
-	formats = PictureCreateDefaultFormats (pScreen, &nformats);
-	if (!formats)
-	    return FALSE;
+    if (!formats) {
+        formats = PictureCreateDefaultFormats(pScreen, &nformats);
+        if (!formats)
+            return FALSE;
     }
-    for (n = 0; n < nformats; n++)
-    {
-	if (!AddResource (formats[n].id, PictFormatType, (pointer) (formats+n)))
-	{
-	    free(formats);
-	    return FALSE;
-	}
-	if (formats[n].type == PictTypeIndexed)
-	{
-            VisualPtr   pVisual = PictureFindVisual (pScreen, formats[n].index.vid);
-	    if ((pVisual->class | DynamicClass) == PseudoColor)
-		type = PICT_TYPE_COLOR;
-	    else
-		type = PICT_TYPE_GRAY;
-	    a = r = g = b = 0;
-	}
-	else
-	{
-	    if ((formats[n].direct.redMask|
-		 formats[n].direct.blueMask|
-		 formats[n].direct.greenMask) == 0)
-		type = PICT_TYPE_A;
-	    else if (formats[n].direct.red > formats[n].direct.blue)
-		type = PICT_TYPE_ARGB;
-	    else if (formats[n].direct.red == 0)
-		type = PICT_TYPE_ABGR;
-	    else
-		type = PICT_TYPE_BGRA;
-	    a = Ones (formats[n].direct.alphaMask);
-	    r = Ones (formats[n].direct.redMask);
-	    g = Ones (formats[n].direct.greenMask);
-	    b = Ones (formats[n].direct.blueMask);
-	}
-	formats[n].format = PICT_FORMAT(0,type,a,r,g,b);
+    for (n = 0; n < nformats; n++) {
+        if (!AddResource
+            (formats[n].id, PictFormatType, (pointer) (formats + n))) {
+            free(formats);
+            return FALSE;
+        }
+        if (formats[n].type == PictTypeIndexed) {
+            VisualPtr pVisual =
+                PictureFindVisual(pScreen, formats[n].index.vid);
+            if ((pVisual->class | DynamicClass) == PseudoColor)
+                type = PICT_TYPE_COLOR;
+            else
+                type = PICT_TYPE_GRAY;
+            a = r = g = b = 0;
+        }
+        else {
+            if ((formats[n].direct.redMask |
+                 formats[n].direct.blueMask | formats[n].direct.greenMask) == 0)
+                type = PICT_TYPE_A;
+            else if (formats[n].direct.red > formats[n].direct.blue)
+                type = PICT_TYPE_ARGB;
+            else if (formats[n].direct.red == 0)
+                type = PICT_TYPE_ABGR;
+            else
+                type = PICT_TYPE_BGRA;
+            a = Ones(formats[n].direct.alphaMask);
+            r = Ones(formats[n].direct.redMask);
+            g = Ones(formats[n].direct.greenMask);
+            b = Ones(formats[n].direct.blueMask);
+        }
+        formats[n].format = PICT_FORMAT(0, type, a, r, g, b);
     }
-    ps = (PictureScreenPtr) malloc(sizeof (PictureScreenRec));
-    if (!ps)
-    {
-	free(formats);
-	return FALSE;
+    ps = (PictureScreenPtr) malloc(sizeof(PictureScreenRec));
+    if (!ps) {
+        free(formats);
+        return FALSE;
     }
     SetPictureScreen(pScreen, ps);
 
     ps->formats = formats;
     ps->fallback = formats;
     ps->nformats = nformats;
-    
+
     ps->filters = 0;
     ps->nfilters = 0;
     ps->filterAliases = 0;
@@ -699,20 +678,19 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
     pScreen->CloseScreen = PictureCloseScreen;
     pScreen->StoreColors = PictureStoreColors;
 
-    if (!PictureSetDefaultFilters (pScreen))
-    {
-	PictureResetFilters (pScreen);
-	SetPictureScreen(pScreen, 0);
-	free(formats);
-	free(ps);
-	return FALSE;
+    if (!PictureSetDefaultFilters(pScreen)) {
+        PictureResetFilters(pScreen);
+        SetPictureScreen(pScreen, 0);
+        free(formats);
+        free(ps);
+        return FALSE;
     }
 
     return TRUE;
 }
 
 void
-SetPictureToDefaults (PicturePtr    pPicture)
+SetPictureToDefaults(PicturePtr pPicture)
 {
     pPicture->refcnt = 1;
     pPicture->repeat = 0;
@@ -735,7 +713,7 @@ SetPictureToDefaults (PicturePtr    pPicture)
 
     pPicture->transform = 0;
 
-    pPicture->filter = PictureGetFilterId (FilterNearest, -1, TRUE);
+    pPicture->filter = PictureGetFilterId(FilterNearest, -1, TRUE);
     pPicture->filter_params = 0;
     pPicture->filter_nparams = 0;
 
@@ -745,22 +723,18 @@ SetPictureToDefaults (PicturePtr    pPicture)
 }
 
 PicturePtr
-CreatePicture (Picture		pid,
-	       DrawablePtr	pDrawable,
-	       PictFormatPtr	pFormat,
-	       Mask		vmask,
-	       XID		*vlist,
-	       ClientPtr	client,
-	       int		*error)
+CreatePicture(Picture pid,
+              DrawablePtr pDrawable,
+              PictFormatPtr pFormat,
+              Mask vmask, XID *vlist, ClientPtr client, int *error)
 {
-    PicturePtr		pPicture;
-    PictureScreenPtr	ps = GetPictureScreen(pDrawable->pScreen);
+    PicturePtr pPicture;
+    PictureScreenPtr ps = GetPictureScreen(pDrawable->pScreen);
 
     pPicture = dixAllocateObjectWithPrivates(PictureRec, PRIVATE_PICTURE);
-    if (!pPicture)
-    {
-	*error = BadAlloc;
-	return 0;
+    if (!pPicture) {
+        *error = BadAlloc;
+        return 0;
     }
 
     pPicture->id = pid;
@@ -770,49 +744,46 @@ CreatePicture (Picture		pid,
 
     /* security creation/labeling check */
     *error = XaceHook(XACE_RESOURCE_ACCESS, client, pid, PictureType, pPicture,
-		      RT_PIXMAP, pDrawable, DixCreateAccess|DixSetAttrAccess);
+                      RT_PIXMAP, pDrawable, DixCreateAccess | DixSetAttrAccess);
     if (*error != Success)
-	goto out;
+        goto out;
 
-    if (pDrawable->type == DRAWABLE_PIXMAP)
-    {
-	++((PixmapPtr)pDrawable)->refcnt;
-	pPicture->pNext = 0;
+    if (pDrawable->type == DRAWABLE_PIXMAP) {
+        ++((PixmapPtr) pDrawable)->refcnt;
+        pPicture->pNext = 0;
     }
-    else
-    {
-	pPicture->pNext = GetPictureWindow(((WindowPtr) pDrawable));
-	SetPictureWindow(((WindowPtr) pDrawable), pPicture);
+    else {
+        pPicture->pNext = GetPictureWindow(((WindowPtr) pDrawable));
+        SetPictureWindow(((WindowPtr) pDrawable), pPicture);
     }
 
-    SetPictureToDefaults (pPicture);
-    
+    SetPictureToDefaults(pPicture);
+
     if (vmask)
-	*error = ChangePicture (pPicture, vmask, vlist, 0, client);
+        *error = ChangePicture(pPicture, vmask, vlist, 0, client);
     else
-	*error = Success;
+        *error = Success;
     if (*error == Success)
-	*error = (*ps->CreatePicture) (pPicture);
-out:
-    if (*error != Success)
-    {
-	FreePicture (pPicture, (XID) 0);
-	pPicture = 0;
+        *error = (*ps->CreatePicture) (pPicture);
+ out:
+    if (*error != Success) {
+        FreePicture(pPicture, (XID) 0);
+        pPicture = 0;
     }
     return pPicture;
 }
 
-static CARD32 xRenderColorToCard32(xRenderColor c)
+static CARD32
+xRenderColorToCard32(xRenderColor c)
 {
     return
         (c.alpha >> 8 << 24) |
-        (c.red >> 8 << 16) |
-        (c.green & 0xff00) |
-        (c.blue >> 8);
+        (c.red >> 8 << 16) | (c.green & 0xff00) | (c.blue >> 8);
 }
 
-static void initGradient(SourcePictPtr pGradient, int stopCount,
-                         xFixed *stopPoints, xRenderColor *stopColors, int *error)
+static void
+initGradient(SourcePictPtr pGradient, int stopCount,
+             xFixed * stopPoints, xRenderColor * stopColors, int *error)
 {
     int i;
     xFixed dpos;
@@ -824,14 +795,14 @@ static void initGradient(SourcePictPtr pGradient, int stopCount,
 
     dpos = -1;
     for (i = 0; i < stopCount; ++i) {
-        if (stopPoints[i] < dpos || stopPoints[i] > (1<<16)) {
+        if (stopPoints[i] < dpos || stopPoints[i] > (1 << 16)) {
             *error = BadValue;
             return;
         }
         dpos = stopPoints[i];
     }
 
-    pGradient->gradient.stops = malloc(stopCount*sizeof(PictGradientStop));
+    pGradient->gradient.stops = malloc(stopCount * sizeof(PictGradientStop));
     if (!pGradient->gradient.stops) {
         *error = BadAlloc;
         return;
@@ -845,9 +816,11 @@ static void initGradient(SourcePictPtr pGradient, int stopCount,
     }
 }
 
-static PicturePtr createSourcePicture(void)
+static PicturePtr
+createSourcePicture(void)
 {
     PicturePtr pPicture;
+
     pPicture = dixAllocateObjectWithPrivates(PictureRec, PRIVATE_PICTURE);
     pPicture->pDrawable = 0;
     pPicture->pFormat = 0;
@@ -859,9 +832,10 @@ static PicturePtr createSourcePicture(void)
 }
 
 PicturePtr
-CreateSolidPicture (Picture pid, xRenderColor *color, int *error)
+CreateSolidPicture(Picture pid, xRenderColor * color, int *error)
 {
     PicturePtr pPicture;
+
     pPicture = createSourcePicture();
     if (!pPicture) {
         *error = BadAlloc;
@@ -881,8 +855,9 @@ CreateSolidPicture (Picture pid, xRenderColor *color, int *error)
 }
 
 PicturePtr
-CreateLinearGradientPicture (Picture pid, xPointFixed *p1, xPointFixed *p2,
-                             int nStops, xFixed *stops, xRenderColor *colors, int *error)
+CreateLinearGradientPicture(Picture pid, xPointFixed * p1, xPointFixed * p2,
+                            int nStops, xFixed * stops, xRenderColor * colors,
+                            int *error)
 {
     PicturePtr pPicture;
 
@@ -918,9 +893,10 @@ CreateLinearGradientPicture (Picture pid, xPointFixed *p1, xPointFixed *p2,
 }
 
 PicturePtr
-CreateRadialGradientPicture (Picture pid, xPointFixed *inner, xPointFixed *outer,
-                             xFixed innerRadius, xFixed outerRadius,
-                             int nStops, xFixed *stops, xRenderColor *colors, int *error)
+CreateRadialGradientPicture(Picture pid, xPointFixed * inner,
+                            xPointFixed * outer, xFixed innerRadius,
+                            xFixed outerRadius, int nStops, xFixed * stops,
+                            xRenderColor * colors, int *error)
 {
     PicturePtr pPicture;
     PictRadialGradient *radial;
@@ -952,7 +928,7 @@ CreateRadialGradientPicture (Picture pid, xPointFixed *inner, xPointFixed *outer
     radial->c2.x = outer->x;
     radial->c2.y = outer->y;
     radial->c2.radius = outerRadius;
-    
+
     initGradient(pPicture->pSourcePict, nStops, stops, colors, error);
     if (*error) {
         free(pPicture);
@@ -962,8 +938,9 @@ CreateRadialGradientPicture (Picture pid, xPointFixed *inner, xPointFixed *outer
 }
 
 PicturePtr
-CreateConicalGradientPicture (Picture pid, xPointFixed *center, xFixed angle,
-                              int nStops, xFixed *stops, xRenderColor *colors, int *error)
+CreateConicalGradientPicture(Picture pid, xPointFixed * center, xFixed angle,
+                             int nStops, xFixed * stops, xRenderColor * colors,
+                             int *error)
 {
     PicturePtr pPicture;
 
@@ -1003,226 +980,214 @@ CreateConicalGradientPicture (Picture pid, xPointFixed *center, xFixed angle,
 #define NEXT_PTR(_type) ((_type) ulist++->ptr)
 
 int
-ChangePicture (PicturePtr	pPicture,
-	       Mask		vmask,
-	       XID		*vlist,
-	       DevUnion		*ulist,
-	       ClientPtr	client)
+ChangePicture(PicturePtr pPicture,
+              Mask vmask, XID *vlist, DevUnion *ulist, ClientPtr client)
 {
     ScreenPtr pScreen = pPicture->pDrawable ? pPicture->pDrawable->pScreen : 0;
     PictureScreenPtr ps = pScreen ? GetPictureScreen(pScreen) : 0;
-    BITS32		index2;
-    int			error = 0;
-    BITS32		maskQ;
-    
+    BITS32 index2;
+    int error = 0;
+    BITS32 maskQ;
+
     pPicture->serialNumber |= GC_CHANGE_SERIAL_BIT;
     maskQ = vmask;
-    while (vmask && !error)
-    {
-	index2 = (BITS32) lowbit (vmask);
-	vmask &= ~index2;
-	pPicture->stateChanges |= index2;
-	switch (index2)
-	{
-	case CPRepeat:
-	    {
-		unsigned int	newr;
-		newr = NEXT_VAL(unsigned int);
-		if (newr <= RepeatReflect)
-		{
-		    pPicture->repeat = (newr != RepeatNone);
-		    pPicture->repeatType = newr;
-		}
-		else
-		{
-		    client->errorValue = newr;
-		    error = BadValue;
-		}
-	    }
-	    break;
-	case CPAlphaMap:
-	    {
-		PicturePtr  pAlpha;
-		
-		if (vlist)
-		{
-		    Picture	pid = NEXT_VAL(Picture);
-
-		    if (pid == None)
-			pAlpha = 0;
-		    else
-		    {
-			error = dixLookupResourceByType((pointer *)&pAlpha, pid,
-						  PictureType, client,
-						  DixReadAccess);
-			if (error != Success)
-			{
-			    client->errorValue = pid;
-			    break;
-			}
-			if (pAlpha->pDrawable == NULL ||
-			    pAlpha->pDrawable->type != DRAWABLE_PIXMAP)
-			{
-			    client->errorValue = pid;
-			    error = BadMatch;
-			    break;
-			}
-		    }
-		}
-		else
-		    pAlpha = NEXT_PTR(PicturePtr);
-		if (!error)
-		{
-		    if (pAlpha && pAlpha->pDrawable->type == DRAWABLE_PIXMAP)
-			pAlpha->refcnt++;
-		    if (pPicture->alphaMap)
-			FreePicture ((pointer) pPicture->alphaMap, (XID) 0);
-		    pPicture->alphaMap = pAlpha;
-		}
-	    }
-	    break;
-	case CPAlphaXOrigin:
-	    pPicture->alphaOrigin.x = NEXT_VAL(INT16);
-	    break;
-	case CPAlphaYOrigin:
-	    pPicture->alphaOrigin.y = NEXT_VAL(INT16);
-	    break;
-	case CPClipXOrigin:
-	    pPicture->clipOrigin.x = NEXT_VAL(INT16);
-	    break;
-	case CPClipYOrigin:
-	    pPicture->clipOrigin.y = NEXT_VAL(INT16);
-	    break;
-	case CPClipMask:
-	    {
-		Pixmap	    pid;
-		PixmapPtr   pPixmap;
-		int	    clipType;
-                if (!pScreen)
-                    return BadDrawable;
-
-		if (vlist)
-		{
-		    pid = NEXT_VAL(Pixmap);
-		    if (pid == None)
-		    {
-			clipType = CT_NONE;
-			pPixmap = NullPixmap;
-		    }
-		    else
-		    {
-			clipType = CT_PIXMAP;
-			error = dixLookupResourceByType((pointer *)&pPixmap, pid,
-						  RT_PIXMAP, client,
-						  DixReadAccess);
-			if (error != Success)
-			{
-			    client->errorValue = pid;
-			    break;
-			}
-		    }
-		}
-		else
-		{
-		    pPixmap = NEXT_PTR(PixmapPtr);
-		    if (pPixmap)
-			clipType = CT_PIXMAP;
-		    else
-			clipType = CT_NONE;
-		}
-
-		if (pPixmap)
-		{
-		    if ((pPixmap->drawable.depth != 1) ||
-			(pPixmap->drawable.pScreen != pScreen))
-		    {
-			error = BadMatch;
-			break;
-		    }
-		    else
-		    {
-			clipType = CT_PIXMAP;
-			pPixmap->refcnt++;
-		    }
-		}
-		error = (*ps->ChangePictureClip)(pPicture, clipType,
-						 (pointer)pPixmap, 0);
-		break;
-	    }
-	case CPGraphicsExposure:
-	    {
-		unsigned int	newe;
-		newe = NEXT_VAL(unsigned int);
-		if (newe <= xTrue)
-		    pPicture->graphicsExposures = newe;
-		else
-		{
-		    client->errorValue = newe;
-		    error = BadValue;
-		}
-	    }
-	    break;
-	case CPSubwindowMode:
-	    {
-		unsigned int	news;
-		news = NEXT_VAL(unsigned int);
-		if (news == ClipByChildren || news == IncludeInferiors)
-		    pPicture->subWindowMode = news;
-		else
-		{
-		    client->errorValue = news;
-		    error = BadValue;
-		}
-	    }
-	    break;
-	case CPPolyEdge:
-	    {
-		unsigned int	newe;
-		newe = NEXT_VAL(unsigned int);
-		if (newe == PolyEdgeSharp || newe == PolyEdgeSmooth)
-		    pPicture->polyEdge = newe;
-		else
-		{
-		    client->errorValue = newe;
-		    error = BadValue;
-		}
-	    }
-	    break;
-	case CPPolyMode:
-	    {
-		unsigned int	newm;
-		newm = NEXT_VAL(unsigned int);
-		if (newm == PolyModePrecise || newm == PolyModeImprecise)
-		    pPicture->polyMode = newm;
-		else
-		{
-		    client->errorValue = newm;
-		    error = BadValue;
-		}
-	    }
-	    break;
-	case CPDither:
-	    (void) NEXT_VAL(Atom); /* unimplemented */
-	    break;
-	case CPComponentAlpha:
-	    {
-		unsigned int	newca;
-
-		newca = NEXT_VAL (unsigned int);
-		if (newca <= xTrue)
-		    pPicture->componentAlpha = newca;
-		else
-		{
-		    client->errorValue = newca;
-		    error = BadValue;
-		}
-	    }
-	    break;
-	default:
-	    client->errorValue = maskQ;
-	    error = BadValue;
-	    break;
-	}
+    while (vmask && !error) {
+        index2 = (BITS32) lowbit(vmask);
+        vmask &= ~index2;
+        pPicture->stateChanges |= index2;
+        switch (index2) {
+        case CPRepeat:
+        {
+            unsigned int newr;
+            newr = NEXT_VAL(unsigned int);
+
+            if (newr <= RepeatReflect) {
+                pPicture->repeat = (newr != RepeatNone);
+                pPicture->repeatType = newr;
+            }
+            else {
+                client->errorValue = newr;
+                error = BadValue;
+            }
+        }
+            break;
+        case CPAlphaMap:
+        {
+            PicturePtr pAlpha;
+
+            if (vlist) {
+                Picture pid = NEXT_VAL(Picture);
+
+                if (pid == None)
+                    pAlpha = 0;
+                else {
+                    error = dixLookupResourceByType((pointer *) &pAlpha, pid,
+                                                    PictureType, client,
+                                                    DixReadAccess);
+                    if (error != Success) {
+                        client->errorValue = pid;
+                        break;
+                    }
+                    if (pAlpha->pDrawable == NULL ||
+                        pAlpha->pDrawable->type != DRAWABLE_PIXMAP) {
+                        client->errorValue = pid;
+                        error = BadMatch;
+                        break;
+                    }
+                }
+            }
+            else
+                pAlpha = NEXT_PTR(PicturePtr);
+            if (!error) {
+                if (pAlpha && pAlpha->pDrawable->type == DRAWABLE_PIXMAP)
+                    pAlpha->refcnt++;
+                if (pPicture->alphaMap)
+                    FreePicture((pointer) pPicture->alphaMap, (XID) 0);
+                pPicture->alphaMap = pAlpha;
+            }
+        }
+            break;
+        case CPAlphaXOrigin:
+            pPicture->alphaOrigin.x = NEXT_VAL(INT16);
+
+            break;
+        case CPAlphaYOrigin:
+            pPicture->alphaOrigin.y = NEXT_VAL(INT16);
+
+            break;
+        case CPClipXOrigin:
+            pPicture->clipOrigin.x = NEXT_VAL(INT16);
+
+            break;
+        case CPClipYOrigin:
+            pPicture->clipOrigin.y = NEXT_VAL(INT16);
+
+            break;
+        case CPClipMask:
+        {
+            Pixmap pid;
+            PixmapPtr pPixmap;
+            int clipType;
+
+            if (!pScreen)
+                return BadDrawable;
+
+            if (vlist) {
+                pid = NEXT_VAL(Pixmap);
+                if (pid == None) {
+                    clipType = CT_NONE;
+                    pPixmap = NullPixmap;
+                }
+                else {
+                    clipType = CT_PIXMAP;
+                    error = dixLookupResourceByType((pointer *) &pPixmap, pid,
+                                                    RT_PIXMAP, client,
+                                                    DixReadAccess);
+                    if (error != Success) {
+                        client->errorValue = pid;
+                        break;
+                    }
+                }
+            }
+            else {
+                pPixmap = NEXT_PTR(PixmapPtr);
+
+                if (pPixmap)
+                    clipType = CT_PIXMAP;
+                else
+                    clipType = CT_NONE;
+            }
+
+            if (pPixmap) {
+                if ((pPixmap->drawable.depth != 1) ||
+                    (pPixmap->drawable.pScreen != pScreen)) {
+                    error = BadMatch;
+                    break;
+                }
+                else {
+                    clipType = CT_PIXMAP;
+                    pPixmap->refcnt++;
+                }
+            }
+            error = (*ps->ChangePictureClip) (pPicture, clipType,
+                                              (pointer) pPixmap, 0);
+            break;
+        }
+        case CPGraphicsExposure:
+        {
+            unsigned int newe;
+            newe = NEXT_VAL(unsigned int);
+
+            if (newe <= xTrue)
+                pPicture->graphicsExposures = newe;
+            else {
+                client->errorValue = newe;
+                error = BadValue;
+            }
+        }
+            break;
+        case CPSubwindowMode:
+        {
+            unsigned int news;
+            news = NEXT_VAL(unsigned int);
+
+            if (news == ClipByChildren || news == IncludeInferiors)
+                pPicture->subWindowMode = news;
+            else {
+                client->errorValue = news;
+                error = BadValue;
+            }
+        }
+            break;
+        case CPPolyEdge:
+        {
+            unsigned int newe;
+            newe = NEXT_VAL(unsigned int);
+
+            if (newe == PolyEdgeSharp || newe == PolyEdgeSmooth)
+                pPicture->polyEdge = newe;
+            else {
+                client->errorValue = newe;
+                error = BadValue;
+            }
+        }
+            break;
+        case CPPolyMode:
+        {
+            unsigned int newm;
+            newm = NEXT_VAL(unsigned int);
+
+            if (newm == PolyModePrecise || newm == PolyModeImprecise)
+                pPicture->polyMode = newm;
+            else {
+                client->errorValue = newm;
+                error = BadValue;
+            }
+        }
+            break;
+        case CPDither:
+            (void) NEXT_VAL(Atom);      /* unimplemented */
+
+            break;
+        case CPComponentAlpha:
+        {
+            unsigned int newca;
+
+            newca = NEXT_VAL(unsigned int);
+
+            if (newca <= xTrue)
+                pPicture->componentAlpha = newca;
+            else {
+                client->errorValue = newca;
+                error = BadValue;
+            }
+        }
+            break;
+        default:
+            client->errorValue = maskQ;
+            error = BadValue;
+            break;
+        }
     }
     if (ps)
         (*ps->ChangePicture) (pPicture, maskQ);
@@ -1230,77 +1195,66 @@ ChangePicture (PicturePtr	pPicture,
 }
 
 int
-SetPictureClipRects (PicturePtr	pPicture,
-		     int	xOrigin,
-		     int	yOrigin,
-		     int	nRect,
-		     xRectangle	*rects)
+SetPictureClipRects(PicturePtr pPicture,
+                    int xOrigin, int yOrigin, int nRect, xRectangle *rects)
 {
-    ScreenPtr		pScreen = pPicture->pDrawable->pScreen;
-    PictureScreenPtr	ps = GetPictureScreen(pScreen);
-    RegionPtr		clientClip;
-    int			result;
+    ScreenPtr pScreen = pPicture->pDrawable->pScreen;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    RegionPtr clientClip;
+    int result;
 
     clientClip = RegionFromRects(nRect, rects, CT_UNSORTED);
     if (!clientClip)
-	return BadAlloc;
-    result =(*ps->ChangePictureClip) (pPicture, CT_REGION, 
-				      (pointer) clientClip, 0);
-    if (result == Success)
-    {
-	pPicture->clipOrigin.x = xOrigin;
-	pPicture->clipOrigin.y = yOrigin;
-	pPicture->stateChanges |= CPClipXOrigin|CPClipYOrigin|CPClipMask;
-	pPicture->serialNumber |= GC_CHANGE_SERIAL_BIT;
+        return BadAlloc;
+    result = (*ps->ChangePictureClip) (pPicture, CT_REGION,
+                                       (pointer) clientClip, 0);
+    if (result == Success) {
+        pPicture->clipOrigin.x = xOrigin;
+        pPicture->clipOrigin.y = yOrigin;
+        pPicture->stateChanges |= CPClipXOrigin | CPClipYOrigin | CPClipMask;
+        pPicture->serialNumber |= GC_CHANGE_SERIAL_BIT;
     }
     return result;
 }
 
 int
-SetPictureClipRegion (PicturePtr    pPicture,
-                      int           xOrigin,
-                      int           yOrigin,
-                      RegionPtr     pRegion)
+SetPictureClipRegion(PicturePtr pPicture,
+                     int xOrigin, int yOrigin, RegionPtr pRegion)
 {
-    ScreenPtr           pScreen = pPicture->pDrawable->pScreen;
-    PictureScreenPtr    ps = GetPictureScreen(pScreen);
-    RegionPtr           clientClip;
-    int                 result;
-    int                 type;
-
-    if (pRegion)
-    {
+    ScreenPtr pScreen = pPicture->pDrawable->pScreen;
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+    RegionPtr clientClip;
+    int result;
+    int type;
+
+    if (pRegion) {
         type = CT_REGION;
         clientClip = RegionCreate(RegionExtents(pRegion),
                                   RegionNumRects(pRegion));
         if (!clientClip)
             return BadAlloc;
-        if (!RegionCopy(clientClip, pRegion))
-        {
+        if (!RegionCopy(clientClip, pRegion)) {
             RegionDestroy(clientClip);
             return BadAlloc;
         }
     }
-    else
-    {
+    else {
         type = CT_NONE;
         clientClip = 0;
     }
 
-    result =(*ps->ChangePictureClip) (pPicture, type,
-                                      (pointer) clientClip, 0);
-    if (result == Success)
-    {
+    result = (*ps->ChangePictureClip) (pPicture, type, (pointer) clientClip, 0);
+    if (result == Success) {
         pPicture->clipOrigin.x = xOrigin;
         pPicture->clipOrigin.y = yOrigin;
-        pPicture->stateChanges |= CPClipXOrigin|CPClipYOrigin|CPClipMask;
+        pPicture->stateChanges |= CPClipXOrigin | CPClipYOrigin | CPClipMask;
         pPicture->serialNumber |= GC_CHANGE_SERIAL_BIT;
     }
     return result;
 }
 
 static Bool
-transformIsIdentity(PictTransform *t)
+transformIsIdentity(PictTransform * t)
 {
     return ((t->matrix[0][0] == t->matrix[1][1]) &&
             (t->matrix[0][0] == t->matrix[2][2]) &&
@@ -1309,50 +1263,44 @@ transformIsIdentity(PictTransform *t)
             (t->matrix[0][2] == 0) &&
             (t->matrix[1][0] == 0) &&
             (t->matrix[1][2] == 0) &&
-            (t->matrix[2][0] == 0) &&
-            (t->matrix[2][1] == 0));
+            (t->matrix[2][0] == 0) && (t->matrix[2][1] == 0));
 }
 
 int
-SetPictureTransform (PicturePtr	    pPicture,
-		     PictTransform  *transform)
+SetPictureTransform(PicturePtr pPicture, PictTransform * transform)
 {
-    if (transform && transformIsIdentity (transform))
-	transform = 0;
-    
-    if (transform)
-    {
-	if (!pPicture->transform)
-	{
-	    pPicture->transform = (PictTransform *) malloc(sizeof (PictTransform));
-	    if (!pPicture->transform)
-		return BadAlloc;
-	}
-	*pPicture->transform = *transform;
+    if (transform && transformIsIdentity(transform))
+        transform = 0;
+
+    if (transform) {
+        if (!pPicture->transform) {
+            pPicture->transform =
+                (PictTransform *) malloc(sizeof(PictTransform));
+            if (!pPicture->transform)
+                return BadAlloc;
+        }
+        *pPicture->transform = *transform;
     }
-    else
-    {
-	free(pPicture->transform);
-	pPicture->transform = NULL;
+    else {
+        free(pPicture->transform);
+        pPicture->transform = NULL;
     }
     pPicture->serialNumber |= GC_CHANGE_SERIAL_BIT;
 
     if (pPicture->pDrawable != NULL) {
-	int result;
-	PictureScreenPtr ps = GetPictureScreen(pPicture->pDrawable->pScreen);
+        int result;
+        PictureScreenPtr ps = GetPictureScreen(pPicture->pDrawable->pScreen);
 
-	result = (*ps->ChangePictureTransform) (pPicture, transform);
+        result = (*ps->ChangePictureTransform) (pPicture, transform);
 
-	return result;
+        return result;
     }
 
     return Success;
 }
 
 void
-CopyPicture (PicturePtr	pSrc,
-	     Mask	mask,
-	     PicturePtr	pDst)
+CopyPicture(PicturePtr pSrc, Mask mask, PicturePtr pDst)
 {
     PictureScreenPtr ps = GetPictureScreen(pSrc->pDrawable->pScreen);
     Mask origMask = mask;
@@ -1361,155 +1309,145 @@ CopyPicture (PicturePtr	pSrc,
     pDst->stateChanges |= mask;
 
     while (mask) {
-	Mask bit = lowbit(mask);
-
-	switch (bit)
-	{
-	case CPRepeat:
-	    pDst->repeat = pSrc->repeat;
-	    pDst->repeatType = pSrc->repeatType;
-	    break;
-	case CPAlphaMap:
-	    if (pSrc->alphaMap && pSrc->alphaMap->pDrawable->type == DRAWABLE_PIXMAP)
-		pSrc->alphaMap->refcnt++;
-	    if (pDst->alphaMap)
-		FreePicture ((pointer) pDst->alphaMap, (XID) 0);
-	    pDst->alphaMap = pSrc->alphaMap;
-	    break;
-	case CPAlphaXOrigin:
-	    pDst->alphaOrigin.x = pSrc->alphaOrigin.x;
-	    break;
-	case CPAlphaYOrigin:
-	    pDst->alphaOrigin.y = pSrc->alphaOrigin.y;
-	    break;
-	case CPClipXOrigin:
-	    pDst->clipOrigin.x = pSrc->clipOrigin.x;
-	    break;
-	case CPClipYOrigin:
-	    pDst->clipOrigin.y = pSrc->clipOrigin.y;
-	    break;
-	case CPClipMask:
-	    switch (pSrc->clientClipType) {
-	    case CT_NONE:
-		(*ps->ChangePictureClip)(pDst, CT_NONE, NULL, 0);
-		break;
-	    case CT_REGION:
-		if (!pSrc->clientClip) {
-		    (*ps->ChangePictureClip)(pDst, CT_NONE, NULL, 0);
-		} else {
-		    RegionPtr clientClip;
-		    RegionPtr srcClientClip = (RegionPtr)pSrc->clientClip;
-
-		    clientClip = RegionCreate(
-			RegionExtents(srcClientClip),
-			RegionNumRects(srcClientClip));
-		    (*ps->ChangePictureClip)(pDst, CT_REGION, clientClip, 0);
-		}
-		break;
-	    default:
-		/* XXX: CT_PIXMAP unimplemented */
-		break;
-	    }
-	    break;
-	case CPGraphicsExposure:
-	    pDst->graphicsExposures = pSrc->graphicsExposures;
-	    break;
-	case CPPolyEdge:
-	    pDst->polyEdge = pSrc->polyEdge;
-	    break;
-	case CPPolyMode:
-	    pDst->polyMode = pSrc->polyMode;
-	    break;
-	case CPDither:
-	    break;
-	case CPComponentAlpha:
-	    pDst->componentAlpha = pSrc->componentAlpha;
-	    break;
-	}
-	mask &= ~bit;
+        Mask bit = lowbit(mask);
+
+        switch (bit) {
+        case CPRepeat:
+            pDst->repeat = pSrc->repeat;
+            pDst->repeatType = pSrc->repeatType;
+            break;
+        case CPAlphaMap:
+            if (pSrc->alphaMap &&
+                pSrc->alphaMap->pDrawable->type == DRAWABLE_PIXMAP)
+                pSrc->alphaMap->refcnt++;
+            if (pDst->alphaMap)
+                FreePicture((pointer) pDst->alphaMap, (XID) 0);
+            pDst->alphaMap = pSrc->alphaMap;
+            break;
+        case CPAlphaXOrigin:
+            pDst->alphaOrigin.x = pSrc->alphaOrigin.x;
+            break;
+        case CPAlphaYOrigin:
+            pDst->alphaOrigin.y = pSrc->alphaOrigin.y;
+            break;
+        case CPClipXOrigin:
+            pDst->clipOrigin.x = pSrc->clipOrigin.x;
+            break;
+        case CPClipYOrigin:
+            pDst->clipOrigin.y = pSrc->clipOrigin.y;
+            break;
+        case CPClipMask:
+            switch (pSrc->clientClipType) {
+            case CT_NONE:
+                (*ps->ChangePictureClip) (pDst, CT_NONE, NULL, 0);
+                break;
+            case CT_REGION:
+                if (!pSrc->clientClip) {
+                    (*ps->ChangePictureClip) (pDst, CT_NONE, NULL, 0);
+                }
+                else {
+                    RegionPtr clientClip;
+                    RegionPtr srcClientClip = (RegionPtr) pSrc->clientClip;
+
+                    clientClip = RegionCreate(RegionExtents(srcClientClip),
+                                              RegionNumRects(srcClientClip));
+                    (*ps->ChangePictureClip) (pDst, CT_REGION, clientClip, 0);
+                }
+                break;
+            default:
+                /* XXX: CT_PIXMAP unimplemented */
+                break;
+            }
+            break;
+        case CPGraphicsExposure:
+            pDst->graphicsExposures = pSrc->graphicsExposures;
+            break;
+        case CPPolyEdge:
+            pDst->polyEdge = pSrc->polyEdge;
+            break;
+        case CPPolyMode:
+            pDst->polyMode = pSrc->polyMode;
+            break;
+        case CPDither:
+            break;
+        case CPComponentAlpha:
+            pDst->componentAlpha = pSrc->componentAlpha;
+            break;
+        }
+        mask &= ~bit;
     }
 
-    (*ps->ChangePicture)(pDst, origMask);
+    (*ps->ChangePicture) (pDst, origMask);
 }
 
 static void
-ValidateOnePicture (PicturePtr pPicture)
+ValidateOnePicture(PicturePtr pPicture)
 {
-    if (pPicture->pDrawable && pPicture->serialNumber != pPicture->pDrawable->serialNumber)
-    {
-	PictureScreenPtr    ps = GetPictureScreen(pPicture->pDrawable->pScreen);
+    if (pPicture->pDrawable &&
+        pPicture->serialNumber != pPicture->pDrawable->serialNumber) {
+        PictureScreenPtr ps = GetPictureScreen(pPicture->pDrawable->pScreen);
 
-	(*ps->ValidatePicture) (pPicture, pPicture->stateChanges);
-	pPicture->stateChanges = 0;
-	pPicture->serialNumber = pPicture->pDrawable->serialNumber;
+        (*ps->ValidatePicture) (pPicture, pPicture->stateChanges);
+        pPicture->stateChanges = 0;
+        pPicture->serialNumber = pPicture->pDrawable->serialNumber;
     }
 }
 
 void
 ValidatePicture(PicturePtr pPicture)
 {
-    ValidateOnePicture (pPicture);
+    ValidateOnePicture(pPicture);
     if (pPicture->alphaMap)
-	ValidateOnePicture (pPicture->alphaMap);
+        ValidateOnePicture(pPicture->alphaMap);
 }
 
 int
-FreePicture (pointer	value,
-	     XID	pid)
+FreePicture(pointer value, XID pid)
 {
-    PicturePtr	pPicture = (PicturePtr) value;
+    PicturePtr pPicture = (PicturePtr) value;
 
-    if (--pPicture->refcnt == 0)
-    {
-	free(pPicture->transform);
+    if (--pPicture->refcnt == 0) {
+        free(pPicture->transform);
 
-	if (pPicture->pSourcePict)
-	{
-	    if (pPicture->pSourcePict->type != SourcePictTypeSolidFill)
-		free(pPicture->pSourcePict->linear.stops);
+        if (pPicture->pSourcePict) {
+            if (pPicture->pSourcePict->type != SourcePictTypeSolidFill)
+                free(pPicture->pSourcePict->linear.stops);
 
-	    free(pPicture->pSourcePict);
-	}
+            free(pPicture->pSourcePict);
+        }
+
+        if (pPicture->pDrawable) {
+            ScreenPtr pScreen = pPicture->pDrawable->pScreen;
+            PictureScreenPtr ps = GetPictureScreen(pScreen);
 
-	if (pPicture->pDrawable)
-	{
-            ScreenPtr	    pScreen = pPicture->pDrawable->pScreen;
-            PictureScreenPtr    ps = GetPictureScreen(pScreen);
-	
             if (pPicture->alphaMap)
-                FreePicture ((pointer) pPicture->alphaMap, (XID) 0);
+                FreePicture((pointer) pPicture->alphaMap, (XID) 0);
             (*ps->DestroyPicture) (pPicture);
             (*ps->DestroyPictureClip) (pPicture);
-            if (pPicture->pDrawable->type == DRAWABLE_WINDOW)
-            {
-                WindowPtr	pWindow = (WindowPtr) pPicture->pDrawable;
-                PicturePtr	*pPrev;
-
-                for (pPrev = (PicturePtr *)dixLookupPrivateAddr
-			 (&pWindow->devPrivates, PictureWindowPrivateKey);
-                     *pPrev;
-                     pPrev = &(*pPrev)->pNext)
-                {
-                    if (*pPrev == pPicture)
-                    {
+            if (pPicture->pDrawable->type == DRAWABLE_WINDOW) {
+                WindowPtr pWindow = (WindowPtr) pPicture->pDrawable;
+                PicturePtr *pPrev;
+
+                for (pPrev = (PicturePtr *) dixLookupPrivateAddr
+                     (&pWindow->devPrivates, PictureWindowPrivateKey);
+                     *pPrev; pPrev = &(*pPrev)->pNext) {
+                    if (*pPrev == pPicture) {
                         *pPrev = pPicture->pNext;
                         break;
                     }
                 }
             }
-            else if (pPicture->pDrawable->type == DRAWABLE_PIXMAP)
-            {
-                (*pScreen->DestroyPixmap) ((PixmapPtr)pPicture->pDrawable);
+            else if (pPicture->pDrawable->type == DRAWABLE_PIXMAP) {
+                (*pScreen->DestroyPixmap) ((PixmapPtr) pPicture->pDrawable);
             }
         }
-	dixFreeObjectWithPrivates(pPicture, PRIVATE_PICTURE);
+        dixFreeObjectWithPrivates(pPicture, PRIVATE_PICTURE);
     }
     return Success;
 }
 
 int
-FreePictFormat (pointer	pPictFormat,
-		XID     pid)
+FreePictFormat(pointer pPictFormat, XID pid)
 {
     return Success;
 }
@@ -1521,8 +1459,8 @@ FreePictFormat (pointer	pPictFormat,
  * being careful to avoid these cases.
  */
 static CARD8
-ReduceCompositeOp (CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
-		   INT16 xSrc, INT16 ySrc, CARD16 width, CARD16 height)
+ReduceCompositeOp(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
+                  INT16 xSrc, INT16 ySrc, CARD16 width, CARD16 height)
 {
     Bool no_src_alpha, no_dst_alpha;
 
@@ -1533,228 +1471,197 @@ ReduceCompositeOp (CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
      * picture.
      */
     no_src_alpha = PICT_FORMAT_COLOR(pSrc->format) &&
-                   PICT_FORMAT_A(pSrc->format) == 0 &&
-                   (pSrc->repeatType != RepeatNone ||
-		    (!pSrc->transform &&
-		     xSrc >= 0 && ySrc >= 0 &&
-		     xSrc + width <= pSrc->pDrawable->width &&
-		     ySrc + height <= pSrc->pDrawable->height)) &&
-                   pSrc->alphaMap == NULL &&
-                   pMask == NULL;
+        PICT_FORMAT_A(pSrc->format) == 0 &&
+        (pSrc->repeatType != RepeatNone ||
+         (!pSrc->transform &&
+          xSrc >= 0 && ySrc >= 0 &&
+          xSrc + width <= pSrc->pDrawable->width &&
+          ySrc + height <= pSrc->pDrawable->height)) &&
+        pSrc->alphaMap == NULL && pMask == NULL;
     no_dst_alpha = PICT_FORMAT_COLOR(pDst->format) &&
-                   PICT_FORMAT_A(pDst->format) == 0 &&
-                   pDst->alphaMap == NULL;
+        PICT_FORMAT_A(pDst->format) == 0 && pDst->alphaMap == NULL;
 
     /* TODO, maybe: Conjoint and Disjoint op reductions? */
- 
+
     /* Deal with simplifications where the source alpha is always 1. */
-    if (no_src_alpha)
-    {
-	switch (op) {
-	case PictOpOver:
-	    op = PictOpSrc;
-	    break;
-	case PictOpInReverse:
-	    op = PictOpDst;
-	    break;
-	case PictOpOutReverse:
-	    op = PictOpClear;
-	    break;
-	case PictOpAtop:
-	    op = PictOpIn;
-	    break;
-	case PictOpAtopReverse:
-	    op = PictOpOverReverse;
-	    break;
-	case PictOpXor:
-	    op = PictOpOut;
-	    break;
-	default:
-	    break;
-	}
+    if (no_src_alpha) {
+        switch (op) {
+        case PictOpOver:
+            op = PictOpSrc;
+            break;
+        case PictOpInReverse:
+            op = PictOpDst;
+            break;
+        case PictOpOutReverse:
+            op = PictOpClear;
+            break;
+        case PictOpAtop:
+            op = PictOpIn;
+            break;
+        case PictOpAtopReverse:
+            op = PictOpOverReverse;
+            break;
+        case PictOpXor:
+            op = PictOpOut;
+            break;
+        default:
+            break;
+        }
     }
 
     /* Deal with simplifications when the destination alpha is always 1 */
-    if (no_dst_alpha)
-    {
-	switch (op) {
-	case PictOpOverReverse:
-	    op = PictOpDst;
-	    break;
-	case PictOpIn:
-	    op = PictOpSrc;
-	    break;
-	case PictOpOut:
-	    op = PictOpClear;
-	    break;
-	case PictOpAtop:
-	    op = PictOpOver;
-	    break;
-	case PictOpXor:
-	    op = PictOpOutReverse;
-	    break;
-	default:
-	    break;
-	}
+    if (no_dst_alpha) {
+        switch (op) {
+        case PictOpOverReverse:
+            op = PictOpDst;
+            break;
+        case PictOpIn:
+            op = PictOpSrc;
+            break;
+        case PictOpOut:
+            op = PictOpClear;
+            break;
+        case PictOpAtop:
+            op = PictOpOver;
+            break;
+        case PictOpXor:
+            op = PictOpOutReverse;
+            break;
+        default:
+            break;
+        }
     }
 
     /* Reduce some con/disjoint ops to the basic names. */
     switch (op) {
     case PictOpDisjointClear:
     case PictOpConjointClear:
-	op = PictOpClear;
-	break;
+        op = PictOpClear;
+        break;
     case PictOpDisjointSrc:
     case PictOpConjointSrc:
-	op = PictOpSrc;
-	break;
+        op = PictOpSrc;
+        break;
     case PictOpDisjointDst:
     case PictOpConjointDst:
-	op = PictOpDst;
-	break;
+        op = PictOpDst;
+        break;
     default:
-	break;
+        break;
     }
 
     return op;
 }
 
 void
-CompositePicture (CARD8		op,
-		  PicturePtr	pSrc,
-		  PicturePtr	pMask,
-		  PicturePtr	pDst,
-		  INT16		xSrc,
-		  INT16		ySrc,
-		  INT16		xMask,
-		  INT16		yMask,
-		  INT16		xDst,
-		  INT16		yDst,
-		  CARD16	width,
-		  CARD16	height)
+CompositePicture(CARD8 op,
+                 PicturePtr pSrc,
+                 PicturePtr pMask,
+                 PicturePtr pDst,
+                 INT16 xSrc,
+                 INT16 ySrc,
+                 INT16 xMask,
+                 INT16 yMask,
+                 INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
 {
-    PictureScreenPtr	ps = GetPictureScreen(pDst->pDrawable->pScreen);
-    
-    ValidatePicture (pSrc);
+    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);
+
+    ValidatePicture(pSrc);
     if (pMask)
-	ValidatePicture (pMask);
-    ValidatePicture (pDst);
+        ValidatePicture(pMask);
+    ValidatePicture(pDst);
 
-    op = ReduceCompositeOp (op, pSrc, pMask, pDst, xSrc, ySrc, width, height);
+    op = ReduceCompositeOp(op, pSrc, pMask, pDst, xSrc, ySrc, width, height);
     if (op == PictOpDst)
-	return;
+        return;
 
     (*ps->Composite) (op,
-		       pSrc,
-		       pMask,
-		       pDst,
-		       xSrc,
-		       ySrc,
-		       xMask,
-		       yMask,
-		       xDst,
-		       yDst,
-		       width,
-		       height);
+                      pSrc,
+                      pMask,
+                      pDst,
+                      xSrc, ySrc, xMask, yMask, xDst, yDst, width, height);
 }
 
 void
-CompositeRects (CARD8		op,
-		PicturePtr	pDst,
-		xRenderColor	*color,
-		int		nRect,
-		xRectangle      *rects)
+CompositeRects(CARD8 op,
+               PicturePtr pDst,
+               xRenderColor * color, int nRect, xRectangle *rects)
 {
-    PictureScreenPtr	ps = GetPictureScreen(pDst->pDrawable->pScreen);
-    
-    ValidatePicture (pDst);
+    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);
+
+    ValidatePicture(pDst);
     (*ps->CompositeRects) (op, pDst, color, nRect, rects);
 }
 
 void
-CompositeTrapezoids (CARD8	    op,
-		     PicturePtr	    pSrc,
-		     PicturePtr	    pDst,
-		     PictFormatPtr  maskFormat,
-		     INT16	    xSrc,
-		     INT16	    ySrc,
-		     int	    ntrap,
-		     xTrapezoid	    *traps)
+CompositeTrapezoids(CARD8 op,
+                    PicturePtr pSrc,
+                    PicturePtr pDst,
+                    PictFormatPtr maskFormat,
+                    INT16 xSrc, INT16 ySrc, int ntrap, xTrapezoid * traps)
 {
-    PictureScreenPtr	ps = GetPictureScreen(pDst->pDrawable->pScreen);
-    
-    ValidatePicture (pSrc);
-    ValidatePicture (pDst);
+    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);
+
+    ValidatePicture(pSrc);
+    ValidatePicture(pDst);
     (*ps->Trapezoids) (op, pSrc, pDst, maskFormat, xSrc, ySrc, ntrap, traps);
 }
 
 void
-CompositeTriangles (CARD8	    op,
-		    PicturePtr	    pSrc,
-		    PicturePtr	    pDst,
-		    PictFormatPtr   maskFormat,
-		    INT16	    xSrc,
-		    INT16	    ySrc,
-		    int		    ntriangles,
-		    xTriangle	    *triangles)
+CompositeTriangles(CARD8 op,
+                   PicturePtr pSrc,
+                   PicturePtr pDst,
+                   PictFormatPtr maskFormat,
+                   INT16 xSrc,
+                   INT16 ySrc, int ntriangles, xTriangle * triangles)
 {
-    PictureScreenPtr	ps = GetPictureScreen(pDst->pDrawable->pScreen);
-    
-    ValidatePicture (pSrc);
-    ValidatePicture (pDst);
-    (*ps->Triangles) (op, pSrc, pDst, maskFormat, xSrc, ySrc, ntriangles, triangles);
+    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);
+
+    ValidatePicture(pSrc);
+    ValidatePicture(pDst);
+    (*ps->Triangles) (op, pSrc, pDst, maskFormat, xSrc, ySrc, ntriangles,
+                      triangles);
 }
 
 void
-CompositeTriStrip (CARD8	    op,
-		   PicturePtr	    pSrc,
-		   PicturePtr	    pDst,
-		   PictFormatPtr    maskFormat,
-		   INT16	    xSrc,
-		   INT16	    ySrc,
-		   int		    npoints,
-		   xPointFixed	    *points)
+CompositeTriStrip(CARD8 op,
+                  PicturePtr pSrc,
+                  PicturePtr pDst,
+                  PictFormatPtr maskFormat,
+                  INT16 xSrc, INT16 ySrc, int npoints, xPointFixed * points)
 {
-    PictureScreenPtr	ps = GetPictureScreen(pDst->pDrawable->pScreen);
+    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);
 
     if (npoints < 3)
         return;
 
-    ValidatePicture (pSrc);
-    ValidatePicture (pDst);
+    ValidatePicture(pSrc);
+    ValidatePicture(pDst);
     (*ps->TriStrip) (op, pSrc, pDst, maskFormat, xSrc, ySrc, npoints, points);
 }
 
 void
-CompositeTriFan (CARD8		op,
-		 PicturePtr	pSrc,
-		 PicturePtr	pDst,
-		 PictFormatPtr	maskFormat,
-		 INT16		xSrc,
-		 INT16		ySrc,
-		 int		npoints,
-		 xPointFixed	*points)
+CompositeTriFan(CARD8 op,
+                PicturePtr pSrc,
+                PicturePtr pDst,
+                PictFormatPtr maskFormat,
+                INT16 xSrc, INT16 ySrc, int npoints, xPointFixed * points)
 {
-    PictureScreenPtr	ps = GetPictureScreen(pDst->pDrawable->pScreen);
+    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);
 
     if (npoints < 3)
-	return;
+        return;
 
-    ValidatePicture (pSrc);
-    ValidatePicture (pDst);
+    ValidatePicture(pSrc);
+    ValidatePicture(pDst);
     (*ps->TriFan) (op, pSrc, pDst, maskFormat, xSrc, ySrc, npoints, points);
 }
 
 void
-AddTraps (PicturePtr	pPicture,
-	  INT16		xOff,
-	  INT16		yOff,
-	  int		ntrap,
-	  xTrap		*traps)
+AddTraps(PicturePtr pPicture, INT16 xOff, INT16 yOff, int ntrap, xTrap * traps)
 {
-    PictureScreenPtr	ps = GetPictureScreen(pPicture->pDrawable->pScreen);
-    
-    ValidatePicture (pPicture);
+    PictureScreenPtr ps = GetPictureScreen(pPicture->pDrawable->pScreen);
+
+    ValidatePicture(pPicture);
     (*ps->AddTraps) (pPicture, xOff, yOff, ntrap, traps);
 }
-
diff --git a/render/picture.h b/render/picture.h
index e5f0d78f6..c85353a44 100644
--- a/render/picture.h
+++ b/render/picture.h
@@ -29,9 +29,9 @@
 
 #include <pixman.h>
 
-typedef struct _DirectFormat	*DirectFormatPtr;
-typedef struct _PictFormat	*PictFormatPtr;
-typedef struct _Picture		*PicturePtr;
+typedef struct _DirectFormat *DirectFormatPtr;
+typedef struct _PictFormat *PictFormatPtr;
+typedef struct _Picture *PicturePtr;
 
 /*
  * While the protocol is generous in format support, the
@@ -68,64 +68,64 @@ typedef struct _Picture		*PicturePtr;
 
 /* 32bpp formats */
 typedef enum _PictFormatShort {
-    PICT_a2r10g10b10 =	PIXMAN_a2r10g10b10,
-    PICT_x2r10g10b10 =	PIXMAN_x2r10g10b10,
-    PICT_a2b10g10r10 =	PIXMAN_a2b10g10r10,
-    PICT_x2b10g10r10 =	PIXMAN_x2b10g10r10,
-
-    PICT_a8r8g8b8 =	PIXMAN_a8r8g8b8,
-    PICT_x8r8g8b8 =	PIXMAN_x8r8g8b8,
-    PICT_a8b8g8r8 =	PIXMAN_a8b8g8r8,
-    PICT_x8b8g8r8 =	PIXMAN_x8b8g8r8,
-    PICT_b8g8r8a8 =	PIXMAN_b8g8r8a8,
-    PICT_b8g8r8x8 =	PIXMAN_b8g8r8x8,
+    PICT_a2r10g10b10 = PIXMAN_a2r10g10b10,
+    PICT_x2r10g10b10 = PIXMAN_x2r10g10b10,
+    PICT_a2b10g10r10 = PIXMAN_a2b10g10r10,
+    PICT_x2b10g10r10 = PIXMAN_x2b10g10r10,
+
+    PICT_a8r8g8b8 = PIXMAN_a8r8g8b8,
+    PICT_x8r8g8b8 = PIXMAN_x8r8g8b8,
+    PICT_a8b8g8r8 = PIXMAN_a8b8g8r8,
+    PICT_x8b8g8r8 = PIXMAN_x8b8g8r8,
+    PICT_b8g8r8a8 = PIXMAN_b8g8r8a8,
+    PICT_b8g8r8x8 = PIXMAN_b8g8r8x8,
 
 /* 24bpp formats */
-    PICT_r8g8b8 =	PIXMAN_r8g8b8,
-    PICT_b8g8r8 =	PIXMAN_b8g8r8,
+    PICT_r8g8b8 = PIXMAN_r8g8b8,
+    PICT_b8g8r8 = PIXMAN_b8g8r8,
 
 /* 16bpp formats */
-    PICT_r5g6b5 =	PIXMAN_r5g6b5,
-    PICT_b5g6r5 =	PIXMAN_b5g6r5,
-
-    PICT_a1r5g5b5 =	PIXMAN_a1r5g5b5,
-    PICT_x1r5g5b5 =	PIXMAN_x1r5g5b5,
-    PICT_a1b5g5r5 =	PIXMAN_a1b5g5r5,
-    PICT_x1b5g5r5 =	PIXMAN_x1b5g5r5,
-    PICT_a4r4g4b4 =	PIXMAN_a4r4g4b4,
-    PICT_x4r4g4b4 =	PIXMAN_x4r4g4b4,
-    PICT_a4b4g4r4 =	PIXMAN_a4b4g4r4,
-    PICT_x4b4g4r4 =	PIXMAN_x4b4g4r4,
+    PICT_r5g6b5 = PIXMAN_r5g6b5,
+    PICT_b5g6r5 = PIXMAN_b5g6r5,
+
+    PICT_a1r5g5b5 = PIXMAN_a1r5g5b5,
+    PICT_x1r5g5b5 = PIXMAN_x1r5g5b5,
+    PICT_a1b5g5r5 = PIXMAN_a1b5g5r5,
+    PICT_x1b5g5r5 = PIXMAN_x1b5g5r5,
+    PICT_a4r4g4b4 = PIXMAN_a4r4g4b4,
+    PICT_x4r4g4b4 = PIXMAN_x4r4g4b4,
+    PICT_a4b4g4r4 = PIXMAN_a4b4g4r4,
+    PICT_x4b4g4r4 = PIXMAN_x4b4g4r4,
 
 /* 8bpp formats */
-    PICT_a8 =		PIXMAN_a8,
-    PICT_r3g3b2 =	PIXMAN_r3g3b2,
-    PICT_b2g3r3 =	PIXMAN_b2g3r3,
-    PICT_a2r2g2b2 =	PIXMAN_a2r2g2b2,
-    PICT_a2b2g2r2 =	PIXMAN_a2b2g2r2,
+    PICT_a8 = PIXMAN_a8,
+    PICT_r3g3b2 = PIXMAN_r3g3b2,
+    PICT_b2g3r3 = PIXMAN_b2g3r3,
+    PICT_a2r2g2b2 = PIXMAN_a2r2g2b2,
+    PICT_a2b2g2r2 = PIXMAN_a2b2g2r2,
 
-    PICT_c8 =		PIXMAN_c8,
-    PICT_g8 =		PIXMAN_g8,
+    PICT_c8 = PIXMAN_c8,
+    PICT_g8 = PIXMAN_g8,
 
-    PICT_x4a4 =		PIXMAN_x4a4,
-				    
-    PICT_x4c4 =		PIXMAN_x4c4,
-    PICT_x4g4 =		PIXMAN_x4g4,
+    PICT_x4a4 = PIXMAN_x4a4,
+
+    PICT_x4c4 = PIXMAN_x4c4,
+    PICT_x4g4 = PIXMAN_x4g4,
 
 /* 4bpp formats */
-    PICT_a4 =		PIXMAN_a4,
-    PICT_r1g2b1 =	PIXMAN_r1g2b1,
-    PICT_b1g2r1 =	PIXMAN_b1g2r1,
-    PICT_a1r1g1b1 =	PIXMAN_a1r1g1b1,
-    PICT_a1b1g1r1 =	PIXMAN_a1b1g1r1,
-				    
-    PICT_c4 =		PIXMAN_c4,
-    PICT_g4 =		PIXMAN_g4,
+    PICT_a4 = PIXMAN_a4,
+    PICT_r1g2b1 = PIXMAN_r1g2b1,
+    PICT_b1g2r1 = PIXMAN_b1g2r1,
+    PICT_a1r1g1b1 = PIXMAN_a1r1g1b1,
+    PICT_a1b1g1r1 = PIXMAN_a1b1g1r1,
+
+    PICT_c4 = PIXMAN_c4,
+    PICT_g4 = PIXMAN_g4,
 
 /* 1bpp formats */
-    PICT_a1 =		PIXMAN_a1,
+    PICT_a1 = PIXMAN_a1,
 
-    PICT_g1 =		PIXMAN_g1
+    PICT_g1 = PIXMAN_g1
 } PictFormatShort;
 
 /*
@@ -160,7 +160,7 @@ typedef enum _PictFormatShort {
  * 4x4x4 cube allocates another two and nine more are allocated to fill
  * in the 13 levels.  When the 4x4x4 cube is not allocated, a total of
  * 11 cells are allocated.
- */   
+ */
 
 #define PictureCmapPolicyInvalid    -1
 #define PictureCmapPolicyDefault    0
@@ -171,28 +171,29 @@ typedef enum _PictFormatShort {
 
 extern _X_EXPORT int PictureCmapPolicy;
 
-extern _X_EXPORT int PictureParseCmapPolicy (const char *name);
+extern _X_EXPORT int PictureParseCmapPolicy(const char *name);
 
 extern _X_EXPORT int RenderErrBase;
 
 /* Fixed point updates from Carl Worth, USC, Information Sciences Institute */
 
-typedef pixman_fixed_32_32_t	xFixed_32_32;
+typedef pixman_fixed_32_32_t xFixed_32_32;
 
-typedef pixman_fixed_48_16_t	xFixed_48_16;
+typedef pixman_fixed_48_16_t xFixed_48_16;
 
 #define MAX_FIXED_48_16		pixman_max_fixed_48_16
 #define MIN_FIXED_48_16		pixman_min_fixed_48_16
 
-typedef pixman_fixed_1_31_t	xFixed_1_31;
-typedef pixman_fixed_1_16_t	xFixed_1_16;
-typedef pixman_fixed_16_16_t	xFixed_16_16;
+typedef pixman_fixed_1_31_t xFixed_1_31;
+typedef pixman_fixed_1_16_t xFixed_1_16;
+typedef pixman_fixed_16_16_t xFixed_16_16;
 
 /*
  * An unadorned "xFixed" is the same as xFixed_16_16, 
  * (since it's quite common in the code) 
  */
-typedef	pixman_fixed_t	xFixed;
+typedef pixman_fixed_t xFixed;
+
 #define XFIXED_BITS	16
 
 #define xFixedToInt(f)	pixman_fixed_to_int(f)
@@ -228,4 +229,4 @@ typedef	pixman_fixed_t	xFixed;
 				  (((s) >>  8) & 0xff) * 301 + \
 				  (((s)      ) & 0xff) * 58) >> 2)
 
-#endif /* _PICTURE_H_ */
+#endif                          /* _PICTURE_H_ */
diff --git a/render/picturestr.h b/render/picturestr.h
index 9b376710e..cd4ec498c 100644
--- a/render/picturestr.h
+++ b/render/picturestr.h
@@ -30,27 +30,27 @@
 #include "privates.h"
 
 typedef struct _DirectFormat {
-    CARD16	    red, redMask;
-    CARD16	    green, greenMask;
-    CARD16	    blue, blueMask;
-    CARD16	    alpha, alphaMask;
+    CARD16 red, redMask;
+    CARD16 green, greenMask;
+    CARD16 blue, blueMask;
+    CARD16 alpha, alphaMask;
 } DirectFormatRec;
 
 typedef struct _IndexFormat {
-    VisualID	    vid;
-    ColormapPtr	    pColormap;
-    int		    nvalues;
-    xIndexValue	    *pValues;
-    void	    *devPrivate;
+    VisualID vid;
+    ColormapPtr pColormap;
+    int nvalues;
+    xIndexValue *pValues;
+    void *devPrivate;
 } IndexFormatRec;
 
 typedef struct _PictFormat {
-    CARD32	    id;
-    CARD32	    format;	    /* except bpp */
-    unsigned char   type;
-    unsigned char   depth;
+    CARD32 id;
+    CARD32 format;              /* except bpp */
+    unsigned char type;
+    unsigned char depth;
     DirectFormatRec direct;
-    IndexFormatRec  index;
+    IndexFormatRec index;
 } PictFormatRec;
 
 typedef struct pixman_vector PictVector, *PictVectorPtr;
@@ -121,53 +121,53 @@ typedef union _SourcePict {
 } SourcePict, *SourcePictPtr;
 
 typedef struct _Picture {
-    DrawablePtr	    pDrawable;
-    PictFormatPtr   pFormat;
-    PictFormatShort format;	    /* PICT_FORMAT */
-    int		    refcnt;
-    CARD32	    id;
-    unsigned int    repeat : 1;
-    unsigned int    graphicsExposures : 1;
-    unsigned int    subWindowMode : 1;
-    unsigned int    polyEdge : 1;
-    unsigned int    polyMode : 1;
-    unsigned int    freeCompClip : 1;
-    unsigned int    clientClipType : 2;
-    unsigned int    componentAlpha : 1;
-    unsigned int    repeatType : 2;
-    unsigned int    filter : 3;
-    unsigned int    stateChanges : CPLastBit;
-    unsigned int    unused : 18 - CPLastBit;
-
-    PicturePtr	    pNext;	    /* chain on same drawable */
-
-    PicturePtr	    alphaMap;
-    DDXPointRec	    alphaOrigin;
-
-    DDXPointRec	    clipOrigin;
-    pointer	    clientClip;
-
-    unsigned long   serialNumber;
-
-    RegionPtr	    pCompositeClip;
-
-    PrivateRec	    *devPrivates;
-
-    PictTransform   *transform;
-
-    SourcePictPtr   pSourcePict;
-    xFixed	    *filter_params;
-    int		    filter_nparams;
+    DrawablePtr pDrawable;
+    PictFormatPtr pFormat;
+    PictFormatShort format;     /* PICT_FORMAT */
+    int refcnt;
+    CARD32 id;
+    unsigned int repeat:1;
+    unsigned int graphicsExposures:1;
+    unsigned int subWindowMode:1;
+    unsigned int polyEdge:1;
+    unsigned int polyMode:1;
+    unsigned int freeCompClip:1;
+    unsigned int clientClipType:2;
+    unsigned int componentAlpha:1;
+    unsigned int repeatType:2;
+    unsigned int filter:3;
+    unsigned int stateChanges:CPLastBit;
+    unsigned int unused:18 - CPLastBit;
+
+    PicturePtr pNext;           /* chain on same drawable */
+
+    PicturePtr alphaMap;
+    DDXPointRec alphaOrigin;
+
+    DDXPointRec clipOrigin;
+    pointer clientClip;
+
+    unsigned long serialNumber;
+
+    RegionPtr pCompositeClip;
+
+    PrivateRec *devPrivates;
+
+    PictTransform *transform;
+
+    SourcePictPtr pSourcePict;
+    xFixed *filter_params;
+    int filter_nparams;
 } PictureRec;
 
 typedef Bool (*PictFilterValidateParamsProcPtr) (ScreenPtr pScreen, int id,
-						 xFixed *params, int nparams,
-						 int *width, int *height);
+                                                 xFixed * params, int nparams,
+                                                 int *width, int *height);
 typedef struct {
-    char			    *name;
-    int				    id;
+    char *name;
+    int id;
     PictFilterValidateParamsProcPtr ValidateParams;
-    int				    width, height;
+    int width, height;
 } PictFilterRec, *PictFilterPtr;
 
 #define PictFilterNearest	0
@@ -181,205 +181,180 @@ typedef struct {
 /* if you add an 8th filter, expand the filter bitfield above */
 
 typedef struct {
-    char	    *alias;
-    int		    alias_id;
-    int		    filter_id;
+    char *alias;
+    int alias_id;
+    int filter_id;
 } PictFilterAliasRec, *PictFilterAliasPtr;
 
-typedef int	(*CreatePictureProcPtr)	    (PicturePtr pPicture);
-typedef void	(*DestroyPictureProcPtr)    (PicturePtr pPicture);
-typedef int	(*ChangePictureClipProcPtr) (PicturePtr	pPicture,
-					     int	clipType,
-					     pointer    value,
-					     int	n);
-typedef void	(*DestroyPictureClipProcPtr)(PicturePtr	pPicture);
-
-typedef int	(*ChangePictureTransformProcPtr)    (PicturePtr	    pPicture,
-						     PictTransform  *transform);
-
-typedef int	(*ChangePictureFilterProcPtr)	(PicturePtr	pPicture,
-						 int		filter,
-						 xFixed		*params,
-						 int		nparams);
-
-typedef void	(*DestroyPictureFilterProcPtr)	(PicturePtr pPicture);
-
-typedef void	(*ChangePictureProcPtr)	    (PicturePtr pPicture,
-					     Mask	mask);
-typedef void	(*ValidatePictureProcPtr)    (PicturePtr pPicture,
-					     Mask       mask);
-typedef void	(*CompositeProcPtr)	    (CARD8	op,
-					     PicturePtr pSrc,
-					     PicturePtr pMask,
-					     PicturePtr pDst,
-					     INT16	xSrc,
-					     INT16	ySrc,
-					     INT16	xMask,
-					     INT16	yMask,
-					     INT16	xDst,
-					     INT16	yDst,
-					     CARD16	width,
-					     CARD16	height);
-
-typedef void	(*GlyphsProcPtr)	    (CARD8      op,
-					     PicturePtr pSrc,
-					     PicturePtr pDst,
-					     PictFormatPtr  maskFormat,
-					     INT16      xSrc,
-					     INT16      ySrc,
-					     int	nlists,
-					     GlyphListPtr   lists,
-					     GlyphPtr	*glyphs);
-
-typedef void	(*CompositeRectsProcPtr)    (CARD8	    op,
-					     PicturePtr	    pDst,
-					     xRenderColor   *color,
-					     int	    nRect,
-					     xRectangle	    *rects);
-
-typedef void	(*RasterizeTrapezoidProcPtr)(PicturePtr	    pMask,
-					     xTrapezoid	    *trap,
-					     int	    x_off,
-					     int	    y_off);
-
-typedef void	(*TrapezoidsProcPtr)	    (CARD8	    op,
-					     PicturePtr	    pSrc,
-					     PicturePtr	    pDst,
-					     PictFormatPtr  maskFormat,
-					     INT16	    xSrc,
-					     INT16	    ySrc,
-					     int	    ntrap,
-					     xTrapezoid	    *traps);
-
-typedef void	(*TrianglesProcPtr)	    (CARD8	    op,
-					     PicturePtr	    pSrc,
-					     PicturePtr	    pDst,
-					     PictFormatPtr  maskFormat,
-					     INT16	    xSrc,
-					     INT16	    ySrc,
-					     int	    ntri,
-					     xTriangle	    *tris);
-
-typedef void	(*TriStripProcPtr)	    (CARD8	    op,
-					     PicturePtr	    pSrc,
-					     PicturePtr	    pDst,
-					     PictFormatPtr  maskFormat,
-					     INT16	    xSrc,
-					     INT16	    ySrc,
-					     int	    npoint,
-					     xPointFixed    *points);
-
-typedef void	(*TriFanProcPtr)	    (CARD8	    op,
-					     PicturePtr	    pSrc,
-					     PicturePtr	    pDst,
-					     PictFormatPtr  maskFormat,
-					     INT16	    xSrc,
-					     INT16	    ySrc,
-					     int	    npoint,
-					     xPointFixed    *points);
-
-typedef Bool	(*InitIndexedProcPtr)	    (ScreenPtr	    pScreen,
-					     PictFormatPtr  pFormat);
-
-typedef void	(*CloseIndexedProcPtr)	    (ScreenPtr	    pScreen,
-					     PictFormatPtr  pFormat);
-
-typedef void	(*UpdateIndexedProcPtr)	    (ScreenPtr	    pScreen,
-					     PictFormatPtr  pFormat,
-					     int	    ndef,
-					     xColorItem	    *pdef);
-
-typedef void	(*AddTrapsProcPtr)	    (PicturePtr	    pPicture,
-					     INT16	    xOff,
-					     INT16	    yOff,
-					     int	    ntrap,
-					     xTrap	    *traps);
-
-typedef void	(*AddTrianglesProcPtr)	    (PicturePtr	    pPicture,
-					     INT16	    xOff,
-					     INT16	    yOff,
-					     int	    ntri,
-					     xTriangle	    *tris);
-
-typedef Bool	(*RealizeGlyphProcPtr)	    (ScreenPtr	    pScreen,
-					     GlyphPtr	    glyph);
-
-typedef void	(*UnrealizeGlyphProcPtr)    (ScreenPtr	    pScreen,
-					     GlyphPtr	    glyph);
+typedef int (*CreatePictureProcPtr) (PicturePtr pPicture);
+typedef void (*DestroyPictureProcPtr) (PicturePtr pPicture);
+typedef int (*ChangePictureClipProcPtr) (PicturePtr pPicture,
+                                         int clipType, pointer value, int n);
+typedef void (*DestroyPictureClipProcPtr) (PicturePtr pPicture);
+
+typedef int (*ChangePictureTransformProcPtr) (PicturePtr pPicture,
+                                              PictTransform * transform);
+
+typedef int (*ChangePictureFilterProcPtr) (PicturePtr pPicture,
+                                           int filter,
+                                           xFixed * params, int nparams);
+
+typedef void (*DestroyPictureFilterProcPtr) (PicturePtr pPicture);
+
+typedef void (*ChangePictureProcPtr) (PicturePtr pPicture, Mask mask);
+typedef void (*ValidatePictureProcPtr) (PicturePtr pPicture, Mask mask);
+typedef void (*CompositeProcPtr) (CARD8 op,
+                                  PicturePtr pSrc,
+                                  PicturePtr pMask,
+                                  PicturePtr pDst,
+                                  INT16 xSrc,
+                                  INT16 ySrc,
+                                  INT16 xMask,
+                                  INT16 yMask,
+                                  INT16 xDst,
+                                  INT16 yDst, CARD16 width, CARD16 height);
+
+typedef void (*GlyphsProcPtr) (CARD8 op,
+                               PicturePtr pSrc,
+                               PicturePtr pDst,
+                               PictFormatPtr maskFormat,
+                               INT16 xSrc,
+                               INT16 ySrc,
+                               int nlists,
+                               GlyphListPtr lists, GlyphPtr * glyphs);
+
+typedef void (*CompositeRectsProcPtr) (CARD8 op,
+                                       PicturePtr pDst,
+                                       xRenderColor * color,
+                                       int nRect, xRectangle *rects);
+
+typedef void (*RasterizeTrapezoidProcPtr) (PicturePtr pMask,
+                                           xTrapezoid * trap,
+                                           int x_off, int y_off);
+
+typedef void (*TrapezoidsProcPtr) (CARD8 op,
+                                   PicturePtr pSrc,
+                                   PicturePtr pDst,
+                                   PictFormatPtr maskFormat,
+                                   INT16 xSrc,
+                                   INT16 ySrc, int ntrap, xTrapezoid * traps);
+
+typedef void (*TrianglesProcPtr) (CARD8 op,
+                                  PicturePtr pSrc,
+                                  PicturePtr pDst,
+                                  PictFormatPtr maskFormat,
+                                  INT16 xSrc,
+                                  INT16 ySrc, int ntri, xTriangle * tris);
+
+typedef void (*TriStripProcPtr) (CARD8 op,
+                                 PicturePtr pSrc,
+                                 PicturePtr pDst,
+                                 PictFormatPtr maskFormat,
+                                 INT16 xSrc,
+                                 INT16 ySrc, int npoint, xPointFixed * points);
+
+typedef void (*TriFanProcPtr) (CARD8 op,
+                               PicturePtr pSrc,
+                               PicturePtr pDst,
+                               PictFormatPtr maskFormat,
+                               INT16 xSrc,
+                               INT16 ySrc, int npoint, xPointFixed * points);
+
+typedef Bool (*InitIndexedProcPtr) (ScreenPtr pScreen, PictFormatPtr pFormat);
+
+typedef void (*CloseIndexedProcPtr) (ScreenPtr pScreen, PictFormatPtr pFormat);
+
+typedef void (*UpdateIndexedProcPtr) (ScreenPtr pScreen,
+                                      PictFormatPtr pFormat,
+                                      int ndef, xColorItem * pdef);
+
+typedef void (*AddTrapsProcPtr) (PicturePtr pPicture,
+                                 INT16 xOff,
+                                 INT16 yOff, int ntrap, xTrap * traps);
+
+typedef void (*AddTrianglesProcPtr) (PicturePtr pPicture,
+                                     INT16 xOff,
+                                     INT16 yOff, int ntri, xTriangle * tris);
+
+typedef Bool (*RealizeGlyphProcPtr) (ScreenPtr pScreen, GlyphPtr glyph);
+
+typedef void (*UnrealizeGlyphProcPtr) (ScreenPtr pScreen, GlyphPtr glyph);
 
 typedef struct _PictureScreen {
-    PictFormatPtr		formats;
-    PictFormatPtr		fallback;
-    int				nformats;
+    PictFormatPtr formats;
+    PictFormatPtr fallback;
+    int nformats;
 
-    CreatePictureProcPtr	CreatePicture;
-    DestroyPictureProcPtr	DestroyPicture;
-    ChangePictureClipProcPtr	ChangePictureClip;
-    DestroyPictureClipProcPtr	DestroyPictureClip;
+    CreatePictureProcPtr CreatePicture;
+    DestroyPictureProcPtr DestroyPicture;
+    ChangePictureClipProcPtr ChangePictureClip;
+    DestroyPictureClipProcPtr DestroyPictureClip;
 
-    ChangePictureProcPtr	ChangePicture;
-    ValidatePictureProcPtr	ValidatePicture;
+    ChangePictureProcPtr ChangePicture;
+    ValidatePictureProcPtr ValidatePicture;
 
-    CompositeProcPtr		Composite;
-    GlyphsProcPtr		Glyphs; /* unused */
-    CompositeRectsProcPtr	CompositeRects;
+    CompositeProcPtr Composite;
+    GlyphsProcPtr Glyphs;       /* unused */
+    CompositeRectsProcPtr CompositeRects;
 
-    DestroyWindowProcPtr	DestroyWindow;
-    CloseScreenProcPtr		CloseScreen;
+    DestroyWindowProcPtr DestroyWindow;
+    CloseScreenProcPtr CloseScreen;
 
-    StoreColorsProcPtr		StoreColors;
+    StoreColorsProcPtr StoreColors;
 
-    InitIndexedProcPtr		InitIndexed;
-    CloseIndexedProcPtr		CloseIndexed;
-    UpdateIndexedProcPtr	UpdateIndexed;
+    InitIndexedProcPtr InitIndexed;
+    CloseIndexedProcPtr CloseIndexed;
+    UpdateIndexedProcPtr UpdateIndexed;
 
-    int				subpixel;
+    int subpixel;
 
-    PictFilterPtr		filters;
-    int				nfilters;
-    PictFilterAliasPtr		filterAliases;
-    int				nfilterAliases;
+    PictFilterPtr filters;
+    int nfilters;
+    PictFilterAliasPtr filterAliases;
+    int nfilterAliases;
 
     /**
      * Called immediately after a picture's transform is changed through the
      * SetPictureTransform request.  Not called for source-only pictures.
      */
-    ChangePictureTransformProcPtr   ChangePictureTransform;
+    ChangePictureTransformProcPtr ChangePictureTransform;
 
     /**
      * Called immediately after a picture's transform is changed through the
      * SetPictureFilter request.  Not called for source-only pictures.
      */
-    ChangePictureFilterProcPtr	ChangePictureFilter;
+    ChangePictureFilterProcPtr ChangePictureFilter;
 
-    DestroyPictureFilterProcPtr	DestroyPictureFilter;
+    DestroyPictureFilterProcPtr DestroyPictureFilter;
 
-    TrapezoidsProcPtr		Trapezoids;
-    TrianglesProcPtr		Triangles;
+    TrapezoidsProcPtr Trapezoids;
+    TrianglesProcPtr Triangles;
 
-    RasterizeTrapezoidProcPtr	RasterizeTrapezoid;
+    RasterizeTrapezoidProcPtr RasterizeTrapezoid;
 
-    AddTrianglesProcPtr		AddTriangles;
+    AddTrianglesProcPtr AddTriangles;
 
-    AddTrapsProcPtr		AddTraps;
+    AddTrapsProcPtr AddTraps;
 
-    RealizeGlyphProcPtr   	RealizeGlyph;
-    UnrealizeGlyphProcPtr 	UnrealizeGlyph;
+    RealizeGlyphProcPtr RealizeGlyph;
+    UnrealizeGlyphProcPtr UnrealizeGlyph;
 
 #define PICTURE_SCREEN_VERSION 2
-    TriStripProcPtr		TriStrip;
-    TriFanProcPtr		TriFan;
+    TriStripProcPtr TriStrip;
+    TriFanProcPtr TriFan;
 } PictureScreenRec, *PictureScreenPtr;
 
 extern _X_EXPORT DevPrivateKeyRec PictureScreenPrivateKeyRec;
+
 #define PictureScreenPrivateKey (&PictureScreenPrivateKeyRec)
 
 extern _X_EXPORT DevPrivateKeyRec PictureWindowPrivateKeyRec;
+
 #define	PictureWindowPrivateKey (&PictureWindowPrivateKeyRec)
 
-extern _X_EXPORT RESTYPE	PictureType;
-extern _X_EXPORT RESTYPE	PictFormatType;
-extern _X_EXPORT RESTYPE	GlyphSetType;
+extern _X_EXPORT RESTYPE PictureType;
+extern _X_EXPORT RESTYPE PictFormatType;
+extern _X_EXPORT RESTYPE GlyphSetType;
 
 #define GetPictureScreen(s) ((PictureScreenPtr)dixLookupPrivate(&(s)->devPrivates, PictureScreenPrivateKey))
 #define GetPictureScreenIfSet(s) (dixPrivateKeyRegistered(PictureScreenPrivateKey) ? GetPictureScreen(s) : NULL)
@@ -403,247 +378,216 @@ extern _X_EXPORT RESTYPE	GlyphSetType;
 } \
 
 extern _X_EXPORT Bool
-PictureDestroyWindow (WindowPtr pWindow);
+ PictureDestroyWindow(WindowPtr pWindow);
 
 extern _X_EXPORT Bool
-PictureCloseScreen (int Index, ScreenPtr pScreen);
+ PictureCloseScreen(int Index, ScreenPtr pScreen);
 
 extern _X_EXPORT void
-PictureStoreColors (ColormapPtr pColormap, int ndef, xColorItem *pdef);
+ PictureStoreColors(ColormapPtr pColormap, int ndef, xColorItem * pdef);
 
 extern _X_EXPORT Bool
-PictureInitIndexedFormat (ScreenPtr pScreen, PictFormatPtr format);
+ PictureInitIndexedFormat(ScreenPtr pScreen, PictFormatPtr format);
 
 extern _X_EXPORT Bool
-PictureSetSubpixelOrder (ScreenPtr pScreen, int subpixel);
+ PictureSetSubpixelOrder(ScreenPtr pScreen, int subpixel);
 
 extern _X_EXPORT int
-PictureGetSubpixelOrder (ScreenPtr pScreen);
+ PictureGetSubpixelOrder(ScreenPtr pScreen);
 
 extern _X_EXPORT PictFormatPtr
-PictureCreateDefaultFormats (ScreenPtr pScreen, int *nformatp);
+PictureCreateDefaultFormats(ScreenPtr pScreen, int *nformatp);
 
 extern _X_EXPORT PictFormatPtr
-PictureMatchVisual (ScreenPtr pScreen, int depth, VisualPtr pVisual);
+PictureMatchVisual(ScreenPtr pScreen, int depth, VisualPtr pVisual);
 
 extern _X_EXPORT PictFormatPtr
-PictureMatchFormat (ScreenPtr pScreen, int depth, CARD32 format);
+PictureMatchFormat(ScreenPtr pScreen, int depth, CARD32 format);
 
 extern _X_EXPORT Bool
-PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats);
+ PictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats);
 
 extern _X_EXPORT int
-PictureGetFilterId (const char *filter, int len, Bool makeit);
+ PictureGetFilterId(const char *filter, int len, Bool makeit);
 
-extern _X_EXPORT char *
-PictureGetFilterName (int id);
+extern _X_EXPORT char *PictureGetFilterName(int id);
 
 extern _X_EXPORT int
-PictureAddFilter (ScreenPtr			    pScreen,
-		  const char			    *filter,
-		  PictFilterValidateParamsProcPtr   ValidateParams,
-		  int				    width,
-		  int				    height);
+
+PictureAddFilter(ScreenPtr pScreen,
+                 const char *filter,
+                 PictFilterValidateParamsProcPtr ValidateParams,
+                 int width, int height);
 
 extern _X_EXPORT Bool
-PictureSetFilterAlias (ScreenPtr pScreen, const char *filter, const char *alias);
+
+PictureSetFilterAlias(ScreenPtr pScreen, const char *filter, const char *alias);
 
 extern _X_EXPORT Bool
-PictureSetDefaultFilters (ScreenPtr pScreen);
+ PictureSetDefaultFilters(ScreenPtr pScreen);
 
 extern _X_EXPORT void
-PictureResetFilters (ScreenPtr pScreen);
+ PictureResetFilters(ScreenPtr pScreen);
 
 extern _X_EXPORT PictFilterPtr
-PictureFindFilter (ScreenPtr pScreen, char *name, int len);
+PictureFindFilter(ScreenPtr pScreen, char *name, int len);
 
 extern _X_EXPORT int
-SetPicturePictFilter (PicturePtr pPicture, PictFilterPtr pFilter,
-		      xFixed *params, int nparams);
+
+SetPicturePictFilter(PicturePtr pPicture, PictFilterPtr pFilter,
+                     xFixed * params, int nparams);
 
 extern _X_EXPORT int
-SetPictureFilter (PicturePtr pPicture, char *name, int len,
-		  xFixed *params, int nparams);
+
+SetPictureFilter(PicturePtr pPicture, char *name, int len,
+                 xFixed * params, int nparams);
 
 extern _X_EXPORT Bool
-PictureFinishInit (void);
+ PictureFinishInit(void);
 
 extern _X_EXPORT void
-SetPictureToDefaults (PicturePtr pPicture);
+ SetPictureToDefaults(PicturePtr pPicture);
 
 extern _X_EXPORT PicturePtr
-CreatePicture (Picture		pid,
-	       DrawablePtr	pDrawable,
-	       PictFormatPtr	pFormat,
-	       Mask		mask,
-	       XID		*list,
-	       ClientPtr	client,
-	       int		*error);
+CreatePicture(Picture pid,
+              DrawablePtr pDrawable,
+              PictFormatPtr pFormat,
+              Mask mask, XID *list, ClientPtr client, int *error);
 
 extern _X_EXPORT int
-ChangePicture (PicturePtr	pPicture,
-	       Mask		vmask,
-	       XID		*vlist,
-	       DevUnion		*ulist,
-	       ClientPtr	client);
+
+ChangePicture(PicturePtr pPicture,
+              Mask vmask, XID *vlist, DevUnion *ulist, ClientPtr client);
 
 extern _X_EXPORT int
-SetPictureClipRects (PicturePtr	pPicture,
-		     int	xOrigin,
-		     int	yOrigin,
-		     int	nRect,
-		     xRectangle	*rects);
+
+SetPictureClipRects(PicturePtr pPicture,
+                    int xOrigin, int yOrigin, int nRect, xRectangle *rects);
 
 extern _X_EXPORT int
-SetPictureClipRegion (PicturePtr    pPicture,
-		      int	    xOrigin,
-		      int	    yOrigin,
-		      RegionPtr	    pRegion);
+
+SetPictureClipRegion(PicturePtr pPicture,
+                     int xOrigin, int yOrigin, RegionPtr pRegion);
 
 extern _X_EXPORT int
-SetPictureTransform (PicturePtr	    pPicture,
-		     PictTransform  *transform);
+ SetPictureTransform(PicturePtr pPicture, PictTransform * transform);
 
 extern _X_EXPORT void
-CopyPicture (PicturePtr	pSrc,
-	     Mask	mask,
-	     PicturePtr	pDst);
+ CopyPicture(PicturePtr pSrc, Mask mask, PicturePtr pDst);
 
 extern _X_EXPORT void
-ValidatePicture(PicturePtr pPicture);
+ ValidatePicture(PicturePtr pPicture);
 
 extern _X_EXPORT int
-FreePicture (pointer	pPicture,
-	     XID	pid);
+ FreePicture(pointer pPicture, XID pid);
 
 extern _X_EXPORT int
-FreePictFormat (pointer	pPictFormat,
-		XID     pid);
+ FreePictFormat(pointer pPictFormat, XID pid);
 
 extern _X_EXPORT void
-CompositePicture (CARD8		op,
-		  PicturePtr	pSrc,
-		  PicturePtr	pMask,
-		  PicturePtr	pDst,
-		  INT16		xSrc,
-		  INT16		ySrc,
-		  INT16		xMask,
-		  INT16		yMask,
-		  INT16		xDst,
-		  INT16		yDst,
-		  CARD16	width,
-		  CARD16	height);
+
+CompositePicture(CARD8 op,
+                 PicturePtr pSrc,
+                 PicturePtr pMask,
+                 PicturePtr pDst,
+                 INT16 xSrc,
+                 INT16 ySrc,
+                 INT16 xMask,
+                 INT16 yMask,
+                 INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
 
 extern _X_EXPORT void
-CompositeGlyphs (CARD8		op,
-		 PicturePtr	pSrc,
-		 PicturePtr	pDst,
-		 PictFormatPtr	maskFormat,
-		 INT16		xSrc,
-		 INT16		ySrc,
-		 int		nlist,
-		 GlyphListPtr	lists,
-		 GlyphPtr	*glyphs);
+
+CompositeGlyphs(CARD8 op,
+                PicturePtr pSrc,
+                PicturePtr pDst,
+                PictFormatPtr maskFormat,
+                INT16 xSrc,
+                INT16 ySrc, int nlist, GlyphListPtr lists, GlyphPtr * glyphs);
 
 extern _X_EXPORT void
-CompositeRects (CARD8		op,
-		PicturePtr	pDst,
-		xRenderColor	*color,
-		int		nRect,
-		xRectangle      *rects);
+
+CompositeRects(CARD8 op,
+               PicturePtr pDst,
+               xRenderColor * color, int nRect, xRectangle *rects);
 
 extern _X_EXPORT void
-CompositeTrapezoids (CARD8	    op,
-		     PicturePtr	    pSrc,
-		     PicturePtr	    pDst,
-		     PictFormatPtr  maskFormat,
-		     INT16	    xSrc,
-		     INT16	    ySrc,
-		     int	    ntrap,
-		     xTrapezoid	    *traps);
+
+CompositeTrapezoids(CARD8 op,
+                    PicturePtr pSrc,
+                    PicturePtr pDst,
+                    PictFormatPtr maskFormat,
+                    INT16 xSrc, INT16 ySrc, int ntrap, xTrapezoid * traps);
 
 extern _X_EXPORT void
-CompositeTriangles (CARD8	    op,
-		    PicturePtr	    pSrc,
-		    PicturePtr	    pDst,
-		    PictFormatPtr   maskFormat,
-		    INT16	    xSrc,
-		    INT16	    ySrc,
-		    int		    ntriangles,
-		    xTriangle	    *triangles);
+
+CompositeTriangles(CARD8 op,
+                   PicturePtr pSrc,
+                   PicturePtr pDst,
+                   PictFormatPtr maskFormat,
+                   INT16 xSrc,
+                   INT16 ySrc, int ntriangles, xTriangle * triangles);
 
 extern _X_EXPORT void
-CompositeTriStrip (CARD8	    op,
-		   PicturePtr	    pSrc,
-		   PicturePtr	    pDst,
-		   PictFormatPtr    maskFormat,
-		   INT16	    xSrc,
-		   INT16	    ySrc,
-		   int		    npoints,
-		   xPointFixed	    *points);
+
+CompositeTriStrip(CARD8 op,
+                  PicturePtr pSrc,
+                  PicturePtr pDst,
+                  PictFormatPtr maskFormat,
+                  INT16 xSrc, INT16 ySrc, int npoints, xPointFixed * points);
 
 extern _X_EXPORT void
-CompositeTriFan (CARD8		op,
-		 PicturePtr	pSrc,
-		 PicturePtr	pDst,
-		 PictFormatPtr	maskFormat,
-		 INT16		xSrc,
-		 INT16		ySrc,
-		 int		npoints,
-		 xPointFixed	*points);
 
-extern _X_EXPORT void RenderExtensionInit (void);
+CompositeTriFan(CARD8 op,
+                PicturePtr pSrc,
+                PicturePtr pDst,
+                PictFormatPtr maskFormat,
+                INT16 xSrc, INT16 ySrc, int npoints, xPointFixed * points);
+
+extern _X_EXPORT void RenderExtensionInit(void);
 
 Bool
-AnimCurInit (ScreenPtr pScreen);
+ AnimCurInit(ScreenPtr pScreen);
 
 int
-AnimCursorCreate (CursorPtr *cursors, CARD32 *deltas, int ncursor, CursorPtr *ppCursor, ClientPtr client, XID cid);
+
+AnimCursorCreate(CursorPtr *cursors, CARD32 *deltas, int ncursor,
+                 CursorPtr *ppCursor, ClientPtr client, XID cid);
 
 extern _X_EXPORT void
-AddTraps (PicturePtr	pPicture,
-	  INT16		xOff,
-	  INT16		yOff,
-	  int		ntraps,
-	  xTrap		*traps);
+
+AddTraps(PicturePtr pPicture,
+         INT16 xOff, INT16 yOff, int ntraps, xTrap * traps);
 
 extern _X_EXPORT PicturePtr
-CreateSolidPicture (Picture pid,
-                    xRenderColor *color,
-                    int *error);
+CreateSolidPicture(Picture pid, xRenderColor * color, int *error);
 
 extern _X_EXPORT PicturePtr
-CreateLinearGradientPicture (Picture pid,
-                             xPointFixed *p1,
-                             xPointFixed *p2,
-                             int nStops,
-                             xFixed *stops,
-                             xRenderColor *colors,
-                             int *error);
+CreateLinearGradientPicture(Picture pid,
+                            xPointFixed * p1,
+                            xPointFixed * p2,
+                            int nStops,
+                            xFixed * stops, xRenderColor * colors, int *error);
 
 extern _X_EXPORT PicturePtr
-CreateRadialGradientPicture (Picture pid,
-                             xPointFixed *inner,
-                             xPointFixed *outer,
-                             xFixed innerRadius,
-                             xFixed outerRadius,
-                             int nStops,
-                             xFixed *stops,
-                             xRenderColor *colors,
-                             int *error);
+CreateRadialGradientPicture(Picture pid,
+                            xPointFixed * inner,
+                            xPointFixed * outer,
+                            xFixed innerRadius,
+                            xFixed outerRadius,
+                            int nStops,
+                            xFixed * stops, xRenderColor * colors, int *error);
 
 extern _X_EXPORT PicturePtr
-CreateConicalGradientPicture (Picture pid,
-                              xPointFixed *center,
-                              xFixed angle,
-                              int nStops,
-                              xFixed *stops,
-                              xRenderColor *colors,
-                              int *error);
+CreateConicalGradientPicture(Picture pid,
+                             xPointFixed * center,
+                             xFixed angle,
+                             int nStops,
+                             xFixed * stops, xRenderColor * colors, int *error);
 
 #ifdef PANORAMIX
-extern _X_EXPORT void PanoramiXRenderInit (void);
-extern _X_EXPORT void PanoramiXRenderReset (void);
+extern _X_EXPORT void PanoramiXRenderInit(void);
+extern _X_EXPORT void PanoramiXRenderReset(void);
 #endif
 
 /*
@@ -651,19 +595,19 @@ extern _X_EXPORT void PanoramiXRenderReset (void);
  */
 
 extern _X_EXPORT void
-PictTransform_from_xRenderTransform (PictTransformPtr pict,
-				     xRenderTransform *render);
+
+PictTransform_from_xRenderTransform(PictTransformPtr pict,
+                                    xRenderTransform * render);
 
 extern _X_EXPORT void
-xRenderTransform_from_PictTransform (xRenderTransform *render,
-				     PictTransformPtr pict);
+
+xRenderTransform_from_PictTransform(xRenderTransform * render,
+                                    PictTransformPtr pict);
 
 extern _X_EXPORT Bool
-PictureTransformPoint (PictTransformPtr transform,
-		       PictVectorPtr	vector);
+ PictureTransformPoint(PictTransformPtr transform, PictVectorPtr vector);
 
 extern _X_EXPORT Bool
-PictureTransformPoint3d (PictTransformPtr transform,
-                         PictVectorPtr	vector);
+ PictureTransformPoint3d(PictTransformPtr transform, PictVectorPtr vector);
 
-#endif /* _PICTURESTR_H_ */
+#endif                          /* _PICTURESTR_H_ */
diff --git a/render/render.c b/render/render.c
index d82e09959..a4f58a024 100644
--- a/render/render.c
+++ b/render/render.c
@@ -54,213 +54,209 @@
 
 #include <stdint.h>
 
-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 ProcRenderAddTraps (ClientPtr pClient);
-static int ProcRenderCreateSolidFill (ClientPtr pClient);
-static int ProcRenderCreateLinearGradient (ClientPtr pClient);
-static int ProcRenderCreateRadialGradient (ClientPtr pClient);
-static int ProcRenderCreateConicalGradient (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 SProcRenderAddTraps (ClientPtr pClient);
-static int SProcRenderCreateSolidFill (ClientPtr pClient);
-static int SProcRenderCreateLinearGradient (ClientPtr pClient);
-static int SProcRenderCreateRadialGradient (ClientPtr pClient);
-static int SProcRenderCreateConicalGradient (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,
-    ProcRenderAddTraps,
-    ProcRenderCreateSolidFill,
-    ProcRenderCreateLinearGradient,
-    ProcRenderCreateRadialGradient,
-    ProcRenderCreateConicalGradient
-};
-
-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,
-    SProcRenderAddTraps,
-    SProcRenderCreateSolidFill,
-    SProcRenderCreateLinearGradient,
-    SProcRenderCreateRadialGradient,
-    SProcRenderCreateConicalGradient
-};
-
-int	RenderErrBase;
+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 ProcRenderAddTraps(ClientPtr pClient);
+static int ProcRenderCreateSolidFill(ClientPtr pClient);
+static int ProcRenderCreateLinearGradient(ClientPtr pClient);
+static int ProcRenderCreateRadialGradient(ClientPtr pClient);
+static int ProcRenderCreateConicalGradient(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 SProcRenderAddTraps(ClientPtr pClient);
+static int SProcRenderCreateSolidFill(ClientPtr pClient);
+static int SProcRenderCreateLinearGradient(ClientPtr pClient);
+static int SProcRenderCreateRadialGradient(ClientPtr pClient);
+static int SProcRenderCreateConicalGradient(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,
+        ProcRenderAddTraps,
+        ProcRenderCreateSolidFill,
+        ProcRenderCreateLinearGradient,
+        ProcRenderCreateRadialGradient, ProcRenderCreateConicalGradient};
+
+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,
+        SProcRenderAddTraps,
+        SProcRenderCreateSolidFill,
+        SProcRenderCreateLinearGradient,
+        SProcRenderCreateRadialGradient, SProcRenderCreateConicalGradient};
+
+int RenderErrBase;
 static DevPrivateKeyRec RenderClientPrivateKeyRec;
+
 #define RenderClientPrivateKey (&RenderClientPrivateKeyRec )
 
 typedef struct _RenderClient {
-    int	    major_version;
-    int	    minor_version;
+    int major_version;
+    int minor_version;
 } RenderClientRec, *RenderClientPtr;
 
 #define GetRenderClient(pClient) ((RenderClientPtr)dixLookupPrivate(&(pClient)->devPrivates, RenderClientPrivateKey))
 
 static void
-RenderClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
+RenderClientCallback(CallbackListPtr *list, pointer closure, pointer data)
 {
-    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
-    ClientPtr		pClient = clientinfo->client;
-    RenderClientPtr	pRenderClient = GetRenderClient (pClient);
+    NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
+    ClientPtr pClient = clientinfo->client;
+    RenderClientPtr pRenderClient = GetRenderClient(pClient);
 
     pRenderClient->major_version = 0;
     pRenderClient->minor_version = 0;
 }
 
 #ifdef PANORAMIX
-RESTYPE	XRT_PICTURE;
+RESTYPE XRT_PICTURE;
 #endif
 
 void
-RenderExtensionInit (void)
+RenderExtensionInit(void)
 {
     ExtensionEntry *extEntry;
 
     if (!PictureType)
-	return;
-    if (!PictureFinishInit ())
-	return;
-    if (!dixRegisterPrivateKey(&RenderClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(RenderClientRec)))
-	return;
-    if (!AddCallback (&ClientStateCallback, RenderClientCallback, 0))
-	return;
-
-    extEntry = AddExtension (RENDER_NAME, 0, RenderNumberErrors,
-			     ProcRenderDispatch, SProcRenderDispatch,
-			     NULL, StandardMinorOpcode);
+        return;
+    if (!PictureFinishInit())
+        return;
+    if (!dixRegisterPrivateKey
+        (&RenderClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(RenderClientRec)))
+        return;
+    if (!AddCallback(&ClientStateCallback, RenderClientCallback, 0))
+        return;
+
+    extEntry = AddExtension(RENDER_NAME, 0, RenderNumberErrors,
+                            ProcRenderDispatch, SProcRenderDispatch,
+                            NULL, StandardMinorOpcode);
     if (!extEntry)
-	return;
+        return;
     RenderErrBase = extEntry->errorBase;
 #ifdef PANORAMIX
     if (XRT_PICTURE)
-	SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture);
+        SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture);
 #endif
     SetResourceTypeErrorValue(PictureType, RenderErrBase + BadPicture);
     SetResourceTypeErrorValue(PictFormatType, RenderErrBase + BadPictFormat);
@@ -268,10 +264,11 @@ RenderExtensionInit (void)
 }
 
 static int
-ProcRenderQueryVersion (ClientPtr client)
+ProcRenderQueryVersion(ClientPtr client)
 {
-    RenderClientPtr pRenderClient = GetRenderClient (client);
+    RenderClientPtr pRenderClient = GetRenderClient(client);
     xRenderQueryVersionReply rep;
+
     REQUEST(xRenderQueryVersionReq);
 
     pRenderClient->major_version = stuff->majorVersion;
@@ -284,110 +281,106 @@ ProcRenderQueryVersion (ClientPtr client)
     rep.sequenceNumber = client->sequence;
 
     if ((stuff->majorVersion * 1000 + stuff->minorVersion) <
-        (SERVER_RENDER_MAJOR_VERSION * 1000 + SERVER_RENDER_MINOR_VERSION))
-    {
-	rep.majorVersion = stuff->majorVersion;
-	rep.minorVersion = stuff->minorVersion;
-    } else
-    {
-	rep.majorVersion = SERVER_RENDER_MAJOR_VERSION;
-	rep.minorVersion = SERVER_RENDER_MINOR_VERSION;
+        (SERVER_RENDER_MAJOR_VERSION * 1000 + SERVER_RENDER_MINOR_VERSION)) {
+        rep.majorVersion = stuff->majorVersion;
+        rep.minorVersion = stuff->minorVersion;
+    }
+    else {
+        rep.majorVersion = SERVER_RENDER_MAJOR_VERSION;
+        rep.minorVersion = SERVER_RENDER_MINOR_VERSION;
     }
 
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swapl(&rep.majorVersion);
-	swapl(&rep.minorVersion);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.majorVersion);
+        swapl(&rep.minorVersion);
     }
-    WriteToClient(client, sizeof(xRenderQueryVersionReply), (char *)&rep);
+    WriteToClient(client, sizeof(xRenderQueryVersionReply), (char *) &rep);
     return Success;
 }
 
 static VisualPtr
-findVisual (ScreenPtr pScreen, VisualID vid)
+findVisual(ScreenPtr pScreen, VisualID vid)
 {
-    VisualPtr	pVisual;
-    int		v;
+    VisualPtr pVisual;
+    int v;
 
-    for (v = 0; v < pScreen->numVisuals; v++)
-    {
-	pVisual = pScreen->visuals + v;
-	if (pVisual->vid == vid)
-	    return pVisual;
+    for (v = 0; v < pScreen->numVisuals; v++) {
+        pVisual = pScreen->visuals + v;
+        if (pVisual->vid == vid)
+            return pVisual;
     }
     return 0;
 }
 
 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				    numScreens;
-    int				    numSubpixel;
+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 numScreens;
+    int numSubpixel;
+
 /*    REQUEST(xRenderQueryPictFormatsReq); */
 
     REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq);
 
 #ifdef PANORAMIX
     if (noPanoramiXExtension)
-	numScreens = screenInfo.numScreens;
-    else 
-        numScreens = ((xConnSetup *)ConnectionInfo)->numRoots;
+        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;
+    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;
+        numSubpixel = 0;
     else
-	numSubpixel = numScreens;
-    
-    rlength = (sizeof (xRenderQueryPictFormatsReply) +
-	       nformat * sizeof (xPictFormInfo) +
-	       numScreens * sizeof (xPictScreen) +
-	       ndepth * sizeof (xPictDepth) +
-	       nvisual * sizeof (xPictVisual) +
-	       numSubpixel * sizeof (CARD32));
+        numSubpixel = numScreens;
+
+    rlength = (sizeof(xRenderQueryPictFormatsReply) +
+               nformat * sizeof(xPictFormInfo) +
+               numScreens * sizeof(xPictScreen) +
+               ndepth * sizeof(xPictDepth) +
+               nvisual * sizeof(xPictVisual) + numSubpixel * sizeof(CARD32));
     reply = (xRenderQueryPictFormatsReply *) calloc(1, rlength);
     if (!reply)
-	return BadAlloc;
+        return BadAlloc;
     reply->type = X_Reply;
     reply->sequenceNumber = client->sequence;
     reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));
@@ -396,130 +389,116 @@ ProcRenderQueryPictFormats (ClientPtr client)
     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 = pFormat->direct.alpha;
-		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);
-		    swaps(&pictForm->direct.red);
-		    swaps(&pictForm->direct.redMask);
-		    swaps(&pictForm->direct.green);
-		    swaps(&pictForm->direct.greenMask);
-		    swaps(&pictForm->direct.blue);
-		    swaps(&pictForm->direct.blueMask);
-		    swaps(&pictForm->direct.alpha);
-		    swaps(&pictForm->direct.alphaMask);
-		    swapl(&pictForm->colormap);
-		}
-		pictForm++;
-	    }
-	}
-    }
-    
+
+    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 = pFormat->direct.alpha;
+                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);
+                    swaps(&pictForm->direct.red);
+                    swaps(&pictForm->direct.redMask);
+                    swaps(&pictForm->direct.green);
+                    swaps(&pictForm->direct.greenMask);
+                    swaps(&pictForm->direct.blue);
+                    swaps(&pictForm->direct.blueMask);
+                    swaps(&pictForm->direct.alpha);
+                    swaps(&pictForm->direct.alphaMask);
+                    swapl(&pictForm->colormap);
+                }
+                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);
-			swapl(&pictVisual->format);
-		    }
-		    pictVisual++;
-		    nvisual++;
-		}
-	    }
-	    pictDepth->depth = pDepth->depth;
-	    pictDepth->nPictVisuals = nvisual;
-	    if (client->swapped)
-	    {
-		swaps(&pictDepth->nPictVisuals);
-	    }
-	    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);
-	    swapl(&pictScreen->fallback);
-	}
-	pictScreen = (xPictScreen *) pictDepth;
+    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);
+                        swapl(&pictVisual->format);
+                    }
+                    pictVisual++;
+                    nvisual++;
+                }
+            }
+            pictDepth->depth = pDepth->depth;
+            pictDepth->nPictVisuals = nvisual;
+            if (client->swapped) {
+                swaps(&pictDepth->nPictVisuals);
+            }
+            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);
+            swapl(&pictScreen->fallback);
+        }
+        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);
-	}
-	++pictSubpixel;
-    }
-    
-    if (client->swapped)
-    {
-	swaps(&reply->sequenceNumber);
-	swapl(&reply->length);
-	swapl(&reply->numFormats);
-	swapl(&reply->numScreens);
-	swapl(&reply->numDepths);
-	swapl(&reply->numVisuals);
-	swapl(&reply->numSubpixel);
+
+    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);
+        }
+        ++pictSubpixel;
+    }
+
+    if (client->swapped) {
+        swaps(&reply->sequenceNumber);
+        swapl(&reply->length);
+        swapl(&reply->numFormats);
+        swapl(&reply->numScreens);
+        swapl(&reply->numDepths);
+        swapl(&reply->numVisuals);
+        swapl(&reply->numSubpixel);
     }
     WriteToClient(client, rlength, (char *) reply);
     free(reply);
@@ -527,34 +506,34 @@ ProcRenderQueryPictFormats (ClientPtr client)
 }
 
 static int
-ProcRenderQueryPictIndexValues (ClientPtr client)
+ProcRenderQueryPictIndexValues(ClientPtr client)
 {
-    PictFormatPtr   pFormat;
-    int		    rc, num;
-    int		    rlength;
-    int		    i;
+    PictFormatPtr pFormat;
+    int rc, num;
+    int rlength;
+    int i;
+
     REQUEST(xRenderQueryPictIndexValuesReq);
     xRenderQueryPictIndexValuesReply *reply;
-    xIndexValue	    *values;
+    xIndexValue *values;
 
     REQUEST_AT_LEAST_SIZE(xRenderQueryPictIndexValuesReq);
 
-    rc = dixLookupResourceByType((pointer *)&pFormat, stuff->format,
-				 PictFormatType, client, DixReadAccess);
+    rc = dixLookupResourceByType((pointer *) &pFormat, stuff->format,
+                                 PictFormatType, client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    if (pFormat->type != PictTypeIndexed)
-    {
-	client->errorValue = stuff->format;
-	return BadMatch;
+    if (pFormat->type != PictTypeIndexed) {
+        client->errorValue = stuff->format;
+        return BadMatch;
     }
     num = pFormat->index.nvalues;
-    rlength = (sizeof (xRenderQueryPictIndexValuesReply) + 
-	       num * sizeof(xIndexValue));
+    rlength = (sizeof(xRenderQueryPictIndexValuesReply) +
+               num * sizeof(xIndexValue));
     reply = (xRenderQueryPictIndexValuesReply *) malloc(rlength);
     if (!reply)
-	return BadAlloc;
+        return BadAlloc;
 
     reply->type = X_Reply;
     reply->sequenceNumber = client->sequence;
@@ -562,22 +541,20 @@ ProcRenderQueryPictIndexValues (ClientPtr client)
     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);
-	    swaps(&values[i].red);
-	    swaps(&values[i].green);
-	    swaps(&values[i].blue);
-	    swaps(&values[i].alpha);
-	}
-	swaps(&reply->sequenceNumber);
-	swapl(&reply->length);
-	swapl(&reply->numIndexValues);
+
+    memcpy(reply + 1, pFormat->index.pValues, num * sizeof(xIndexValue));
+
+    if (client->swapped) {
+        for (i = 0; i < num; i++) {
+            swapl(&values[i].pixel);
+            swaps(&values[i].red);
+            swaps(&values[i].green);
+            swaps(&values[i].blue);
+            swaps(&values[i].alpha);
+        }
+        swaps(&reply->sequenceNumber);
+        swapl(&reply->length);
+        swapl(&reply->numIndexValues);
     }
 
     WriteToClient(client, rlength, (char *) reply);
@@ -586,409 +563,411 @@ ProcRenderQueryPictIndexValues (ClientPtr client)
 }
 
 static int
-ProcRenderQueryDithers (ClientPtr client)
+ProcRenderQueryDithers(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-ProcRenderCreatePicture (ClientPtr client)
+ProcRenderCreatePicture(ClientPtr client)
 {
-    PicturePtr	    pPicture;
-    DrawablePtr	    pDrawable;
-    PictFormatPtr   pFormat;
-    int		    len, error, rc;
+    PicturePtr pPicture;
+    DrawablePtr pDrawable;
+    PictFormatPtr pFormat;
+    int len, error, rc;
+
     REQUEST(xRenderCreatePictureReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq);
 
     LEGAL_NEW_RESOURCE(stuff->pid, client);
     rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
-			   DixReadAccess|DixAddAccess);
+                           DixReadAccess | DixAddAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    rc = dixLookupResourceByType((pointer *)&pFormat, stuff->format,
-				 PictFormatType, client, DixReadAccess);
+    rc = dixLookupResourceByType((pointer *) &pFormat, stuff->format,
+                                 PictFormatType, client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     if (pFormat->depth != pDrawable->depth)
-	return BadMatch;
+        return BadMatch;
     len = client->req_len - bytes_to_int32(sizeof(xRenderCreatePictureReq));
     if (Ones(stuff->mask) != len)
-	return BadLength;
-    
-    pPicture = CreatePicture (stuff->pid,
-			      pDrawable,
-			      pFormat,
-			      stuff->mask,
-			      (XID *) (stuff + 1),
-			      client,
-			      &error);
+        return BadLength;
+
+    pPicture = CreatePicture(stuff->pid,
+                             pDrawable,
+                             pFormat,
+                             stuff->mask, (XID *) (stuff + 1), client, &error);
     if (!pPicture)
-	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
-	return BadAlloc;
+        return error;
+    if (!AddResource(stuff->pid, PictureType, (pointer) pPicture))
+        return BadAlloc;
     return Success;
 }
 
 static int
-ProcRenderChangePicture (ClientPtr client)
+ProcRenderChangePicture(ClientPtr client)
 {
-    PicturePtr	    pPicture;
+    PicturePtr pPicture;
+
     REQUEST(xRenderChangePictureReq);
     int len;
 
     REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, DixSetAttrAccess);
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess);
 
     len = client->req_len - bytes_to_int32(sizeof(xRenderChangePictureReq));
     if (Ones(stuff->mask) != len)
-	return BadLength;
-    
-    return ChangePicture (pPicture, stuff->mask, (XID *) (stuff + 1),
-			  (DevUnion *) 0, client);
+        return BadLength;
+
+    return ChangePicture(pPicture, stuff->mask, (XID *) (stuff + 1),
+                         (DevUnion *) 0, client);
 }
 
 static int
-ProcRenderSetPictureClipRectangles (ClientPtr client)
+ProcRenderSetPictureClipRectangles(ClientPtr client)
 {
     REQUEST(xRenderSetPictureClipRectanglesReq);
-    PicturePtr	    pPicture;
-    int		    nr;
+    PicturePtr pPicture;
+    int nr;
 
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, DixSetAttrAccess);
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess);
     if (!pPicture->pDrawable)
         return BadDrawable;
 
     nr = (client->req_len << 2) - sizeof(xRenderSetPictureClipRectanglesReq);
     if (nr & 4)
-	return BadLength;
+        return BadLength;
     nr >>= 3;
-    return SetPictureClipRects (pPicture,
-				  stuff->xOrigin, stuff->yOrigin,
-				  nr, (xRectangle *) &stuff[1]);
+    return SetPictureClipRects(pPicture,
+                               stuff->xOrigin, stuff->yOrigin,
+                               nr, (xRectangle *) &stuff[1]);
 }
 
 static int
-ProcRenderFreePicture (ClientPtr client)
+ProcRenderFreePicture(ClientPtr client)
 {
-    PicturePtr	pPicture;
+    PicturePtr pPicture;
+
     REQUEST(xRenderFreePictureReq);
 
     REQUEST_SIZE_MATCH(xRenderFreePictureReq);
 
-    VERIFY_PICTURE (pPicture, stuff->picture, client, DixDestroyAccess);
-    FreeResource (stuff->picture, RT_NONE);
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixDestroyAccess);
+    FreeResource(stuff->picture, RT_NONE);
     return Success;
 }
 
 static Bool
-PictOpValid (CARD8 op)
+PictOpValid(CARD8 op)
 {
-    if (/*PictOpMinimum <= op && */ op <= PictOpMaximum)
-	return TRUE;
+    if ( /*PictOpMinimum <= op && */ op <= PictOpMaximum)
+        return TRUE;
     if (PictOpDisjointMinimum <= op && op <= PictOpDisjointMaximum)
-	return TRUE;
+        return TRUE;
     if (PictOpConjointMinimum <= op && op <= PictOpConjointMaximum)
-	return TRUE;
+        return TRUE;
     if (PictOpBlendMinimum <= op && op <= PictOpBlendMaximum)
-	return TRUE;
+        return TRUE;
     return FALSE;
 }
 
 static int
-ProcRenderComposite (ClientPtr client)
+ProcRenderComposite(ClientPtr client)
 {
-    PicturePtr	pSrc, pMask, pDst;
+    PicturePtr pSrc, pMask, pDst;
+
     REQUEST(xRenderCompositeReq);
 
     REQUEST_SIZE_MATCH(xRenderCompositeReq);
-    if (!PictOpValid (stuff->op))
-    {
-	client->errorValue = stuff->op;
-	return BadValue;
+    if (!PictOpValid(stuff->op)) {
+        client->errorValue = stuff->op;
+        return BadValue;
     }
-    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess);
+    VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
     if (!pDst->pDrawable)
         return BadDrawable;
-    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess);
-    VERIFY_ALPHA (pMask, stuff->mask, client, DixReadAccess);
-    if ((pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) ||
-	(pMask && pMask->pDrawable && pDst->pDrawable->pScreen != pMask->pDrawable->pScreen))
-	return BadMatch;
-    CompositePicture (stuff->op,
-		      pSrc,
-		      pMask,
-		      pDst,
-		      stuff->xSrc,
-		      stuff->ySrc,
-		      stuff->xMask,
-		      stuff->yMask,
-		      stuff->xDst,
-		      stuff->yDst,
-		      stuff->width,
-		      stuff->height);
+    VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
+    VERIFY_ALPHA(pMask, stuff->mask, client, DixReadAccess);
+    if ((pSrc->pDrawable &&
+         pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) || (pMask &&
+                                                                   pMask->
+                                                                   pDrawable &&
+                                                                   pDst->
+                                                                   pDrawable->
+                                                                   pScreen !=
+                                                                   pMask->
+                                                                   pDrawable->
+                                                                   pScreen))
+        return BadMatch;
+    CompositePicture(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)
+ProcRenderScale(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-ProcRenderTrapezoids (ClientPtr client)
+ProcRenderTrapezoids(ClientPtr client)
 {
-    int		rc, ntraps;
-    PicturePtr	pSrc, pDst;
-    PictFormatPtr   pFormat;
+    int rc, ntraps;
+    PicturePtr pSrc, pDst;
+    PictFormatPtr pFormat;
+
     REQUEST(xRenderTrapezoidsReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq);
-    if (!PictOpValid (stuff->op))
-    {
-	client->errorValue = stuff->op;
-	return BadValue;
+    if (!PictOpValid(stuff->op)) {
+        client->errorValue = stuff->op;
+        return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess);
-    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess);
+    VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
+    VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
     if (!pDst->pDrawable)
         return BadDrawable;
     if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen)
-	return BadMatch;
-    if (stuff->maskFormat)
-    {
-	rc = dixLookupResourceByType((pointer *)&pFormat, stuff->maskFormat,
-				     PictFormatType, client, DixReadAccess);
-	if (rc != Success)
-	    return rc;
+        return BadMatch;
+    if (stuff->maskFormat) {
+        rc = dixLookupResourceByType((pointer *) &pFormat, stuff->maskFormat,
+                                     PictFormatType, client, DixReadAccess);
+        if (rc != Success)
+            return rc;
     }
     else
-	pFormat = 0;
-    ntraps = (client->req_len << 2) - sizeof (xRenderTrapezoidsReq);
-    if (ntraps % sizeof (xTrapezoid))
-	return BadLength;
-    ntraps /= sizeof (xTrapezoid);
+        pFormat = 0;
+    ntraps = (client->req_len << 2) - sizeof(xRenderTrapezoidsReq);
+    if (ntraps % sizeof(xTrapezoid))
+        return BadLength;
+    ntraps /= sizeof(xTrapezoid);
     if (ntraps)
-	CompositeTrapezoids (stuff->op, pSrc, pDst, pFormat,
-			     stuff->xSrc, stuff->ySrc,
-			     ntraps, (xTrapezoid *) &stuff[1]);
+        CompositeTrapezoids(stuff->op, pSrc, pDst, pFormat,
+                            stuff->xSrc, stuff->ySrc,
+                            ntraps, (xTrapezoid *) & stuff[1]);
     return Success;
 }
 
 static int
-ProcRenderTriangles (ClientPtr client)
+ProcRenderTriangles(ClientPtr client)
 {
-    int		rc, ntris;
-    PicturePtr	pSrc, pDst;
-    PictFormatPtr   pFormat;
+    int rc, ntris;
+    PicturePtr pSrc, pDst;
+    PictFormatPtr pFormat;
+
     REQUEST(xRenderTrianglesReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq);
-    if (!PictOpValid (stuff->op))
-    {
-	client->errorValue = stuff->op;
-	return BadValue;
+    if (!PictOpValid(stuff->op)) {
+        client->errorValue = stuff->op;
+        return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess);
-    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess);
+    VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
+    VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
     if (!pDst->pDrawable)
         return BadDrawable;
     if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen)
-	return BadMatch;
-    if (stuff->maskFormat)
-    {
-	rc = dixLookupResourceByType((pointer *)&pFormat, stuff->maskFormat,
-				     PictFormatType, client, DixReadAccess);
-	if (rc != Success)
-	    return rc;
+        return BadMatch;
+    if (stuff->maskFormat) {
+        rc = dixLookupResourceByType((pointer *) &pFormat, stuff->maskFormat,
+                                     PictFormatType, client, DixReadAccess);
+        if (rc != Success)
+            return rc;
     }
     else
-	pFormat = 0;
-    ntris = (client->req_len << 2) - sizeof (xRenderTrianglesReq);
-    if (ntris % sizeof (xTriangle))
-	return BadLength;
-    ntris /= sizeof (xTriangle);
+        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]);
+        CompositeTriangles(stuff->op, pSrc, pDst, pFormat,
+                           stuff->xSrc, stuff->ySrc,
+                           ntris, (xTriangle *) & stuff[1]);
     return Success;
 }
 
 static int
-ProcRenderTriStrip (ClientPtr client)
+ProcRenderTriStrip(ClientPtr client)
 {
-    int		rc, npoints;
-    PicturePtr	pSrc, pDst;
-    PictFormatPtr   pFormat;
+    int rc, npoints;
+    PicturePtr pSrc, pDst;
+    PictFormatPtr pFormat;
+
     REQUEST(xRenderTrianglesReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq);
-    if (!PictOpValid (stuff->op))
-    {
-	client->errorValue = stuff->op;
-	return BadValue;
+    if (!PictOpValid(stuff->op)) {
+        client->errorValue = stuff->op;
+        return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess);
-    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess);
+    VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
+    VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
     if (!pDst->pDrawable)
         return BadDrawable;
     if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen)
-	return BadMatch;
-    if (stuff->maskFormat)
-    {
-	rc = dixLookupResourceByType((pointer *)&pFormat, stuff->maskFormat,
-				     PictFormatType, client, DixReadAccess);
-	if (rc != Success)
-	    return rc;
+        return BadMatch;
+    if (stuff->maskFormat) {
+        rc = dixLookupResourceByType((pointer *) &pFormat, stuff->maskFormat,
+                                     PictFormatType, client, DixReadAccess);
+        if (rc != Success)
+            return rc;
     }
     else
-	pFormat = 0;
-    npoints = ((client->req_len << 2) - sizeof (xRenderTriStripReq));
+        pFormat = 0;
+    npoints = ((client->req_len << 2) - sizeof(xRenderTriStripReq));
     if (npoints & 4)
-	return BadLength;
+        return BadLength;
     npoints >>= 3;
     if (npoints >= 3)
-	CompositeTriStrip (stuff->op, pSrc, pDst, pFormat,
-			   stuff->xSrc, stuff->ySrc,
-			   npoints, (xPointFixed *) &stuff[1]);
+        CompositeTriStrip(stuff->op, pSrc, pDst, pFormat,
+                          stuff->xSrc, stuff->ySrc,
+                          npoints, (xPointFixed *) & stuff[1]);
     return Success;
 }
 
 static int
-ProcRenderTriFan (ClientPtr client)
+ProcRenderTriFan(ClientPtr client)
 {
-    int		rc, npoints;
-    PicturePtr	pSrc, pDst;
-    PictFormatPtr   pFormat;
+    int rc, npoints;
+    PicturePtr pSrc, pDst;
+    PictFormatPtr pFormat;
+
     REQUEST(xRenderTrianglesReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq);
-    if (!PictOpValid (stuff->op))
-    {
-	client->errorValue = stuff->op;
-	return BadValue;
+    if (!PictOpValid(stuff->op)) {
+        client->errorValue = stuff->op;
+        return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess);
-    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess);
+    VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
+    VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
     if (!pDst->pDrawable)
         return BadDrawable;
     if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen)
-	return BadMatch;
-    if (stuff->maskFormat)
-    {
-	rc = dixLookupResourceByType((pointer *)&pFormat, stuff->maskFormat,
-				     PictFormatType, client, DixReadAccess);
-	if (rc != Success)
-	    return rc;
+        return BadMatch;
+    if (stuff->maskFormat) {
+        rc = dixLookupResourceByType((pointer *) &pFormat, stuff->maskFormat,
+                                     PictFormatType, client, DixReadAccess);
+        if (rc != Success)
+            return rc;
     }
     else
-	pFormat = 0;
-    npoints = ((client->req_len << 2) - sizeof (xRenderTriStripReq));
+        pFormat = 0;
+    npoints = ((client->req_len << 2) - sizeof(xRenderTriStripReq));
     if (npoints & 4)
-	return BadLength;
+        return BadLength;
     npoints >>= 3;
     if (npoints >= 3)
-	CompositeTriFan (stuff->op, pSrc, pDst, pFormat,
-			 stuff->xSrc, stuff->ySrc,
-			 npoints, (xPointFixed *) &stuff[1]);
+        CompositeTriFan(stuff->op, pSrc, pDst, pFormat,
+                        stuff->xSrc, stuff->ySrc,
+                        npoints, (xPointFixed *) & stuff[1]);
     return Success;
 }
 
 static int
-ProcRenderColorTrapezoids (ClientPtr client)
+ProcRenderColorTrapezoids(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-ProcRenderColorTriangles (ClientPtr client)
+ProcRenderColorTriangles(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-ProcRenderTransform (ClientPtr client)
+ProcRenderTransform(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-ProcRenderCreateGlyphSet (ClientPtr client)
+ProcRenderCreateGlyphSet(ClientPtr client)
 {
-    GlyphSetPtr	    glyphSet;
-    PictFormatPtr   format;
-    int		    rc, f;
+    GlyphSetPtr glyphSet;
+    PictFormatPtr format;
+    int rc, f;
+
     REQUEST(xRenderCreateGlyphSetReq);
 
     REQUEST_SIZE_MATCH(xRenderCreateGlyphSetReq);
 
     LEGAL_NEW_RESOURCE(stuff->gsid, client);
-    rc = dixLookupResourceByType((pointer *)&format, stuff->format,
-				 PictFormatType, client, DixReadAccess);
+    rc = dixLookupResourceByType((pointer *) &format, stuff->format,
+                                 PictFormatType, client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     switch (format->depth) {
     case 1:
-	f = GlyphFormat1;
-	break;
+        f = GlyphFormat1;
+        break;
     case 4:
-	f = GlyphFormat4;
-	break;
+        f = GlyphFormat4;
+        break;
     case 8:
-	f = GlyphFormat8;
-	break;
+        f = GlyphFormat8;
+        break;
     case 16:
-	f = GlyphFormat16;
-	break;
+        f = GlyphFormat16;
+        break;
     case 32:
-	f = GlyphFormat32;
-	break;
+        f = GlyphFormat32;
+        break;
     default:
-	return BadMatch;
+        return BadMatch;
     }
     if (format->type != PictTypeDirect)
-	return BadMatch;
-    glyphSet = AllocateGlyphSet (f, format);
+        return BadMatch;
+    glyphSet = AllocateGlyphSet(f, format);
     if (!glyphSet)
-	return BadAlloc;
+        return BadAlloc;
     /* security creation/labeling check */
     rc = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->gsid, GlyphSetType,
-		  glyphSet, RT_NONE, NULL, DixCreateAccess);
+                  glyphSet, RT_NONE, NULL, DixCreateAccess);
     if (rc != Success)
-	return rc;
-    if (!AddResource (stuff->gsid, GlyphSetType, (pointer)glyphSet))
-	return BadAlloc;
+        return rc;
+    if (!AddResource(stuff->gsid, GlyphSetType, (pointer) glyphSet))
+        return BadAlloc;
     return Success;
 }
 
 static int
-ProcRenderReferenceGlyphSet (ClientPtr client)
+ProcRenderReferenceGlyphSet(ClientPtr client)
 {
-    GlyphSetPtr     glyphSet;
+    GlyphSetPtr glyphSet;
     int rc;
+
     REQUEST(xRenderReferenceGlyphSetReq);
 
     REQUEST_SIZE_MATCH(xRenderReferenceGlyphSetReq);
 
     LEGAL_NEW_RESOURCE(stuff->gsid, client);
 
-    rc = dixLookupResourceByType((pointer *)&glyphSet, stuff->existing, GlyphSetType,
-			   client, DixGetAttrAccess);
-    if (rc != Success)
-    {
-	client->errorValue = stuff->existing;
-	return rc;
+    rc = dixLookupResourceByType((pointer *) &glyphSet, stuff->existing,
+                                 GlyphSetType, client, DixGetAttrAccess);
+    if (rc != Success) {
+        client->errorValue = stuff->existing;
+        return rc;
     }
     glyphSet->refcnt++;
-    if (!AddResource (stuff->gsid, GlyphSetType, (pointer)glyphSet))
-	return BadAlloc;
+    if (!AddResource(stuff->gsid, GlyphSetType, (pointer) glyphSet))
+        return BadAlloc;
     return Success;
 }
 
@@ -996,616 +975,576 @@ ProcRenderReferenceGlyphSet (ClientPtr client)
 #define NLOCALGLYPH	256
 
 static int
-ProcRenderFreeGlyphSet (ClientPtr client)
+ProcRenderFreeGlyphSet(ClientPtr client)
 {
-    GlyphSetPtr     glyphSet;
+    GlyphSetPtr glyphSet;
     int rc;
+
     REQUEST(xRenderFreeGlyphSetReq);
 
     REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq);
-    rc = dixLookupResourceByType((pointer *)&glyphSet, stuff->glyphset, GlyphSetType,
-			   client, DixDestroyAccess);
-    if (rc != Success)
-    {
-	client->errorValue = stuff->glyphset;
-	return rc;
+    rc = dixLookupResourceByType((pointer *) &glyphSet, stuff->glyphset,
+                                 GlyphSetType, client, DixDestroyAccess);
+    if (rc != Success) {
+        client->errorValue = stuff->glyphset;
+        return rc;
     }
-    FreeResource (stuff->glyphset, RT_NONE);
+    FreeResource(stuff->glyphset, RT_NONE);
     return Success;
 }
 
 typedef struct _GlyphNew {
-    Glyph	    id;
-    GlyphPtr        glyph;
-    Bool	    found;
-    unsigned char   sha1[20];
+    Glyph id;
+    GlyphPtr glyph;
+    Bool found;
+    unsigned char sha1[20];
 } GlyphNewRec, *GlyphNewPtr;
 
 #define NeedsComponent(f) (PICT_FORMAT_A(f) != 0 && PICT_FORMAT_RGB(f) != 0)
 
 static int
-ProcRenderAddGlyphs (ClientPtr client)
+ProcRenderAddGlyphs(ClientPtr client)
 {
-    GlyphSetPtr     glyphSet;
+    GlyphSetPtr glyphSet;
+
     REQUEST(xRenderAddGlyphsReq);
-    GlyphNewRec	    glyphsLocal[NLOCALGLYPH];
-    GlyphNewPtr	    glyphsBase, glyphs, glyph_new;
-    int		    remain, nglyphs;
-    CARD32	    *gids;
-    xGlyphInfo	    *gi;
-    CARD8	    *bits;
-    unsigned int    size;
-    int		    err;
-    int		    i, screen;
-    PicturePtr	    pSrc = NULL, pDst = NULL;
-    PixmapPtr	    pSrcPix = NULL, pDstPix = NULL;
-    CARD32	    component_alpha;
+    GlyphNewRec glyphsLocal[NLOCALGLYPH];
+    GlyphNewPtr glyphsBase, glyphs, glyph_new;
+    int remain, nglyphs;
+    CARD32 *gids;
+    xGlyphInfo *gi;
+    CARD8 *bits;
+    unsigned int size;
+    int err;
+    int i, screen;
+    PicturePtr pSrc = NULL, pDst = NULL;
+    PixmapPtr pSrcPix = NULL, pDstPix = NULL;
+    CARD32 component_alpha;
 
     REQUEST_AT_LEAST_SIZE(xRenderAddGlyphsReq);
-    err = dixLookupResourceByType((pointer *)&glyphSet, stuff->glyphset, GlyphSetType,
-			    client, DixAddAccess);
-    if (err != Success)
-    {
-	client->errorValue = stuff->glyphset;
-	return err;
+    err =
+        dixLookupResourceByType((pointer *) &glyphSet, stuff->glyphset,
+                                GlyphSetType, client, DixAddAccess);
+    if (err != Success) {
+        client->errorValue = stuff->glyphset;
+        return err;
     }
 
     err = BadAlloc;
     nglyphs = stuff->nglyphs;
     if (nglyphs > UINT32_MAX / sizeof(GlyphNewRec))
-	    return BadAlloc;
+        return BadAlloc;
 
-    component_alpha = NeedsComponent (glyphSet->format->format);
+    component_alpha = NeedsComponent(glyphSet->format->format);
 
     if (nglyphs <= NLOCALGLYPH) {
-	memset (glyphsLocal, 0, sizeof (glyphsLocal));
-	glyphsBase = glyphsLocal;
+        memset(glyphsLocal, 0, sizeof(glyphsLocal));
+        glyphsBase = glyphsLocal;
     }
-    else
-    {
-	glyphsBase = (GlyphNewPtr)calloc(nglyphs, sizeof (GlyphNewRec));
-	if (!glyphsBase)
-	    return BadAlloc;
+    else {
+        glyphsBase = (GlyphNewPtr) calloc(nglyphs, sizeof(GlyphNewRec));
+        if (!glyphsBase)
+            return BadAlloc;
     }
 
-    remain = (client->req_len << 2) - sizeof (xRenderAddGlyphsReq);
+    remain = (client->req_len << 2) - sizeof(xRenderAddGlyphsReq);
 
     glyphs = glyphsBase;
 
     gids = (CARD32 *) (stuff + 1);
     gi = (xGlyphInfo *) (gids + nglyphs);
     bits = (CARD8 *) (gi + nglyphs);
-    remain -= (sizeof (CARD32) + sizeof (xGlyphInfo)) * nglyphs;
+    remain -= (sizeof(CARD32) + sizeof(xGlyphInfo)) * nglyphs;
 
     /* protect against bad nglyphs */
-    if (gi < ((xGlyphInfo *)stuff) ||
-        gi > ((xGlyphInfo *)((CARD32 *)stuff + client->req_len)) ||
-        bits < ((CARD8 *)stuff) ||
-        bits > ((CARD8 *)((CARD32 *)stuff + client->req_len))) {
+    if (gi < ((xGlyphInfo *) stuff) ||
+        gi > ((xGlyphInfo *) ((CARD32 *) stuff + client->req_len)) ||
+        bits < ((CARD8 *) stuff) ||
+        bits > ((CARD8 *) ((CARD32 *) stuff + client->req_len))) {
         err = BadLength;
         goto bail;
     }
 
-    for (i = 0; i < nglyphs; i++)
-    {
-	size_t padded_width;
-	glyph_new = &glyphs[i];
-
-	padded_width = PixmapBytePad (gi[i].width,
-				      glyphSet->format->depth);
-
-	if (gi[i].height && padded_width > (UINT32_MAX - sizeof(GlyphRec))/gi[i].height)
-	    break;
-	
-	size = gi[i].height * padded_width;
-	if (remain < size)
-	    break;
-
-	err = HashGlyph (&gi[i], bits, size, glyph_new->sha1);
-	if (err)
-	    goto bail;
-
-	glyph_new->glyph = FindGlyphByHash (glyph_new->sha1,
-					    glyphSet->fdepth);
-
-	if (glyph_new->glyph && glyph_new->glyph != DeletedGlyph)
-	{
-	    glyph_new->found = TRUE;
-	}
-	else
-	{
-	    GlyphPtr glyph;
-
-	    glyph_new->found = FALSE;
-	    glyph_new->glyph = glyph = AllocateGlyph (&gi[i], glyphSet->fdepth);
-	    if (! glyph)
-	    {
-		err = BadAlloc;
-		goto bail;
-	    }
-
-	    for (screen = 0; screen < screenInfo.numScreens; screen++)
-	    {
-		int	    width = gi[i].width;
-		int	    height = gi[i].height;
-		int	    depth = glyphSet->format->depth;
-		ScreenPtr   pScreen;
-		int	    error;
-
-		/* Skip work if it's invisibly small anyway */
-		if (!width || !height)
-		    break;
-
-		pScreen = screenInfo.screens[screen];
-		pSrcPix = GetScratchPixmapHeader (pScreen,
-						  width, height,
-						  depth, depth,
-						  -1, bits);
-		if (! pSrcPix)
-		{
-		    err = BadAlloc;
-		    goto bail;
-		}
-
-		pSrc = CreatePicture (0, &pSrcPix->drawable,
-				      glyphSet->format, 0, NULL,
-				      serverClient, &error);
-		if (! pSrc)
-		{
-		    err = BadAlloc;
-		    goto bail;
-		}
-
-		pDstPix = (pScreen->CreatePixmap) (pScreen,
-						   width, height, depth,
-						   CREATE_PIXMAP_USAGE_GLYPH_PICTURE);
-
-		if (!pDstPix)
-		{
-		    err = BadAlloc;
-		    goto bail;
-		}
-
-		GlyphPicture (glyph)[screen] = pDst =
-			CreatePicture (0, &pDstPix->drawable,
-				       glyphSet->format,
-				       CPComponentAlpha, &component_alpha,
-				       serverClient, &error);
-
-		/* The picture takes a reference to the pixmap, so we
-		   drop ours. */
-		(pScreen->DestroyPixmap) (pDstPix);
-		pDstPix = NULL;
-
-		if (! pDst)
-		{
-		    err = BadAlloc;
-		    goto bail;
-		}
-
-		CompositePicture (PictOpSrc,
-				  pSrc,
-				  None,
-				  pDst,
-				  0, 0,
-				  0, 0,
-				  0, 0,
-				  width, height);
-
-		FreePicture ((pointer) pSrc, 0);
-		pSrc = NULL;
-		FreeScratchPixmapHeader (pSrcPix);
-		pSrcPix = NULL;
-	    }
-
-	    memcpy (glyph_new->glyph->sha1, glyph_new->sha1, 20);
-	}
-
-	glyph_new->id = gids[i];
-	
-	if (size & 3)
-	    size += 4 - (size & 3);
-	bits += size;
-	remain -= size;
-    }
-    if (remain || i < nglyphs)
-    {
-	err = BadLength;
-	goto bail;
-    }
-    if (!ResizeGlyphSet (glyphSet, nglyphs))
-    {
-	err = BadAlloc;
-	goto bail;
+    for (i = 0; i < nglyphs; i++) {
+        size_t padded_width;
+
+        glyph_new = &glyphs[i];
+
+        padded_width = PixmapBytePad(gi[i].width, glyphSet->format->depth);
+
+        if (gi[i].height &&
+            padded_width > (UINT32_MAX - sizeof(GlyphRec)) / gi[i].height)
+            break;
+
+        size = gi[i].height * padded_width;
+        if (remain < size)
+            break;
+
+        err = HashGlyph(&gi[i], bits, size, glyph_new->sha1);
+        if (err)
+            goto bail;
+
+        glyph_new->glyph = FindGlyphByHash(glyph_new->sha1, glyphSet->fdepth);
+
+        if (glyph_new->glyph && glyph_new->glyph != DeletedGlyph) {
+            glyph_new->found = TRUE;
+        }
+        else {
+            GlyphPtr glyph;
+
+            glyph_new->found = FALSE;
+            glyph_new->glyph = glyph = AllocateGlyph(&gi[i], glyphSet->fdepth);
+            if (!glyph) {
+                err = BadAlloc;
+                goto bail;
+            }
+
+            for (screen = 0; screen < screenInfo.numScreens; screen++) {
+                int width = gi[i].width;
+                int height = gi[i].height;
+                int depth = glyphSet->format->depth;
+                ScreenPtr pScreen;
+                int error;
+
+                /* Skip work if it's invisibly small anyway */
+                if (!width || !height)
+                    break;
+
+                pScreen = screenInfo.screens[screen];
+                pSrcPix = GetScratchPixmapHeader(pScreen,
+                                                 width, height,
+                                                 depth, depth, -1, bits);
+                if (!pSrcPix) {
+                    err = BadAlloc;
+                    goto bail;
+                }
+
+                pSrc = CreatePicture(0, &pSrcPix->drawable,
+                                     glyphSet->format, 0, NULL,
+                                     serverClient, &error);
+                if (!pSrc) {
+                    err = BadAlloc;
+                    goto bail;
+                }
+
+                pDstPix = (pScreen->CreatePixmap) (pScreen,
+                                                   width, height, depth,
+                                                   CREATE_PIXMAP_USAGE_GLYPH_PICTURE);
+
+                if (!pDstPix) {
+                    err = BadAlloc;
+                    goto bail;
+                }
+
+                GlyphPicture(glyph)[screen] = pDst =
+                    CreatePicture(0, &pDstPix->drawable,
+                                  glyphSet->format,
+                                  CPComponentAlpha, &component_alpha,
+                                  serverClient, &error);
+
+                /* The picture takes a reference to the pixmap, so we
+                   drop ours. */
+                (pScreen->DestroyPixmap) (pDstPix);
+                pDstPix = NULL;
+
+                if (!pDst) {
+                    err = BadAlloc;
+                    goto bail;
+                }
+
+                CompositePicture(PictOpSrc,
+                                 pSrc,
+                                 None, pDst, 0, 0, 0, 0, 0, 0, width, height);
+
+                FreePicture((pointer) pSrc, 0);
+                pSrc = NULL;
+                FreeScratchPixmapHeader(pSrcPix);
+                pSrcPix = NULL;
+            }
+
+            memcpy(glyph_new->glyph->sha1, glyph_new->sha1, 20);
+        }
+
+        glyph_new->id = gids[i];
+
+        if (size & 3)
+            size += 4 - (size & 3);
+        bits += size;
+        remain -= size;
+    }
+    if (remain || i < nglyphs) {
+        err = BadLength;
+        goto bail;
+    }
+    if (!ResizeGlyphSet(glyphSet, nglyphs)) {
+        err = BadAlloc;
+        goto bail;
     }
     for (i = 0; i < nglyphs; i++)
-	AddGlyph (glyphSet, glyphs[i].glyph, glyphs[i].id);
+        AddGlyph(glyphSet, glyphs[i].glyph, glyphs[i].id);
 
     if (glyphsBase != glyphsLocal)
-	free(glyphsBase);
+        free(glyphsBase);
     return Success;
-bail:
+ bail:
     if (pSrc)
-	FreePicture ((pointer) pSrc, 0);
+        FreePicture((pointer) pSrc, 0);
     if (pSrcPix)
-	FreeScratchPixmapHeader (pSrcPix);
+        FreeScratchPixmapHeader(pSrcPix);
     for (i = 0; i < nglyphs; i++)
-	if (glyphs[i].glyph && ! glyphs[i].found)
-	    free(glyphs[i].glyph);
+        if (glyphs[i].glyph && !glyphs[i].found)
+            free(glyphs[i].glyph);
     if (glyphsBase != glyphsLocal)
-	free(glyphsBase);
+        free(glyphsBase);
     return err;
 }
 
 static int
-ProcRenderAddGlyphsFromPicture (ClientPtr client)
+ProcRenderAddGlyphsFromPicture(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-ProcRenderFreeGlyphs (ClientPtr client)
+ProcRenderFreeGlyphs(ClientPtr client)
 {
     REQUEST(xRenderFreeGlyphsReq);
-    GlyphSetPtr     glyphSet;
-    int		    rc, nglyph;
-    CARD32	    *gids;
-    CARD32	    glyph;
+    GlyphSetPtr glyphSet;
+    int rc, nglyph;
+    CARD32 *gids;
+    CARD32 glyph;
 
     REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq);
-    rc = dixLookupResourceByType((pointer *)&glyphSet, stuff->glyphset, GlyphSetType,
-			   client, DixRemoveAccess);
-    if (rc != Success)
-    {
-	client->errorValue = stuff->glyphset;
-	return rc;
-    }
-    nglyph = bytes_to_int32((client->req_len << 2) - sizeof (xRenderFreeGlyphsReq));
+    rc = dixLookupResourceByType((pointer *) &glyphSet, stuff->glyphset,
+                                 GlyphSetType, client, DixRemoveAccess);
+    if (rc != Success) {
+        client->errorValue = stuff->glyphset;
+        return rc;
+    }
+    nglyph =
+        bytes_to_int32((client->req_len << 2) - sizeof(xRenderFreeGlyphsReq));
     gids = (CARD32 *) (stuff + 1);
-    while (nglyph-- > 0)
-    {
-	glyph = *gids++;
-	if (!DeleteGlyph (glyphSet, glyph))
-	{
-	    client->errorValue = glyph;
-	    return RenderErrBase + BadGlyph;
-	}
+    while (nglyph-- > 0) {
+        glyph = *gids++;
+        if (!DeleteGlyph(glyphSet, glyph)) {
+            client->errorValue = glyph;
+            return RenderErrBase + BadGlyph;
+        }
     }
     return Success;
 }
 
 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		    rc, n;
-    
+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 rc, n;
+
     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, DixReadAccess);
-    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess);
+    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, DixReadAccess);
+    VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
     if (!pDst->pDrawable)
         return BadDrawable;
     if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen)
-	return BadMatch;
-    if (stuff->maskFormat)
-    {
-	rc = dixLookupResourceByType((pointer *)&pFormat, stuff->maskFormat,
-				     PictFormatType, client, DixReadAccess);
-	if (rc != Success)
-	    return rc;
+        return BadMatch;
+    if (stuff->maskFormat) {
+        rc = dixLookupResourceByType((pointer *) &pFormat, stuff->maskFormat,
+                                     PictFormatType, client, DixReadAccess);
+        if (rc != Success)
+            return rc;
     }
     else
-	pFormat = 0;
+        pFormat = 0;
 
-    rc = dixLookupResourceByType((pointer *)&glyphSet, stuff->glyphset,
-				 GlyphSetType, client, DixUseAccess);
+    rc = dixLookupResourceByType((pointer *) &glyphSet, stuff->glyphset,
+                                 GlyphSetType, client, DixUseAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     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;
-	}
+    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 *) malloc(nglyph * sizeof (GlyphPtr));
-	if (!glyphsBase)
-	    return BadAlloc;
+        glyphsBase = glyphsLocal;
+    else {
+        glyphsBase = (GlyphPtr *) malloc(nglyph * sizeof(GlyphPtr));
+        if (!glyphsBase)
+            return BadAlloc;
     }
     if (nlist <= NLOCALDELTA)
-	listsBase = listsLocal;
-    else
-    {
-	listsBase = (GlyphListPtr) malloc(nlist * sizeof (GlyphListRec));
-	if (!listsBase) {
-	    rc = BadAlloc;
-	    goto bail;
-	}
+        listsBase = listsLocal;
+    else {
+        listsBase = (GlyphListPtr) malloc(nlist * sizeof(GlyphListRec));
+        if (!listsBase) {
+            rc = BadAlloc;
+            goto bail;
+        }
     }
     buffer = (CARD8 *) (stuff + 1);
     glyphs = glyphsBase;
     lists = listsBase;
-    while (buffer + sizeof (xGlyphElt) < end)
-    {
-	elt = (xGlyphElt *) buffer;
-	buffer += sizeof (xGlyphElt);
-	
-	if (elt->len == 0xff)
-	{
-	    if (buffer + sizeof (GlyphSet) < end)
-	    {
+    while (buffer + sizeof(xGlyphElt) < end) {
+        elt = (xGlyphElt *) buffer;
+        buffer += sizeof(xGlyphElt);
+
+        if (elt->len == 0xff) {
+            if (buffer + sizeof(GlyphSet) < end) {
                 memcpy(&gs, buffer, sizeof(GlyphSet));
-		rc = dixLookupResourceByType((pointer *)&glyphSet, gs,
-					     GlyphSetType, client,
-					     DixUseAccess);
-		if (rc != Success)
-		    goto bail;
-	    }
-	    buffer += 4;
-	}
-	else
-	{
-	    lists->xOff = elt->deltax;
-	    lists->yOff = elt->deltay;
-	    lists->format = glyphSet->format;
-	    lists->len = 0;
-	    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++;
-	}
+                rc = dixLookupResourceByType((pointer *) &glyphSet, gs,
+                                             GlyphSetType, client,
+                                             DixUseAccess);
+                if (rc != Success)
+                    goto bail;
+            }
+            buffer += 4;
+        }
+        else {
+            lists->xOff = elt->deltax;
+            lists->yOff = elt->deltay;
+            lists->format = glyphSet->format;
+            lists->len = 0;
+            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++;
+        }
     }
     if (buffer > end) {
-	rc = BadLength;
-	goto bail;
-    }
-
-    CompositeGlyphs (stuff->op,
-		     pSrc,
-		     pDst,
-		     pFormat,
-		     stuff->xSrc,
-		     stuff->ySrc,
-		     nlist,
-		     listsBase,
-		     glyphsBase);
+        rc = BadLength;
+        goto bail;
+    }
+
+    CompositeGlyphs(stuff->op,
+                    pSrc,
+                    pDst,
+                    pFormat,
+                    stuff->xSrc, stuff->ySrc, nlist, listsBase, glyphsBase);
     rc = Success;
 
-bail:
+ bail:
     if (glyphsBase != glyphsLocal)
-	free(glyphsBase);
+        free(glyphsBase);
     if (listsBase != listsLocal)
-	free(listsBase);
+        free(listsBase);
     return rc;
 }
 
 static int
-ProcRenderFillRectangles (ClientPtr client)
+ProcRenderFillRectangles(ClientPtr client)
 {
-    PicturePtr	    pDst;
-    int             things;
+    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, DixWriteAccess);
+
+    REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq);
+    if (!PictOpValid(stuff->op)) {
+        client->errorValue = stuff->op;
+        return BadValue;
+    }
+    VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
     if (!pDst->pDrawable)
         return BadDrawable;
-    
+
     things = (client->req_len << 2) - sizeof(xRenderFillRectanglesReq);
     if (things & 4)
-	return BadLength;
+        return BadLength;
     things >>= 3;
-    
-    CompositeRects (stuff->op,
-		    pDst,
-		    &stuff->color,
-		    things,
-		    (xRectangle *) &stuff[1]);
-    
+
+    CompositeRects(stuff->op,
+                   pDst, &stuff->color, things, (xRectangle *) &stuff[1]);
+
     return Success;
 }
 
 static void
-RenderSetBit (unsigned char *line, int x, int bit)
+RenderSetBit(unsigned char *line, int x, int bit)
 {
-    unsigned char   mask;
-    
+    unsigned char mask;
+
     if (screenInfo.bitmapBitOrder == LSBFirst)
-	mask = (1 << (x & 7));
+        mask = (1 << (x & 7));
     else
-	mask = (0x80 >> (x & 7));
+        mask = (0x80 >> (x & 7));
     /* XXX assumes byte order is host byte order */
     line += (x >> 3);
     if (bit)
-	*line |= mask;
+        *line |= mask;
     else
-	*line &= ~mask;
+        *line &= ~mask;
 }
 
 #define DITHER_DIM 2
 
 static CARD32 orderedDither[DITHER_DIM][DITHER_DIM] = {
-    {  1,  3,  },
-    {  4,  2,  },
+    {1, 3,},
+    {4, 2,},
 };
 
 #define DITHER_SIZE  ((sizeof orderedDither / sizeof orderedDither[0][0]) + 1)
 
 static int
-ProcRenderCreateCursor (ClientPtr client)
+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;
+    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		    rc, ncolor;
+    CursorPtr pCursor;
+    CARD32 twocolor[3];
+    int rc, ncolor;
 
-    REQUEST_SIZE_MATCH (xRenderCreateCursorReq);
+    REQUEST_SIZE_MATCH(xRenderCreateCursorReq);
     LEGAL_NEW_RESOURCE(stuff->cid, client);
-    
-    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess);
+
+    VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
     if (!pSrc->pDrawable)
         return BadDrawable;
     pScreen = pSrc->pDrawable->pScreen;
     width = pSrc->pDrawable->width;
     height = pSrc->pDrawable->height;
-    if (height && width > UINT32_MAX/(height*sizeof(CARD32)))
-	return BadAlloc;
-    if ( stuff->x > width 
-      || stuff->y > height )
-	return BadMatch;
-    argbbits = malloc(width * height * sizeof (CARD32));
+    if (height && width > UINT32_MAX / (height * sizeof(CARD32)))
+        return BadAlloc;
+    if (stuff->x > width || stuff->y > height)
+        return BadMatch;
+    argbbits = malloc(width * height * sizeof(CARD32));
     if (!argbbits)
-	return BadAlloc;
-    
+        return BadAlloc;
+
     stride = BitmapBytePad(width);
-    nbytes_mono = stride*height;
+    nbytes_mono = stride * height;
     srcbits = calloc(1, nbytes_mono);
-    if (!srcbits)
-    {
-	free(argbbits);
-	return BadAlloc;
+    if (!srcbits) {
+        free(argbbits);
+        return BadAlloc;
     }
     mskbits = calloc(1, nbytes_mono);
-    if (!mskbits)
-    {
-	free(argbbits);
-	free(srcbits);
-	return BadAlloc;
-    }
-
-    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)
-	{
-	    free(argbbits);
-	    free(srcbits);
-	    free(mskbits);
-	    return BadImplementation;
-	}
-	pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 32,
-					    CREATE_PIXMAP_USAGE_SCRATCH);
-	if (!pPixmap)
-	{
-	    free(argbbits);
-	    free(srcbits);
-	    free(mskbits);
-	    return BadAlloc;
-	}
-	pPicture = CreatePicture (0, &pPixmap->drawable, pFormat, 0, 0, 
-				  client, &error);
-	if (!pPicture)
-	{
-	    free(argbbits);
-	    free(srcbits);
-	    free(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);
+    if (!mskbits) {
+        free(argbbits);
+        free(srcbits);
+        return BadAlloc;
+    }
+
+    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) {
+            free(argbbits);
+            free(srcbits);
+            free(mskbits);
+            return BadImplementation;
+        }
+        pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 32,
+                                            CREATE_PIXMAP_USAGE_SCRATCH);
+        if (!pPixmap) {
+            free(argbbits);
+            free(srcbits);
+            free(mskbits);
+            return BadAlloc;
+        }
+        pPicture = CreatePicture(0, &pPixmap->drawable, pFormat, 0, 0,
+                                 client, &error);
+        if (!pPicture) {
+            free(argbbits);
+            free(srcbits);
+            free(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 
@@ -1613,314 +1552,300 @@ ProcRenderCreateCursor (ClientPtr client)
      */
     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;
-	}
-    }
-    
+    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));
-
-		RenderSetBit (mskline, x, a != 0);
-		RenderSetBit (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 */
-		RenderSetBit(mskline, x, a > d);
-		/* Set src from dithered intensity value */
-		RenderSetBit(srcline, x, a > d && i <= d);
-	    }
-	}
-	srcline += stride;
-	mskline += stride;
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            CARD32 p = *argb++;
+
+            if (ncolor <= 2) {
+                CARD32 a = ((p >> 24));
+
+                RenderSetBit(mskline, x, a != 0);
+                RenderSetBit(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 */
+                RenderSetBit(mskline, x, a > d);
+                /* Set src from dithered intensity value */
+                RenderSetBit(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;
+    if (ncolor > 2) {
+        twocolor[0] = 0xff000000;
+        twocolor[1] = 0xffffffff;
     }
-    else
-    {
-	free(argbbits);
-	argbbits = 0;
+    else {
+        free(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;
     rc = AllocARGBCursor(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),
-			 &pCursor, client, stuff->cid);
+                         GetColor(twocolor[0], 16),
+                         GetColor(twocolor[0], 8),
+                         GetColor(twocolor[0], 0),
+                         GetColor(twocolor[1], 16),
+                         GetColor(twocolor[1], 8),
+                         GetColor(twocolor[1], 0),
+                         &pCursor, client, stuff->cid);
     if (rc != Success)
-	goto bail;
-    if (!AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor)) {
-	rc = BadAlloc;
-	goto bail;
+        goto bail;
+    if (!AddResource(stuff->cid, RT_CURSOR, (pointer) pCursor)) {
+        rc = BadAlloc;
+        goto bail;
     }
 
     return Success;
-bail:
+ bail:
     free(srcbits);
     free(mskbits);
     return rc;
 }
 
 static int
-ProcRenderSetPictureTransform (ClientPtr client)
+ProcRenderSetPictureTransform(ClientPtr client)
 {
     REQUEST(xRenderSetPictureTransformReq);
-    PicturePtr	pPicture;
+    PicturePtr pPicture;
 
     REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, DixSetAttrAccess);
-    return SetPictureTransform (pPicture, (PictTransform *) &stuff->transform);
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess);
+    return SetPictureTransform(pPicture, (PictTransform *) & stuff->transform);
 }
 
 static int
-ProcRenderQueryFilters (ClientPtr client)
+ProcRenderQueryFilters(ClientPtr client)
 {
-    REQUEST (xRenderQueryFiltersReq);
-    DrawablePtr			pDrawable;
-    xRenderQueryFiltersReply	*reply;
-    int				nbytesName;
-    int				nnames;
-    ScreenPtr			pScreen;
-    PictureScreenPtr		ps;
-    int				i, j, len, total_bytes, rc;
-    INT16			*aliases;
-    char			*names;
+    REQUEST(xRenderQueryFiltersReq);
+    DrawablePtr pDrawable;
+    xRenderQueryFiltersReply *reply;
+    int nbytesName;
+    int nnames;
+    ScreenPtr pScreen;
+    PictureScreenPtr ps;
+    int i, j, len, total_bytes, rc;
+    INT16 *aliases;
+    char *names;
 
     REQUEST_SIZE_MATCH(xRenderQueryFiltersReq);
     rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
-			   DixGetAttrAccess);
+                           DixGetAttrAccess);
     if (rc != Success)
-	return rc;
-    
+        return rc;
+
     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;
+    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) + bytes_to_int32(nbytesName);
-    total_bytes = sizeof (xRenderQueryFiltersReply) + (len << 2);
+    total_bytes = sizeof(xRenderQueryFiltersReply) + (len << 2);
     reply = (xRenderQueryFiltersReply *) malloc(total_bytes);
     if (!reply)
-	return BadAlloc;
+        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;
-	    memcpy (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;
-	    memcpy (names, ps->filterAliases[i].alias, j);
-	    names += j;
-	}
-    }
-
-    if (client->swapped)
-    {
-	for (i = 0; i < reply->numAliases; i++)
-	{
-	    swaps(&aliases[i]);
-	}
-	swaps(&reply->sequenceNumber);
-	swapl(&reply->length);
-	swapl(&reply->numAliases);
-	swapl(&reply->numFilters);
+    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;
+            memcpy(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;
+            memcpy(names, ps->filterAliases[i].alias, j);
+            names += j;
+        }
+    }
+
+    if (client->swapped) {
+        for (i = 0; i < reply->numAliases; i++) {
+            swaps(&aliases[i]);
+        }
+        swaps(&reply->sequenceNumber);
+        swapl(&reply->length);
+        swapl(&reply->numAliases);
+        swapl(&reply->numFilters);
     }
     WriteToClient(client, total_bytes, (char *) reply);
     free(reply);
-    
+
     return Success;
 }
 
 static int
-ProcRenderSetPictureFilter (ClientPtr client)
+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, DixSetAttrAccess);
+    REQUEST(xRenderSetPictureFilterReq);
+    PicturePtr pPicture;
+    int result;
+    xFixed *params;
+    int nparams;
+    char *name;
+
+    REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq);
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess);
     name = (char *) (stuff + 1);
     params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
     nparams = ((xFixed *) stuff + client->req_len) - params;
-    result = SetPictureFilter (pPicture, name, stuff->nbytes, params, nparams);
+    result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
     return result;
 }
 
 static int
-ProcRenderCreateAnimCursor (ClientPtr client)
+ProcRenderCreateAnimCursor(ClientPtr client)
 {
     REQUEST(xRenderCreateAnimCursorReq);
-    CursorPtr	    *cursors;
-    CARD32	    *deltas;
-    CursorPtr	    pCursor;
-    int		    ncursor;
-    xAnimCursorElt  *elt;
-    int		    i;
-    int		    ret;
+    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 - (bytes_to_int32(sizeof(xRenderCreateAnimCursorReq)))) >> 1;
-    cursors = malloc(ncursor * (sizeof (CursorPtr) + sizeof (CARD32)));
+        return BadLength;
+    ncursor =
+        (client->req_len -
+         (bytes_to_int32(sizeof(xRenderCreateAnimCursorReq)))) >> 1;
+    cursors = malloc(ncursor * (sizeof(CursorPtr) + sizeof(CARD32)));
     if (!cursors)
-	return BadAlloc;
+        return BadAlloc;
     deltas = (CARD32 *) (cursors + ncursor);
     elt = (xAnimCursorElt *) (stuff + 1);
-    for (i = 0; i < ncursor; i++)
-    {
-	ret = dixLookupResourceByType((pointer *)(cursors + i), elt->cursor,
-				      RT_CURSOR, client, DixReadAccess);
-	if (ret != Success)
-	{
-	    free(cursors);
-	    return ret;
-	}
-	deltas[i] = elt->delay;
-	elt++;
-    }
-    ret = AnimCursorCreate (cursors, deltas, ncursor, &pCursor, client,
-			    stuff->cid);
+    for (i = 0; i < ncursor; i++) {
+        ret = dixLookupResourceByType((pointer *) (cursors + i), elt->cursor,
+                                      RT_CURSOR, client, DixReadAccess);
+        if (ret != Success) {
+            free(cursors);
+            return ret;
+        }
+        deltas[i] = elt->delay;
+        elt++;
+    }
+    ret = AnimCursorCreate(cursors, deltas, ncursor, &pCursor, client,
+                           stuff->cid);
     free(cursors);
     if (ret != Success)
-	return ret;
-    
-    if (AddResource (stuff->cid, RT_CURSOR, (pointer)pCursor))
-	return Success;
+        return ret;
+
+    if (AddResource(stuff->cid, RT_CURSOR, (pointer) pCursor))
+        return Success;
     return BadAlloc;
 }
 
 static int
-ProcRenderAddTraps (ClientPtr client)
+ProcRenderAddTraps(ClientPtr client)
 {
-    int		ntraps;
-    PicturePtr	pPicture;
+    int ntraps;
+    PicturePtr pPicture;
+
     REQUEST(xRenderAddTrapsReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess);
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess);
     if (!pPicture->pDrawable)
         return BadDrawable;
-    ntraps = (client->req_len << 2) - sizeof (xRenderAddTrapsReq);
-    if (ntraps % sizeof (xTrap))
-	return BadLength;
-    ntraps /= sizeof (xTrap);
+    ntraps = (client->req_len << 2) - sizeof(xRenderAddTrapsReq);
+    if (ntraps % sizeof(xTrap))
+        return BadLength;
+    ntraps /= sizeof(xTrap);
     if (ntraps)
-	AddTraps (pPicture,
-		  stuff->xOff, stuff->yOff,
-		  ntraps, (xTrap *) &stuff[1]);
+        AddTraps(pPicture,
+                 stuff->xOff, stuff->yOff, ntraps, (xTrap *) & stuff[1]);
     return Success;
 }
 
-static int ProcRenderCreateSolidFill(ClientPtr client)
+static int
+ProcRenderCreateSolidFill(ClientPtr client)
 {
-    PicturePtr	    pPicture;
-    int		    error = 0;
+    PicturePtr pPicture;
+    int error = 0;
+
     REQUEST(xRenderCreateSolidFillReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq);
@@ -1929,24 +1854,26 @@ static int ProcRenderCreateSolidFill(ClientPtr client)
 
     pPicture = CreateSolidPicture(stuff->pid, &stuff->color, &error);
     if (!pPicture)
-	return error;
+        return error;
     /* security creation/labeling check */
     error = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, PictureType,
-		     pPicture, RT_NONE, NULL, DixCreateAccess);
+                     pPicture, RT_NONE, NULL, DixCreateAccess);
     if (error != Success)
-	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
-	return BadAlloc;
+        return error;
+    if (!AddResource(stuff->pid, PictureType, (pointer) pPicture))
+        return BadAlloc;
     return Success;
 }
 
-static int ProcRenderCreateLinearGradient (ClientPtr client)
+static int
+ProcRenderCreateLinearGradient(ClientPtr client)
 {
-    PicturePtr	    pPicture;
-    int		    len;
-    int		    error = 0;
-    xFixed          *stops;
-    xRenderColor   *colors;
+    PicturePtr pPicture;
+    int len;
+    int error = 0;
+    xFixed *stops;
+    xRenderColor *colors;
+
     REQUEST(xRenderCreateLinearGradientReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq);
@@ -1954,35 +1881,38 @@ static int ProcRenderCreateLinearGradient (ClientPtr client)
     LEGAL_NEW_RESOURCE(stuff->pid, client);
 
     len = (client->req_len << 2) - sizeof(xRenderCreateLinearGradientReq);
-    if (stuff->nStops > UINT32_MAX/(sizeof(xFixed) + sizeof(xRenderColor)))
-	return BadLength;
-    if (len != stuff->nStops*(sizeof(xFixed) + sizeof(xRenderColor)))
+    if (stuff->nStops > UINT32_MAX / (sizeof(xFixed) + sizeof(xRenderColor)))
+        return BadLength;
+    if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor)))
         return BadLength;
 
-    stops = (xFixed *)(stuff + 1);
-    colors = (xRenderColor *)(stops + stuff->nStops);
+    stops = (xFixed *) (stuff + 1);
+    colors = (xRenderColor *) (stops + stuff->nStops);
 
-    pPicture = CreateLinearGradientPicture (stuff->pid, &stuff->p1, &stuff->p2,
-                                            stuff->nStops, stops, colors, &error);
+    pPicture = CreateLinearGradientPicture(stuff->pid, &stuff->p1, &stuff->p2,
+                                           stuff->nStops, stops, colors,
+                                           &error);
     if (!pPicture)
-	return error;
+        return error;
     /* security creation/labeling check */
     error = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, PictureType,
-		     pPicture, RT_NONE, NULL, DixCreateAccess);
+                     pPicture, RT_NONE, NULL, DixCreateAccess);
     if (error != Success)
-	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
-	return BadAlloc;
+        return error;
+    if (!AddResource(stuff->pid, PictureType, (pointer) pPicture))
+        return BadAlloc;
     return Success;
 }
 
-static int ProcRenderCreateRadialGradient (ClientPtr client)
+static int
+ProcRenderCreateRadialGradient(ClientPtr client)
 {
-    PicturePtr	    pPicture;
-    int		    len;
-    int		    error = 0;
-    xFixed          *stops;
-    xRenderColor   *colors;
+    PicturePtr pPicture;
+    int len;
+    int error = 0;
+    xFixed *stops;
+    xRenderColor *colors;
+
     REQUEST(xRenderCreateRadialGradientReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq);
@@ -1990,34 +1920,37 @@ static int ProcRenderCreateRadialGradient (ClientPtr client)
     LEGAL_NEW_RESOURCE(stuff->pid, client);
 
     len = (client->req_len << 2) - sizeof(xRenderCreateRadialGradientReq);
-    if (len != stuff->nStops*(sizeof(xFixed) + sizeof(xRenderColor)))
+    if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor)))
         return BadLength;
 
-    stops = (xFixed *)(stuff + 1);
-    colors = (xRenderColor *)(stops + stuff->nStops);
+    stops = (xFixed *) (stuff + 1);
+    colors = (xRenderColor *) (stops + stuff->nStops);
 
-    pPicture = CreateRadialGradientPicture (stuff->pid, &stuff->inner, &stuff->outer,
-                                            stuff->inner_radius, stuff->outer_radius,
-                                            stuff->nStops, stops, colors, &error);
+    pPicture =
+        CreateRadialGradientPicture(stuff->pid, &stuff->inner, &stuff->outer,
+                                    stuff->inner_radius, stuff->outer_radius,
+                                    stuff->nStops, stops, colors, &error);
     if (!pPicture)
-	return error;
+        return error;
     /* security creation/labeling check */
     error = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, PictureType,
-		     pPicture, RT_NONE, NULL, DixCreateAccess);
+                     pPicture, RT_NONE, NULL, DixCreateAccess);
     if (error != Success)
-	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
-	return BadAlloc;
+        return error;
+    if (!AddResource(stuff->pid, PictureType, (pointer) pPicture))
+        return BadAlloc;
     return Success;
 }
 
-static int ProcRenderCreateConicalGradient (ClientPtr client)
+static int
+ProcRenderCreateConicalGradient(ClientPtr client)
 {
-    PicturePtr	    pPicture;
-    int		    len;
-    int		    error = 0;
-    xFixed          *stops;
-    xRenderColor   *colors;
+    PicturePtr pPicture;
+    int len;
+    int error = 0;
+    xFixed *stops;
+    xRenderColor *colors;
+
     REQUEST(xRenderCreateConicalGradientReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq);
@@ -2025,51 +1958,51 @@ static int ProcRenderCreateConicalGradient (ClientPtr client)
     LEGAL_NEW_RESOURCE(stuff->pid, client);
 
     len = (client->req_len << 2) - sizeof(xRenderCreateConicalGradientReq);
-    if (len != stuff->nStops*(sizeof(xFixed) + sizeof(xRenderColor)))
+    if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor)))
         return BadLength;
 
-    stops = (xFixed *)(stuff + 1);
-    colors = (xRenderColor *)(stops + stuff->nStops);
+    stops = (xFixed *) (stuff + 1);
+    colors = (xRenderColor *) (stops + stuff->nStops);
 
-    pPicture = CreateConicalGradientPicture (stuff->pid, &stuff->center, stuff->angle,
-                                             stuff->nStops, stops, colors, &error);
+    pPicture =
+        CreateConicalGradientPicture(stuff->pid, &stuff->center, stuff->angle,
+                                     stuff->nStops, stops, colors, &error);
     if (!pPicture)
-	return error;
+        return error;
     /* security creation/labeling check */
     error = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, PictureType,
-		     pPicture, RT_NONE, NULL, DixCreateAccess);
+                     pPicture, RT_NONE, NULL, DixCreateAccess);
     if (error != Success)
-	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
-	return BadAlloc;
+        return error;
+    if (!AddResource(stuff->pid, PictureType, (pointer) pPicture))
+        return BadAlloc;
     return Success;
 }
 
-
 static int
-ProcRenderDispatch (ClientPtr client)
+ProcRenderDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    
+
     if (stuff->data < RenderNumberRequests)
-	return (*ProcRenderVector[stuff->data]) (client);
+        return (*ProcRenderVector[stuff->data]) (client);
     else
-	return BadRequest;
+        return BadRequest;
 }
 
 static int
-SProcRenderQueryVersion (ClientPtr client)
+SProcRenderQueryVersion(ClientPtr client)
 {
     REQUEST(xRenderQueryVersionReq);
 
     swaps(&stuff->length);
     swapl(&stuff->majorVersion);
     swapl(&stuff->minorVersion);
-    return (*ProcRenderVector[stuff->renderReqType])(client);
+    return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
-SProcRenderQueryPictFormats (ClientPtr client)
+SProcRenderQueryPictFormats(ClientPtr client)
 {
     REQUEST(xRenderQueryPictFormatsReq);
     swaps(&stuff->length);
@@ -2077,7 +2010,7 @@ SProcRenderQueryPictFormats (ClientPtr client)
 }
 
 static int
-SProcRenderQueryPictIndexValues (ClientPtr client)
+SProcRenderQueryPictIndexValues(ClientPtr client)
 {
     REQUEST(xRenderQueryPictIndexValuesReq);
     swaps(&stuff->length);
@@ -2086,13 +2019,13 @@ SProcRenderQueryPictIndexValues (ClientPtr client)
 }
 
 static int
-SProcRenderQueryDithers (ClientPtr client)
+SProcRenderQueryDithers(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-SProcRenderCreatePicture (ClientPtr client)
+SProcRenderCreatePicture(ClientPtr client)
 {
     REQUEST(xRenderCreatePictureReq);
     swaps(&stuff->length);
@@ -2105,7 +2038,7 @@ SProcRenderCreatePicture (ClientPtr client)
 }
 
 static int
-SProcRenderChangePicture (ClientPtr client)
+SProcRenderChangePicture(ClientPtr client)
 {
     REQUEST(xRenderChangePictureReq);
     swaps(&stuff->length);
@@ -2116,7 +2049,7 @@ SProcRenderChangePicture (ClientPtr client)
 }
 
 static int
-SProcRenderSetPictureClipRectangles (ClientPtr client)
+SProcRenderSetPictureClipRectangles(ClientPtr client)
 {
     REQUEST(xRenderSetPictureClipRectanglesReq);
     swaps(&stuff->length);
@@ -2128,7 +2061,7 @@ SProcRenderSetPictureClipRectangles (ClientPtr client)
 }
 
 static int
-SProcRenderFreePicture (ClientPtr client)
+SProcRenderFreePicture(ClientPtr client)
 {
     REQUEST(xRenderFreePictureReq);
     swaps(&stuff->length);
@@ -2137,7 +2070,7 @@ SProcRenderFreePicture (ClientPtr client)
 }
 
 static int
-SProcRenderComposite (ClientPtr client)
+SProcRenderComposite(ClientPtr client)
 {
     REQUEST(xRenderCompositeReq);
     swaps(&stuff->length);
@@ -2156,7 +2089,7 @@ SProcRenderComposite (ClientPtr client)
 }
 
 static int
-SProcRenderScale (ClientPtr client)
+SProcRenderScale(ClientPtr client)
 {
     REQUEST(xRenderScaleReq);
     swaps(&stuff->length);
@@ -2174,7 +2107,7 @@ SProcRenderScale (ClientPtr client)
 }
 
 static int
-SProcRenderTrapezoids (ClientPtr client)
+SProcRenderTrapezoids(ClientPtr client)
 {
     REQUEST(xRenderTrapezoidsReq);
 
@@ -2190,7 +2123,7 @@ SProcRenderTrapezoids (ClientPtr client)
 }
 
 static int
-SProcRenderTriangles (ClientPtr client)
+SProcRenderTriangles(ClientPtr client)
 {
     REQUEST(xRenderTrianglesReq);
 
@@ -2206,7 +2139,7 @@ SProcRenderTriangles (ClientPtr client)
 }
 
 static int
-SProcRenderTriStrip (ClientPtr client)
+SProcRenderTriStrip(ClientPtr client)
 {
     REQUEST(xRenderTriStripReq);
 
@@ -2222,7 +2155,7 @@ SProcRenderTriStrip (ClientPtr client)
 }
 
 static int
-SProcRenderTriFan (ClientPtr client)
+SProcRenderTriFan(ClientPtr client)
 {
     REQUEST(xRenderTriFanReq);
 
@@ -2238,25 +2171,25 @@ SProcRenderTriFan (ClientPtr client)
 }
 
 static int
-SProcRenderColorTrapezoids (ClientPtr client)
+SProcRenderColorTrapezoids(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-SProcRenderColorTriangles (ClientPtr client)
+SProcRenderColorTriangles(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-SProcRenderTransform (ClientPtr client)
+SProcRenderTransform(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-SProcRenderCreateGlyphSet (ClientPtr client)
+SProcRenderCreateGlyphSet(ClientPtr client)
 {
     REQUEST(xRenderCreateGlyphSetReq);
     swaps(&stuff->length);
@@ -2266,17 +2199,17 @@ SProcRenderCreateGlyphSet (ClientPtr client)
 }
 
 static int
-SProcRenderReferenceGlyphSet (ClientPtr client)
+SProcRenderReferenceGlyphSet(ClientPtr client)
 {
     REQUEST(xRenderReferenceGlyphSetReq);
     swaps(&stuff->length);
     swapl(&stuff->gsid);
     swapl(&stuff->existing);
-    return (*ProcRenderVector[stuff->renderReqType])  (client);
+    return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
-SProcRenderFreeGlyphSet (ClientPtr client)
+SProcRenderFreeGlyphSet(ClientPtr client)
 {
     REQUEST(xRenderFreeGlyphSetReq);
     swaps(&stuff->length);
@@ -2285,46 +2218,46 @@ SProcRenderFreeGlyphSet (ClientPtr client)
 }
 
 static int
-SProcRenderAddGlyphs (ClientPtr client)
+SProcRenderAddGlyphs(ClientPtr client)
 {
     register int i;
-    CARD32  *gids;
-    void    *end;
+    CARD32 *gids;
+    void *end;
     xGlyphInfo *gi;
+
     REQUEST(xRenderAddGlyphsReq);
     swaps(&stuff->length);
     swapl(&stuff->glyphset);
     swapl(&stuff->nglyphs);
     if (stuff->nglyphs & 0xe0000000)
-	return BadLength;
+        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;
+        return BadLength;
     if ((char *) end - (char *) (gi + stuff->nglyphs) < 0)
-	return BadLength;
-    for (i = 0; i < stuff->nglyphs; i++)
-    {
-	swapl(&gids[i]);
-	swaps(&gi[i].width);
-	swaps(&gi[i].height);
-	swaps(&gi[i].x);
-	swaps(&gi[i].y);
-	swaps(&gi[i].xOff);
-	swaps(&gi[i].yOff);
+        return BadLength;
+    for (i = 0; i < stuff->nglyphs; i++) {
+        swapl(&gids[i]);
+        swaps(&gi[i].width);
+        swaps(&gi[i].height);
+        swaps(&gi[i].x);
+        swaps(&gi[i].y);
+        swaps(&gi[i].xOff);
+        swaps(&gi[i].yOff);
     }
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
-SProcRenderAddGlyphsFromPicture (ClientPtr client)
+SProcRenderAddGlyphsFromPicture(ClientPtr client)
 {
     return BadImplementation;
 }
 
 static int
-SProcRenderFreeGlyphs (ClientPtr client)
+SProcRenderFreeGlyphs(ClientPtr client)
 {
     REQUEST(xRenderFreeGlyphsReq);
     swaps(&stuff->length);
@@ -2334,23 +2267,29 @@ SProcRenderFreeGlyphs (ClientPtr client)
 }
 
 static int
-SProcRenderCompositeGlyphs (ClientPtr client)
+SProcRenderCompositeGlyphs(ClientPtr client)
 {
-    xGlyphElt	*elt;
-    CARD8	*buffer;
-    CARD8	*end;
-    int		space;
-    int		i;
-    int		size;
-    
+    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;
+    default:
+        size = 1;
+        break;
+    case X_RenderCompositeGlyphs16:
+        size = 2;
+        break;
+    case X_RenderCompositeGlyphs32:
+        size = 4;
+        break;
     }
-	    
+
     swaps(&stuff->length);
     swapl(&stuff->src);
     swapl(&stuff->dst);
@@ -2360,55 +2299,50 @@ SProcRenderCompositeGlyphs (ClientPtr client)
     swaps(&stuff->ySrc);
     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);
-	swaps(&elt->deltay);
-	
-	i = elt->len;
-	if (i == 0xff)
-	{
-	    swapl((int *)buffer);
-	    buffer += 4;
-	}
-	else
-	{
-	    space = size * i;
-	    switch (size) {
-	    case 1:
-		buffer += i;
-		break;
-	    case 2:
-		while (i--)
-		{
-		    swaps((short *)buffer);
-		    buffer += 2;
-		}
-		break;
-	    case 4:
-		while (i--)
-		{
-		    swapl((int *)buffer);
-		    buffer += 4;
-		}
-		break;
-	    }
-	    if (space & 3)
-		buffer += 4 - (space & 3);
-	}
+    while (buffer + sizeof(xGlyphElt) < end) {
+        elt = (xGlyphElt *) buffer;
+        buffer += sizeof(xGlyphElt);
+
+        swaps(&elt->deltax);
+        swaps(&elt->deltay);
+
+        i = elt->len;
+        if (i == 0xff) {
+            swapl((int *) buffer);
+            buffer += 4;
+        }
+        else {
+            space = size * i;
+            switch (size) {
+            case 1:
+                buffer += i;
+                break;
+            case 2:
+                while (i--) {
+                    swaps((short *) buffer);
+                    buffer += 2;
+                }
+                break;
+            case 4:
+                while (i--) {
+                    swapl((int *) buffer);
+                    buffer += 4;
+                }
+                break;
+            }
+            if (space & 3)
+                buffer += 4 - (space & 3);
+        }
     }
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
-SProcRenderFillRectangles (ClientPtr client)
+SProcRenderFillRectangles(ClientPtr client)
 {
     REQUEST(xRenderFillRectanglesReq);
 
-    REQUEST_AT_LEAST_SIZE (xRenderFillRectanglesReq);
+    REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq);
     swaps(&stuff->length);
     swapl(&stuff->dst);
     swaps(&stuff->color.red);
@@ -2418,13 +2352,13 @@ SProcRenderFillRectangles (ClientPtr client)
     SwapRestS(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
-    
+
 static int
-SProcRenderCreateCursor (ClientPtr client)
+SProcRenderCreateCursor(ClientPtr client)
 {
     REQUEST(xRenderCreateCursorReq);
-    REQUEST_SIZE_MATCH (xRenderCreateCursorReq);
-    
+    REQUEST_SIZE_MATCH(xRenderCreateCursorReq);
+
     swaps(&stuff->length);
     swapl(&stuff->cid);
     swapl(&stuff->src);
@@ -2432,9 +2366,9 @@ SProcRenderCreateCursor (ClientPtr client)
     swaps(&stuff->y);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
-    
+
 static int
-SProcRenderSetPictureTransform (ClientPtr client)
+SProcRenderSetPictureTransform(ClientPtr client)
 {
     REQUEST(xRenderSetPictureTransformReq);
     REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq);
@@ -2454,33 +2388,33 @@ SProcRenderSetPictureTransform (ClientPtr client)
 }
 
 static int
-SProcRenderQueryFilters (ClientPtr client)
+SProcRenderQueryFilters(ClientPtr client)
 {
-    REQUEST (xRenderQueryFiltersReq);
-    REQUEST_SIZE_MATCH (xRenderQueryFiltersReq);
+    REQUEST(xRenderQueryFiltersReq);
+    REQUEST_SIZE_MATCH(xRenderQueryFiltersReq);
 
     swaps(&stuff->length);
     swapl(&stuff->drawable);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
-    
+
 static int
-SProcRenderSetPictureFilter (ClientPtr client)
+SProcRenderSetPictureFilter(ClientPtr client)
 {
-    REQUEST (xRenderSetPictureFilterReq);
-    REQUEST_AT_LEAST_SIZE (xRenderSetPictureFilterReq);
+    REQUEST(xRenderSetPictureFilterReq);
+    REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq);
 
     swaps(&stuff->length);
     swapl(&stuff->picture);
     swaps(&stuff->nbytes);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
-    
+
 static int
-SProcRenderCreateAnimCursor (ClientPtr client)
+SProcRenderCreateAnimCursor(ClientPtr client)
 {
-    REQUEST (xRenderCreateAnimCursorReq);
-    REQUEST_AT_LEAST_SIZE (xRenderCreateAnimCursorReq);
+    REQUEST(xRenderCreateAnimCursorReq);
+    REQUEST_AT_LEAST_SIZE(xRenderCreateAnimCursorReq);
 
     swaps(&stuff->length);
     swapl(&stuff->cid);
@@ -2489,10 +2423,10 @@ SProcRenderCreateAnimCursor (ClientPtr client)
 }
 
 static int
-SProcRenderAddTraps (ClientPtr client)
+SProcRenderAddTraps(ClientPtr client)
 {
-    REQUEST (xRenderAddTrapsReq);
-    REQUEST_AT_LEAST_SIZE (xRenderAddTrapsReq);
+    REQUEST(xRenderAddTrapsReq);
+    REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq);
 
     swaps(&stuff->length);
     swapl(&stuff->picture);
@@ -2505,8 +2439,8 @@ SProcRenderAddTraps (ClientPtr client)
 static int
 SProcRenderCreateSolidFill(ClientPtr client)
 {
-    REQUEST (xRenderCreateSolidFillReq);
-    REQUEST_AT_LEAST_SIZE (xRenderCreateSolidFillReq);
+    REQUEST(xRenderCreateSolidFillReq);
+    REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq);
 
     swaps(&stuff->length);
     swapl(&stuff->pid);
@@ -2517,29 +2451,32 @@ SProcRenderCreateSolidFill(ClientPtr client)
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
-static void swapStops(void *stuff, int num)
+static void
+swapStops(void *stuff, int num)
 {
     int i;
     CARD32 *stops;
     CARD16 *colors;
-    stops = (CARD32 *)(stuff);
+
+    stops = (CARD32 *) (stuff);
     for (i = 0; i < num; ++i) {
         swapl(stops);
         ++stops;
     }
-    colors = (CARD16 *)(stops);
-    for (i = 0; i < 4*num; ++i) {
+    colors = (CARD16 *) (stops);
+    for (i = 0; i < 4 * num; ++i) {
         swaps(colors);
         ++colors;
     }
 }
 
 static int
-SProcRenderCreateLinearGradient (ClientPtr client)
+SProcRenderCreateLinearGradient(ClientPtr client)
 {
     int len;
-    REQUEST (xRenderCreateLinearGradientReq);
-    REQUEST_AT_LEAST_SIZE (xRenderCreateLinearGradientReq);
+
+    REQUEST(xRenderCreateLinearGradientReq);
+    REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq);
 
     swaps(&stuff->length);
     swapl(&stuff->pid);
@@ -2550,22 +2487,23 @@ SProcRenderCreateLinearGradient (ClientPtr client)
     swapl(&stuff->nStops);
 
     len = (client->req_len << 2) - sizeof(xRenderCreateLinearGradientReq);
-    if (stuff->nStops > UINT32_MAX/(sizeof(xFixed) + sizeof(xRenderColor)))
-	return BadLength;
-    if (len != stuff->nStops*(sizeof(xFixed) + sizeof(xRenderColor)))
+    if (stuff->nStops > UINT32_MAX / (sizeof(xFixed) + sizeof(xRenderColor)))
+        return BadLength;
+    if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor)))
         return BadLength;
 
-    swapStops(stuff+1, stuff->nStops);
+    swapStops(stuff + 1, stuff->nStops);
 
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
-SProcRenderCreateRadialGradient (ClientPtr client)
+SProcRenderCreateRadialGradient(ClientPtr client)
 {
     int len;
-    REQUEST (xRenderCreateRadialGradientReq);
-    REQUEST_AT_LEAST_SIZE (xRenderCreateRadialGradientReq);
+
+    REQUEST(xRenderCreateRadialGradientReq);
+    REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq);
 
     swaps(&stuff->length);
     swapl(&stuff->pid);
@@ -2578,22 +2516,23 @@ SProcRenderCreateRadialGradient (ClientPtr client)
     swapl(&stuff->nStops);
 
     len = (client->req_len << 2) - sizeof(xRenderCreateRadialGradientReq);
-    if (stuff->nStops > UINT32_MAX/(sizeof(xFixed) + sizeof(xRenderColor)))
-	return BadLength;
-    if (len != stuff->nStops*(sizeof(xFixed) + sizeof(xRenderColor)))
+    if (stuff->nStops > UINT32_MAX / (sizeof(xFixed) + sizeof(xRenderColor)))
+        return BadLength;
+    if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor)))
         return BadLength;
 
-    swapStops(stuff+1, stuff->nStops);
+    swapStops(stuff + 1, stuff->nStops);
 
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
-SProcRenderCreateConicalGradient (ClientPtr client)
+SProcRenderCreateConicalGradient(ClientPtr client)
 {
     int len;
-    REQUEST (xRenderCreateConicalGradientReq);
-    REQUEST_AT_LEAST_SIZE (xRenderCreateConicalGradientReq);
+
+    REQUEST(xRenderCreateConicalGradientReq);
+    REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq);
 
     swaps(&stuff->length);
     swapl(&stuff->pid);
@@ -2603,25 +2542,25 @@ SProcRenderCreateConicalGradient (ClientPtr client)
     swapl(&stuff->nStops);
 
     len = (client->req_len << 2) - sizeof(xRenderCreateConicalGradientReq);
-    if (stuff->nStops > UINT32_MAX/(sizeof(xFixed) + sizeof(xRenderColor)))
-	return BadLength;
-    if (len != stuff->nStops*(sizeof(xFixed) + sizeof(xRenderColor)))
+    if (stuff->nStops > UINT32_MAX / (sizeof(xFixed) + sizeof(xRenderColor)))
+        return BadLength;
+    if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor)))
         return BadLength;
 
-    swapStops(stuff+1, stuff->nStops);
+    swapStops(stuff + 1, stuff->nStops);
 
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
-SProcRenderDispatch (ClientPtr client)
+SProcRenderDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    
+
     if (stuff->data < RenderNumberRequests)
-	return (*SProcRenderVector[stuff->data]) (client);
+        return (*SProcRenderVector[stuff->data]) (client);
     else
-	return BadRequest;
+        return BadRequest;
 }
 
 #ifdef PANORAMIX
@@ -2640,133 +2579,143 @@ SProcRenderDispatch (ClientPtr client)
     } \
 } \
 
-int	    (*PanoramiXSaveRenderVector[RenderNumberRequests])(ClientPtr);
+int (*PanoramiXSaveRenderVector[RenderNumberRequests]) (ClientPtr);
 
 static int
-PanoramiXRenderCreatePicture (ClientPtr client)
+PanoramiXRenderCreatePicture(ClientPtr client)
 {
     REQUEST(xRenderCreatePictureReq);
-    PanoramiXRes    *refDraw, *newPict;
-    int		    result, j;
+    PanoramiXRes *refDraw, *newPict;
+    int result, j;
 
     REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq);
-    result = dixLookupResourceByClass((pointer *)&refDraw, stuff->drawable,
-				      XRC_DRAWABLE, client, DixWriteAccess);
+    result = dixLookupResourceByClass((pointer *) &refDraw, stuff->drawable,
+                                      XRC_DRAWABLE, client, DixWriteAccess);
     if (result != Success)
-	return (result == BadValue) ? BadDrawable : result;
-    if(!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
-	return BadAlloc;
+        return (result == BadValue) ? BadDrawable : result;
+    if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
+        return BadAlloc;
     newPict->type = XRT_PICTURE;
     panoramix_setup_ids(newPict, client, stuff->pid);
-    
+
     if (refDraw->type == XRT_WINDOW &&
-	stuff->drawable == screenInfo.screens[0]->root->drawable.id)
-    {
-	newPict->u.pict.root = TRUE;
+        stuff->drawable == screenInfo.screens[0]->root->drawable.id) {
+        newPict->u.pict.root = TRUE;
     }
     else
-	newPict->u.pict.root = FALSE;
-    
+        newPict->u.pict.root = FALSE;
+
     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;
+        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 
-	free(newPict);
+        AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
+    else
+        free(newPict);
 
     return result;
 }
 
 static int
-PanoramiXRenderChangePicture (ClientPtr client)
+PanoramiXRenderChangePicture(ClientPtr client)
 {
-    PanoramiXRes    *pict;
-    int		    result = Success, j;
+    PanoramiXRes *pict;
+    int result = Success, j;
+
     REQUEST(xRenderChangePictureReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq);
-    
+
     VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
-    
+
     FOR_NSCREENS_BACKWARD(j) {
         stuff->picture = pict->info[j].id;
         result = (*PanoramiXSaveRenderVector[X_RenderChangePicture]) (client);
-        if(result != Success) break;
+        if (result != Success)
+            break;
     }
 
     return result;
 }
 
 static int
-PanoramiXRenderSetPictureClipRectangles (ClientPtr client)
+PanoramiXRenderSetPictureClipRectangles(ClientPtr client)
 {
     REQUEST(xRenderSetPictureClipRectanglesReq);
-    int		    result = Success, j;
-    PanoramiXRes    *pict;
+    int result = Success, j;
+    PanoramiXRes *pict;
 
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq);
-    
+
     VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
-    
+
     FOR_NSCREENS_BACKWARD(j) {
         stuff->picture = pict->info[j].id;
-        result = (*PanoramiXSaveRenderVector[X_RenderSetPictureClipRectangles]) (client);
-        if(result != Success) break;
+        result =
+            (*PanoramiXSaveRenderVector[X_RenderSetPictureClipRectangles])
+            (client);
+        if (result != Success)
+            break;
     }
 
     return result;
 }
 
 static int
-PanoramiXRenderSetPictureTransform (ClientPtr client)
+PanoramiXRenderSetPictureTransform(ClientPtr client)
 {
     REQUEST(xRenderSetPictureTransformReq);
-    int		    result = Success, j;
-    PanoramiXRes    *pict;
+    int result = Success, j;
+    PanoramiXRes *pict;
 
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureTransformReq);
-    
+
     VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
-    
+
     FOR_NSCREENS_BACKWARD(j) {
         stuff->picture = pict->info[j].id;
-        result = (*PanoramiXSaveRenderVector[X_RenderSetPictureTransform]) (client);
-        if(result != Success) break;
+        result =
+            (*PanoramiXSaveRenderVector[X_RenderSetPictureTransform]) (client);
+        if (result != Success)
+            break;
     }
 
     return result;
 }
 
 static int
-PanoramiXRenderSetPictureFilter (ClientPtr client)
+PanoramiXRenderSetPictureFilter(ClientPtr client)
 {
     REQUEST(xRenderSetPictureFilterReq);
-    int		    result = Success, j;
-    PanoramiXRes    *pict;
+    int result = Success, j;
+    PanoramiXRes *pict;
 
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq);
-    
+
     VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
-    
+
     FOR_NSCREENS_BACKWARD(j) {
         stuff->picture = pict->info[j].id;
-        result = (*PanoramiXSaveRenderVector[X_RenderSetPictureFilter]) (client);
-        if(result != Success) break;
+        result =
+            (*PanoramiXSaveRenderVector[X_RenderSetPictureFilter]) (client);
+        if (result != Success)
+            break;
     }
 
     return result;
 }
 
 static int
-PanoramiXRenderFreePicture (ClientPtr client)
+PanoramiXRenderFreePicture(ClientPtr client)
 {
     PanoramiXRes *pict;
-    int         result = Success, j;
+    int result = Success, j;
+
     REQUEST(xRenderFreePictureReq);
 
     REQUEST_SIZE_MATCH(xRenderFreePictureReq);
@@ -2774,146 +2723,144 @@ PanoramiXRenderFreePicture (ClientPtr client)
     client->errorValue = stuff->picture;
 
     VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixDestroyAccess);
-    
 
     FOR_NSCREENS_BACKWARD(j) {
-	stuff->picture = pict->info[j].id;
-	result = (*PanoramiXSaveRenderVector[X_RenderFreePicture]) (client);
-	if(result != Success) break;
+        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 */
- 
+       our resource for us on the last pass through the loop above */
+
     return result;
 }
 
 static int
-PanoramiXRenderComposite (ClientPtr client)
+PanoramiXRenderComposite(ClientPtr client)
 {
-    PanoramiXRes	*src, *msk, *dst;
-    int			result = Success, j;
-    xRenderCompositeReq	orig;
+    PanoramiXRes *src, *msk, *dst;
+    int result = Success, j;
+    xRenderCompositeReq orig;
+
     REQUEST(xRenderCompositeReq);
 
     REQUEST_SIZE_MATCH(xRenderCompositeReq);
-    
-    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess);
-    VERIFY_XIN_ALPHA (msk, stuff->mask, client, DixReadAccess);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess);
-    
+
+    VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
+    VERIFY_XIN_ALPHA(msk, stuff->mask, client, DixReadAccess);
+    VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
+
     orig = *stuff;
-    
+
     FOR_NSCREENS_FORWARD(j) {
-	stuff->src = src->info[j].id;
-	if (src->u.pict.root)
-	{
-	    stuff->xSrc = orig.xSrc - screenInfo.screens[j]->x;
-	    stuff->ySrc = orig.ySrc - screenInfo.screens[j]->y;
-	}
-	stuff->dst = dst->info[j].id;
-	if (dst->u.pict.root)
-	{
-	    stuff->xDst = orig.xDst - screenInfo.screens[j]->x;
-	    stuff->yDst = orig.yDst - screenInfo.screens[j]->y;
-	}
-	if (msk)
-	{
-	    stuff->mask = msk->info[j].id;
-	    if (msk->u.pict.root)
-	    {
-		stuff->xMask = orig.xMask - screenInfo.screens[j]->x;
-		stuff->yMask = orig.yMask - screenInfo.screens[j]->y;
-	    }
-	}
-	result = (*PanoramiXSaveRenderVector[X_RenderComposite]) (client);
-	if(result != Success) break;
+        stuff->src = src->info[j].id;
+        if (src->u.pict.root) {
+            stuff->xSrc = orig.xSrc - screenInfo.screens[j]->x;
+            stuff->ySrc = orig.ySrc - screenInfo.screens[j]->y;
+        }
+        stuff->dst = dst->info[j].id;
+        if (dst->u.pict.root) {
+            stuff->xDst = orig.xDst - screenInfo.screens[j]->x;
+            stuff->yDst = orig.yDst - screenInfo.screens[j]->y;
+        }
+        if (msk) {
+            stuff->mask = msk->info[j].id;
+            if (msk->u.pict.root) {
+                stuff->xMask = orig.xMask - screenInfo.screens[j]->x;
+                stuff->yMask = orig.yMask - screenInfo.screens[j]->y;
+            }
+        }
+        result = (*PanoramiXSaveRenderVector[X_RenderComposite]) (client);
+        if (result != Success)
+            break;
     }
 
     return result;
 }
 
 static int
-PanoramiXRenderCompositeGlyphs (ClientPtr client)
+PanoramiXRenderCompositeGlyphs(ClientPtr client)
 {
-    PanoramiXRes    *src, *dst;
-    int		    result = Success, j;
+    PanoramiXRes *src, *dst;
+    int result = Success, j;
+
     REQUEST(xRenderCompositeGlyphsReq);
-    xGlyphElt	    origElt, *elt;
-    INT16	    xSrc, ySrc;
+    xGlyphElt origElt, *elt;
+    INT16 xSrc, ySrc;
 
     REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq);
-    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess);
-
-    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 - screenInfo.screens[j]->x;
-		stuff->ySrc = ySrc - screenInfo.screens[j]->y;
-	    }
-	    stuff->dst = dst->info[j].id;
-	    if (dst->u.pict.root)
-	    {
-		elt->deltax = origElt.deltax - screenInfo.screens[j]->x;
-		elt->deltay = origElt.deltay - screenInfo.screens[j]->y;
-	    }
-	    result = (*PanoramiXSaveRenderVector[stuff->renderReqType]) (client);
-	    if(result != Success) break;
-	}
+    VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
+    VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
+
+    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 - screenInfo.screens[j]->x;
+                stuff->ySrc = ySrc - screenInfo.screens[j]->y;
+            }
+            stuff->dst = dst->info[j].id;
+            if (dst->u.pict.root) {
+                elt->deltax = origElt.deltax - screenInfo.screens[j]->x;
+                elt->deltay = origElt.deltay - screenInfo.screens[j]->y;
+            }
+            result =
+                (*PanoramiXSaveRenderVector[stuff->renderReqType]) (client);
+            if (result != Success)
+                break;
+        }
     }
 
     return result;
 }
 
 static int
-PanoramiXRenderFillRectangles (ClientPtr client)
+PanoramiXRenderFillRectangles(ClientPtr client)
 {
-    PanoramiXRes    *dst;
-    int		    result = Success, j;
+    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, DixWriteAccess);
-    extra_len = (client->req_len << 2) - sizeof (xRenderFillRectanglesReq);
-    if (extra_len &&
-	(extra = (char *) malloc(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 = screenInfo.screens[j]->x;
-		int y_off = screenInfo.screens[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;
-	}
-	free(extra);
+    char *extra;
+    int extra_len;
+
+    REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq);
+    VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
+    extra_len = (client->req_len << 2) - sizeof(xRenderFillRectanglesReq);
+    if (extra_len && (extra = (char *) malloc(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 = screenInfo.screens[j]->x;
+                int y_off = screenInfo.screens[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;
+        }
+        free(extra);
     }
 
     return result;
@@ -2922,57 +2869,58 @@ PanoramiXRenderFillRectangles (ClientPtr client)
 static int
 PanoramiXRenderTrapezoids(ClientPtr client)
 {
-    PanoramiXRes        *src, *dst;
-    int                 result = Success, j;
+    PanoramiXRes *src, *dst;
+    int result = Success, j;
+
     REQUEST(xRenderTrapezoidsReq);
-    char		*extra;
-    int			extra_len;
-    
-    REQUEST_AT_LEAST_SIZE (xRenderTrapezoidsReq);
-    
-    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess);
-
-    extra_len = (client->req_len << 2) - sizeof (xRenderTrapezoidsReq);
-
-    if (extra_len &&
-	(extra = (char *) malloc(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 = screenInfo.screens[j]->x;
-		int y_off = screenInfo.screens[j]->y;
-
-		if(x_off || y_off) {
-                    xTrapezoid  *trap = (xTrapezoid *) (stuff + 1);
-		    int         i = extra_len / sizeof (xTrapezoid);
-
-		    while (i--) {
-			trap->top -= y_off;
-			trap->bottom -= y_off;
-			trap->left.p1.x -= x_off;
-			trap->left.p1.y -= y_off;
-			trap->left.p2.x -= x_off;
-			trap->left.p2.y -= y_off;
-			trap->right.p1.x -= x_off;
-			trap->right.p1.y -= y_off;
-			trap->right.p2.x -= x_off;
-			trap->right.p2.y -= y_off;
-			trap++;
-		    }
-		}
-	    }
-	    
+    char *extra;
+    int extra_len;
+
+    REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq);
+
+    VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
+    VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
+
+    extra_len = (client->req_len << 2) - sizeof(xRenderTrapezoidsReq);
+
+    if (extra_len && (extra = (char *) malloc(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 = screenInfo.screens[j]->x;
+                int y_off = screenInfo.screens[j]->y;
+
+                if (x_off || y_off) {
+                    xTrapezoid *trap = (xTrapezoid *) (stuff + 1);
+                    int i = extra_len / sizeof(xTrapezoid);
+
+                    while (i--) {
+                        trap->top -= y_off;
+                        trap->bottom -= y_off;
+                        trap->left.p1.x -= x_off;
+                        trap->left.p1.y -= y_off;
+                        trap->left.p2.x -= x_off;
+                        trap->left.p2.y -= y_off;
+                        trap->right.p1.x -= x_off;
+                        trap->right.p1.y -= y_off;
+                        trap->right.p2.x -= x_off;
+                        trap->right.p2.y -= y_off;
+                        trap++;
+                    }
+                }
+            }
+
             stuff->src = src->info[j].id;
             stuff->dst = dst->info[j].id;
-	    result =
-		(*PanoramiXSaveRenderVector[X_RenderTrapezoids]) (client);
+            result = (*PanoramiXSaveRenderVector[X_RenderTrapezoids]) (client);
+
+            if (result != Success)
+                break;
+        }
 
-	    if(result != Success) break;
-	}
-	
         free(extra);
     }
 
@@ -2982,53 +2930,54 @@ PanoramiXRenderTrapezoids(ClientPtr client)
 static int
 PanoramiXRenderTriangles(ClientPtr client)
 {
-    PanoramiXRes        *src, *dst;
-    int                 result = Success, j;
+    PanoramiXRes *src, *dst;
+    int result = Success, j;
+
     REQUEST(xRenderTrianglesReq);
-    char		*extra;
-    int			extra_len;
-    
-    REQUEST_AT_LEAST_SIZE (xRenderTrianglesReq);
-    
-    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess);
-
-    extra_len = (client->req_len << 2) - sizeof (xRenderTrianglesReq);
-
-    if (extra_len &&
-	(extra = (char *) malloc(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 = screenInfo.screens[j]->x;
-		int y_off = screenInfo.screens[j]->y;
-
-		if(x_off || y_off) {
-                    xTriangle  *tri = (xTriangle *) (stuff + 1);
-		    int         i = extra_len / sizeof (xTriangle);
-
-		    while (i--) {
-			tri->p1.x -= x_off;
-			tri->p1.y -= y_off;
-			tri->p2.x -= x_off;
-			tri->p2.y -= y_off;
-			tri->p3.x -= x_off;
-			tri->p3.y -= y_off;
-			tri++;
-		    }
-		}
-	    }
-	    
+    char *extra;
+    int extra_len;
+
+    REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq);
+
+    VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
+    VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
+
+    extra_len = (client->req_len << 2) - sizeof(xRenderTrianglesReq);
+
+    if (extra_len && (extra = (char *) malloc(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 = screenInfo.screens[j]->x;
+                int y_off = screenInfo.screens[j]->y;
+
+                if (x_off || y_off) {
+                    xTriangle *tri = (xTriangle *) (stuff + 1);
+                    int i = extra_len / sizeof(xTriangle);
+
+                    while (i--) {
+                        tri->p1.x -= x_off;
+                        tri->p1.y -= y_off;
+                        tri->p2.x -= x_off;
+                        tri->p2.y -= y_off;
+                        tri->p3.x -= x_off;
+                        tri->p3.y -= y_off;
+                        tri++;
+                    }
+                }
+            }
+
             stuff->src = src->info[j].id;
             stuff->dst = dst->info[j].id;
-	    result =
-		(*PanoramiXSaveRenderVector[X_RenderTriangles]) (client);
+            result = (*PanoramiXSaveRenderVector[X_RenderTriangles]) (client);
+
+            if (result != Success)
+                break;
+        }
 
-	    if(result != Success) break;
-	}
-	
         free(extra);
     }
 
@@ -3038,49 +2987,50 @@ PanoramiXRenderTriangles(ClientPtr client)
 static int
 PanoramiXRenderTriStrip(ClientPtr client)
 {
-    PanoramiXRes        *src, *dst;
-    int                 result = Success, j;
+    PanoramiXRes *src, *dst;
+    int result = Success, j;
+
     REQUEST(xRenderTriStripReq);
-    char		*extra;
-    int			extra_len;
-    
-    REQUEST_AT_LEAST_SIZE (xRenderTriStripReq);
-    
-    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess);
-
-    extra_len = (client->req_len << 2) - sizeof (xRenderTriStripReq);
-
-    if (extra_len &&
-	(extra = (char *) malloc(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 = screenInfo.screens[j]->x;
-		int y_off = screenInfo.screens[j]->y;
-
-		if(x_off || y_off) {
-                    xPointFixed  *fixed = (xPointFixed *) (stuff + 1);
-		    int         i = extra_len / sizeof (xPointFixed);
-
-		    while (i--) {
-			fixed->x -= x_off;
-			fixed->y -= y_off;
-			fixed++;
-		    }
-		}
-	    }
-	    
+    char *extra;
+    int extra_len;
+
+    REQUEST_AT_LEAST_SIZE(xRenderTriStripReq);
+
+    VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
+    VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
+
+    extra_len = (client->req_len << 2) - sizeof(xRenderTriStripReq);
+
+    if (extra_len && (extra = (char *) malloc(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 = screenInfo.screens[j]->x;
+                int y_off = screenInfo.screens[j]->y;
+
+                if (x_off || y_off) {
+                    xPointFixed *fixed = (xPointFixed *) (stuff + 1);
+                    int i = extra_len / sizeof(xPointFixed);
+
+                    while (i--) {
+                        fixed->x -= x_off;
+                        fixed->y -= y_off;
+                        fixed++;
+                    }
+                }
+            }
+
             stuff->src = src->info[j].id;
             stuff->dst = dst->info[j].id;
-	    result =
-		(*PanoramiXSaveRenderVector[X_RenderTriStrip]) (client);
+            result = (*PanoramiXSaveRenderVector[X_RenderTriStrip]) (client);
+
+            if (result != Success)
+                break;
+        }
 
-	    if(result != Success) break;
-	}
-	
         free(extra);
     }
 
@@ -3090,49 +3040,50 @@ PanoramiXRenderTriStrip(ClientPtr client)
 static int
 PanoramiXRenderTriFan(ClientPtr client)
 {
-    PanoramiXRes        *src, *dst;
-    int                 result = Success, j;
+    PanoramiXRes *src, *dst;
+    int result = Success, j;
+
     REQUEST(xRenderTriFanReq);
-    char		*extra;
-    int			extra_len;
-    
-    REQUEST_AT_LEAST_SIZE (xRenderTriFanReq);
-    
-    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess);
-
-    extra_len = (client->req_len << 2) - sizeof (xRenderTriFanReq);
-
-    if (extra_len &&
-	(extra = (char *) malloc(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 = screenInfo.screens[j]->x;
-		int y_off = screenInfo.screens[j]->y;
-
-		if(x_off || y_off) {
-                    xPointFixed  *fixed = (xPointFixed *) (stuff + 1);
-		    int         i = extra_len / sizeof (xPointFixed);
-
-		    while (i--) {
-			fixed->x -= x_off;
-			fixed->y -= y_off;
-			fixed++;
-		    }
-		}
-	    }
-	    
+    char *extra;
+    int extra_len;
+
+    REQUEST_AT_LEAST_SIZE(xRenderTriFanReq);
+
+    VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
+    VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
+
+    extra_len = (client->req_len << 2) - sizeof(xRenderTriFanReq);
+
+    if (extra_len && (extra = (char *) malloc(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 = screenInfo.screens[j]->x;
+                int y_off = screenInfo.screens[j]->y;
+
+                if (x_off || y_off) {
+                    xPointFixed *fixed = (xPointFixed *) (stuff + 1);
+                    int i = extra_len / sizeof(xPointFixed);
+
+                    while (i--) {
+                        fixed->x -= x_off;
+                        fixed->y -= y_off;
+                        fixed++;
+                    }
+                }
+            }
+
             stuff->src = src->info[j].id;
             stuff->dst = dst->info[j].id;
-	    result =
-		(*PanoramiXSaveRenderVector[X_RenderTriFan]) (client);
+            result = (*PanoramiXSaveRenderVector[X_RenderTriFan]) (client);
+
+            if (result != Success)
+                break;
+        }
 
-	    if(result != Success) break;
-	}
-	
         free(extra);
     }
 
@@ -3140,186 +3091,199 @@ PanoramiXRenderTriFan(ClientPtr client)
 }
 
 static int
-PanoramiXRenderAddTraps (ClientPtr client)
+PanoramiXRenderAddTraps(ClientPtr client)
 {
-    PanoramiXRes    *picture;
-    int		    result = Success, j;
+    PanoramiXRes *picture;
+    int result = Success, j;
+
     REQUEST(xRenderAddTrapsReq);
-    char	    *extra;
-    int		    extra_len;
-    INT16    	    x_off, y_off;
-
-    REQUEST_AT_LEAST_SIZE (xRenderAddTrapsReq);
-    VERIFY_XIN_PICTURE (picture, stuff->picture, client, DixWriteAccess);
-    extra_len = (client->req_len << 2) - sizeof (xRenderAddTrapsReq);
-    if (extra_len &&
-	(extra = (char *) malloc(extra_len)))
-    {
-	memcpy (extra, stuff + 1, extra_len);
-	x_off = stuff->xOff;
-	y_off = stuff->yOff;
-	FOR_NSCREENS_FORWARD(j) {
-	    if (j) memcpy (stuff + 1, extra, extra_len);
-	    stuff->picture = picture->info[j].id;
-	    
-	    if (picture->u.pict.root)
-	    {
-		stuff->xOff = x_off + screenInfo.screens[j]->x;
-		stuff->yOff = y_off + screenInfo.screens[j]->y;
-	    }
-	    result = (*PanoramiXSaveRenderVector[X_RenderAddTraps]) (client);
-	    if(result != Success) break;
-	}
-	free(extra);
+    char *extra;
+    int extra_len;
+    INT16 x_off, y_off;
+
+    REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq);
+    VERIFY_XIN_PICTURE(picture, stuff->picture, client, DixWriteAccess);
+    extra_len = (client->req_len << 2) - sizeof(xRenderAddTrapsReq);
+    if (extra_len && (extra = (char *) malloc(extra_len))) {
+        memcpy(extra, stuff + 1, extra_len);
+        x_off = stuff->xOff;
+        y_off = stuff->yOff;
+        FOR_NSCREENS_FORWARD(j) {
+            if (j)
+                memcpy(stuff + 1, extra, extra_len);
+            stuff->picture = picture->info[j].id;
+
+            if (picture->u.pict.root) {
+                stuff->xOff = x_off + screenInfo.screens[j]->x;
+                stuff->yOff = y_off + screenInfo.screens[j]->y;
+            }
+            result = (*PanoramiXSaveRenderVector[X_RenderAddTraps]) (client);
+            if (result != Success)
+                break;
+        }
+        free(extra);
     }
 
     return result;
 }
 
 static int
-PanoramiXRenderCreateSolidFill (ClientPtr client)
+PanoramiXRenderCreateSolidFill(ClientPtr client)
 {
     REQUEST(xRenderCreateSolidFillReq);
-    PanoramiXRes    *newPict;
-    int		    result = Success, j;
+    PanoramiXRes *newPict;
+    int result = Success, j;
 
     REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq);
 
-    if(!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
-	return BadAlloc;
+    if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
+        return BadAlloc;
 
     newPict->type = XRT_PICTURE;
     panoramix_setup_ids(newPict, client, stuff->pid);
     newPict->u.pict.root = FALSE;
-	
+
     FOR_NSCREENS_BACKWARD(j) {
-	stuff->pid = newPict->info[j].id;
-	result = (*PanoramiXSaveRenderVector[X_RenderCreateSolidFill]) (client);
-	if(result != Success) break;
+        stuff->pid = newPict->info[j].id;
+        result = (*PanoramiXSaveRenderVector[X_RenderCreateSolidFill]) (client);
+        if (result != Success)
+            break;
     }
 
     if (result == Success)
-	AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
+        AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
     else
-	free(newPict);
+        free(newPict);
 
     return result;
 }
 
 static int
-PanoramiXRenderCreateLinearGradient (ClientPtr client)
+PanoramiXRenderCreateLinearGradient(ClientPtr client)
 {
     REQUEST(xRenderCreateLinearGradientReq);
-    PanoramiXRes    *newPict;
-    int		    result = Success, j;
+    PanoramiXRes *newPict;
+    int result = Success, j;
 
     REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq);
 
-    if(!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
-	return BadAlloc;
+    if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
+        return BadAlloc;
 
     newPict->type = XRT_PICTURE;
     panoramix_setup_ids(newPict, client, stuff->pid);
     newPict->u.pict.root = FALSE;
 
     FOR_NSCREENS_BACKWARD(j) {
-	stuff->pid = newPict->info[j].id;
-	result = (*PanoramiXSaveRenderVector[X_RenderCreateLinearGradient]) (client);
-	if(result != Success) break;
+        stuff->pid = newPict->info[j].id;
+        result =
+            (*PanoramiXSaveRenderVector[X_RenderCreateLinearGradient]) (client);
+        if (result != Success)
+            break;
     }
 
     if (result == Success)
-	AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
+        AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
     else
-	free(newPict);
+        free(newPict);
 
     return result;
 }
 
 static int
-PanoramiXRenderCreateRadialGradient (ClientPtr client)
+PanoramiXRenderCreateRadialGradient(ClientPtr client)
 {
     REQUEST(xRenderCreateRadialGradientReq);
-    PanoramiXRes    *newPict;
-    int		    result = Success, j;
+    PanoramiXRes *newPict;
+    int result = Success, j;
 
     REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq);
 
-    if(!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
-	return BadAlloc;
+    if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
+        return BadAlloc;
 
     newPict->type = XRT_PICTURE;
     panoramix_setup_ids(newPict, client, stuff->pid);
     newPict->u.pict.root = FALSE;
 
     FOR_NSCREENS_BACKWARD(j) {
-	stuff->pid = newPict->info[j].id;
-	result = (*PanoramiXSaveRenderVector[X_RenderCreateRadialGradient]) (client);
-	if(result != Success) break;
+        stuff->pid = newPict->info[j].id;
+        result =
+            (*PanoramiXSaveRenderVector[X_RenderCreateRadialGradient]) (client);
+        if (result != Success)
+            break;
     }
 
     if (result == Success)
-	AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
+        AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
     else
-	free(newPict);
+        free(newPict);
 
     return result;
 }
 
 static int
-PanoramiXRenderCreateConicalGradient (ClientPtr client)
+PanoramiXRenderCreateConicalGradient(ClientPtr client)
 {
     REQUEST(xRenderCreateConicalGradientReq);
-    PanoramiXRes    *newPict;
-    int		    result = Success, j;
+    PanoramiXRes *newPict;
+    int result = Success, j;
 
     REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq);
 
-    if(!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
-	return BadAlloc;
+    if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
+        return BadAlloc;
 
     newPict->type = XRT_PICTURE;
     panoramix_setup_ids(newPict, client, stuff->pid);
     newPict->u.pict.root = FALSE;
 
     FOR_NSCREENS_BACKWARD(j) {
-	stuff->pid = newPict->info[j].id;
-	result = (*PanoramiXSaveRenderVector[X_RenderCreateConicalGradient]) (client);
-	if(result != Success) break;
+        stuff->pid = newPict->info[j].id;
+        result =
+            (*PanoramiXSaveRenderVector[X_RenderCreateConicalGradient])
+            (client);
+        if (result != Success)
+            break;
     }
 
     if (result == Success)
-	AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
+        AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
     else
-	free(newPict);
+        free(newPict);
 
     return result;
 }
 
 void
-PanoramiXRenderInit (void)
+PanoramiXRenderInit(void)
 {
-    int	    i;
-    
-    XRT_PICTURE = CreateNewResourceType (XineramaDeleteResource,
-					 "XineramaPicture");
+    int i;
+
+    XRT_PICTURE = CreateNewResourceType(XineramaDeleteResource,
+                                        "XineramaPicture");
     if (RenderErrBase)
-	SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture);
+        SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture);
     for (i = 0; i < RenderNumberRequests; i++)
-	PanoramiXSaveRenderVector[i] = ProcRenderVector[i];
+        PanoramiXSaveRenderVector[i] = ProcRenderVector[i];
     /*
      * Stuff in Xinerama aware request processing hooks
      */
     ProcRenderVector[X_RenderCreatePicture] = PanoramiXRenderCreatePicture;
     ProcRenderVector[X_RenderChangePicture] = PanoramiXRenderChangePicture;
-    ProcRenderVector[X_RenderSetPictureTransform] = PanoramiXRenderSetPictureTransform;
-    ProcRenderVector[X_RenderSetPictureFilter] = PanoramiXRenderSetPictureFilter;
-    ProcRenderVector[X_RenderSetPictureClipRectangles] = PanoramiXRenderSetPictureClipRectangles;
+    ProcRenderVector[X_RenderSetPictureTransform] =
+        PanoramiXRenderSetPictureTransform;
+    ProcRenderVector[X_RenderSetPictureFilter] =
+        PanoramiXRenderSetPictureFilter;
+    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_RenderCompositeGlyphs16] =
+        PanoramiXRenderCompositeGlyphs;
+    ProcRenderVector[X_RenderCompositeGlyphs32] =
+        PanoramiXRenderCompositeGlyphs;
     ProcRenderVector[X_RenderFillRectangles] = PanoramiXRenderFillRectangles;
 
     ProcRenderVector[X_RenderTrapezoids] = PanoramiXRenderTrapezoids;
@@ -3329,18 +3293,22 @@ PanoramiXRenderInit (void)
     ProcRenderVector[X_RenderAddTraps] = PanoramiXRenderAddTraps;
 
     ProcRenderVector[X_RenderCreateSolidFill] = PanoramiXRenderCreateSolidFill;
-    ProcRenderVector[X_RenderCreateLinearGradient] = PanoramiXRenderCreateLinearGradient;
-    ProcRenderVector[X_RenderCreateRadialGradient] = PanoramiXRenderCreateRadialGradient;
-    ProcRenderVector[X_RenderCreateConicalGradient] = PanoramiXRenderCreateConicalGradient;
+    ProcRenderVector[X_RenderCreateLinearGradient] =
+        PanoramiXRenderCreateLinearGradient;
+    ProcRenderVector[X_RenderCreateRadialGradient] =
+        PanoramiXRenderCreateRadialGradient;
+    ProcRenderVector[X_RenderCreateConicalGradient] =
+        PanoramiXRenderCreateConicalGradient;
 }
 
 void
-PanoramiXRenderReset (void)
+PanoramiXRenderReset(void)
 {
-    int	    i;
+    int i;
+
     for (i = 0; i < RenderNumberRequests; i++)
-	ProcRenderVector[i] = PanoramiXSaveRenderVector[i];
+        ProcRenderVector[i] = PanoramiXSaveRenderVector[i];
     RenderErrBase = 0;
 }
 
-#endif	/* PANORAMIX */
+#endif                          /* PANORAMIX */