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>

1 files changed, 814 insertions, 820 deletions

diff --git a/exa/exa_accel.c b/exa/exa_accel.c
index 5600539d6..0e948f414 100644
--- a/exa/exa_accel.c
+++ b/exa/exa_accel.c
@@ -37,48 +37,46 @@
 
 static void
 exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n,
-	     DDXPointPtr ppt, int *pwidth, int fSorted)
+             DDXPointPtr ppt, int *pwidth, int fSorted)
 {
-    ScreenPtr	    pScreen = pDrawable->pScreen;
-    ExaScreenPriv (pScreen);
-    RegionPtr	    pClip = fbGetCompositeClip(pGC);
-    PixmapPtr	    pPixmap = exaGetDrawablePixmap (pDrawable);
-    ExaPixmapPriv (pPixmap);
-    BoxPtr	    pextent, pbox;
-    int		    nbox;
-    int		    extentX1, extentX2, extentY1, extentY2;
-    int		    fullX1, fullX2, fullY1;
-    int		    partX1, partX2;
-    int		    off_x, off_y;
+    ScreenPtr pScreen = pDrawable->pScreen;
+
+    ExaScreenPriv(pScreen);
+    RegionPtr pClip = fbGetCompositeClip(pGC);
+    PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
+
+    ExaPixmapPriv(pPixmap);
+    BoxPtr pextent, pbox;
+    int nbox;
+    int extentX1, extentX2, extentY1, extentY2;
+    int fullX1, fullX2, fullY1;
+    int partX1, partX2;
+    int off_x, off_y;
 
     if (pExaScr->fallback_counter ||
-	pExaScr->swappedOut ||
-	pGC->fillStyle != FillSolid ||
-	pExaPixmap->accel_blocked)
-    {
-	ExaCheckFillSpans (pDrawable, pGC, n, ppt, pwidth, fSorted);
-	return;
+        pExaScr->swappedOut ||
+        pGC->fillStyle != FillSolid || pExaPixmap->accel_blocked) {
+        ExaCheckFillSpans(pDrawable, pGC, n, ppt, pwidth, fSorted);
+        return;
     }
 
     if (pExaScr->do_migration) {
-	ExaMigrationRec pixmaps[1];
+        ExaMigrationRec pixmaps[1];
 
-	pixmaps[0].as_dst = TRUE;
-	pixmaps[0].as_src = FALSE;
-	pixmaps[0].pPix = pPixmap;
-	pixmaps[0].pReg = NULL;
+        pixmaps[0].as_dst = TRUE;
+        pixmaps[0].as_src = FALSE;
+        pixmaps[0].pPix = pPixmap;
+        pixmaps[0].pReg = NULL;
 
-	exaDoMigration (pixmaps, 1, TRUE);
+        exaDoMigration(pixmaps, 1, TRUE);
     }
 
-    if (!(pPixmap = exaGetOffscreenPixmap (pDrawable, &off_x, &off_y)) ||
-	!(*pExaScr->info->PrepareSolid) (pPixmap,
-					 pGC->alu,
-					 pGC->planemask,
-					 pGC->fgPixel))
-    {
-	ExaCheckFillSpans (pDrawable, pGC, n, ppt, pwidth, fSorted);
-	return;
+    if (!(pPixmap = exaGetOffscreenPixmap(pDrawable, &off_x, &off_y)) ||
+        !(*pExaScr->info->PrepareSolid) (pPixmap,
+                                         pGC->alu,
+                                         pGC->planemask, pGC->fgPixel)) {
+        ExaCheckFillSpans(pDrawable, pGC, n, ppt, pwidth, fSorted);
+        return;
     }
 
     pextent = RegionExtents(pClip);
@@ -86,66 +84,63 @@ exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n,
     extentY1 = pextent->y1;
     extentX2 = pextent->x2;
     extentY2 = pextent->y2;
-    while (n--)
-    {
-	fullX1 = ppt->x;
-	fullY1 = ppt->y;
-	fullX2 = fullX1 + (int) *pwidth;
-	ppt++;
-	pwidth++;
-
-	if (fullY1 < extentY1 || extentY2 <= fullY1)
-	    continue;
-
-	if (fullX1 < extentX1)
-	    fullX1 = extentX1;
-
-	if (fullX2 > extentX2)
-	    fullX2 = extentX2;
-
-	if (fullX1 >= fullX2)
-	    continue;
-
-	nbox = RegionNumRects (pClip);
-	if (nbox == 1)
-	{
-	    (*pExaScr->info->Solid) (pPixmap,
-				     fullX1 + off_x, fullY1 + off_y,
-				     fullX2 + off_x, fullY1 + 1 + off_y);
-	}
-	else
-	{
-	    pbox = RegionRects(pClip);
-	    while(nbox--)
-	    {
-		if (pbox->y1 <= fullY1 && fullY1 < pbox->y2)
-		{
-		    partX1 = pbox->x1;
-		    if (partX1 < fullX1)
-			partX1 = fullX1;
-		    partX2 = pbox->x2;
-		    if (partX2 > fullX2)
-			partX2 = fullX2;
-		    if (partX2 > partX1) {
-			(*pExaScr->info->Solid) (pPixmap,
-						 partX1 + off_x, fullY1 + off_y,
-						 partX2 + off_x, fullY1 + 1 + off_y);
-		    }
-		}
-		pbox++;
-	    }
-	}
+    while (n--) {
+        fullX1 = ppt->x;
+        fullY1 = ppt->y;
+        fullX2 = fullX1 + (int) *pwidth;
+        ppt++;
+        pwidth++;
+
+        if (fullY1 < extentY1 || extentY2 <= fullY1)
+            continue;
+
+        if (fullX1 < extentX1)
+            fullX1 = extentX1;
+
+        if (fullX2 > extentX2)
+            fullX2 = extentX2;
+
+        if (fullX1 >= fullX2)
+            continue;
+
+        nbox = RegionNumRects(pClip);
+        if (nbox == 1) {
+            (*pExaScr->info->Solid) (pPixmap,
+                                     fullX1 + off_x, fullY1 + off_y,
+                                     fullX2 + off_x, fullY1 + 1 + off_y);
+        }
+        else {
+            pbox = RegionRects(pClip);
+            while (nbox--) {
+                if (pbox->y1 <= fullY1 && fullY1 < pbox->y2) {
+                    partX1 = pbox->x1;
+                    if (partX1 < fullX1)
+                        partX1 = fullX1;
+                    partX2 = pbox->x2;
+                    if (partX2 > fullX2)
+                        partX2 = fullX2;
+                    if (partX2 > partX1) {
+                        (*pExaScr->info->Solid) (pPixmap,
+                                                 partX1 + off_x, fullY1 + off_y,
+                                                 partX2 + off_x,
+                                                 fullY1 + 1 + off_y);
+                    }
+                }
+                pbox++;
+            }
+        }
     }
     (*pExaScr->info->DoneSolid) (pPixmap);
     exaMarkSync(pScreen);
 }
 
 static Bool
-exaDoPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
-	       int w, int h, int format, char *bits, int src_stride)
+exaDoPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
+              int w, int h, int format, char *bits, int src_stride)
 {
-    ExaScreenPriv (pDrawable->pScreen);
-    PixmapPtr pPix = exaGetDrawablePixmap (pDrawable);
+    ExaScreenPriv(pDrawable->pScreen);
+    PixmapPtr pPix = exaGetDrawablePixmap(pDrawable);
+
     ExaPixmapPriv(pPix);
     RegionPtr pClip;
     BoxPtr pbox;
@@ -154,284 +149,280 @@ exaDoPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
     int bpp = pDrawable->bitsPerPixel;
     Bool ret = TRUE;
 
-    if (pExaScr->fallback_counter || pExaPixmap->accel_blocked || !pExaScr->info->UploadToScreen)
-	return FALSE;
+    if (pExaScr->fallback_counter || pExaPixmap->accel_blocked ||
+        !pExaScr->info->UploadToScreen)
+        return FALSE;
 
     /* If there's a system copy, we want to save the result there */
     if (pExaPixmap->pDamage)
-	return FALSE;
+        return FALSE;
 
     /* Don't bother with under 8bpp, XYPixmaps. */
     if (format != ZPixmap || bpp < 8)
-	return FALSE;
+        return FALSE;
 
     /* Only accelerate copies: no rop or planemask. */
     if (!EXA_PM_IS_SOLID(pDrawable, pGC->planemask) || pGC->alu != GXcopy)
-	return FALSE;
+        return FALSE;
 
     if (pExaScr->swappedOut)
-	return FALSE;
+        return FALSE;
 
     if (pExaScr->do_migration) {
-	ExaMigrationRec pixmaps[1];
+        ExaMigrationRec pixmaps[1];
 
-	pixmaps[0].as_dst = TRUE;
-	pixmaps[0].as_src = FALSE;
-	pixmaps[0].pPix = pPix;
-	pixmaps[0].pReg = DamagePendingRegion(pExaPixmap->pDamage);
+        pixmaps[0].as_dst = TRUE;
+        pixmaps[0].as_src = FALSE;
+        pixmaps[0].pPix = pPix;
+        pixmaps[0].pReg = DamagePendingRegion(pExaPixmap->pDamage);
 
-	exaDoMigration (pixmaps, 1, TRUE);
+        exaDoMigration(pixmaps, 1, TRUE);
     }
 
-    pPix = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff);
+    pPix = exaGetOffscreenPixmap(pDrawable, &xoff, &yoff);
 
     if (!pPix)
-	return FALSE;
+        return FALSE;
 
     x += pDrawable->x;
     y += pDrawable->y;
 
     pClip = fbGetCompositeClip(pGC);
     for (nbox = RegionNumRects(pClip),
-	 pbox = RegionRects(pClip);
-	 nbox--;
-	 pbox++)
-    {
-	int x1 = x;
-	int y1 = y;
-	int x2 = x + w;
-	int y2 = y + h;
-	char *src;
-	Bool ok;
-
-	if (x1 < pbox->x1)
-	    x1 = pbox->x1;
-	if (y1 < pbox->y1)
-	    y1 = pbox->y1;
-	if (x2 > pbox->x2)
-	    x2 = pbox->x2;
-	if (y2 > pbox->y2)
-	    y2 = pbox->y2;
-	if (x1 >= x2 || y1 >= y2)
-	    continue;
-
-	src = bits + (y1 - y) * src_stride + (x1 - x) * (bpp / 8);
-	ok = pExaScr->info->UploadToScreen(pPix, x1 + xoff, y1 + yoff,
-					   x2 - x1, y2 - y1, src, src_stride);
-	/* We have to fall back completely, and ignore what has already been completed.
-	 * Messing with the fb layer directly like we used to is completely unacceptable.
-	 */
-	if (!ok) {
-	    ret = FALSE;
-	    break;
-	}
+         pbox = RegionRects(pClip); nbox--; pbox++) {
+        int x1 = x;
+        int y1 = y;
+        int x2 = x + w;
+        int y2 = y + h;
+        char *src;
+        Bool ok;
+
+        if (x1 < pbox->x1)
+            x1 = pbox->x1;
+        if (y1 < pbox->y1)
+            y1 = pbox->y1;
+        if (x2 > pbox->x2)
+            x2 = pbox->x2;
+        if (y2 > pbox->y2)
+            y2 = pbox->y2;
+        if (x1 >= x2 || y1 >= y2)
+            continue;
+
+        src = bits + (y1 - y) * src_stride + (x1 - x) * (bpp / 8);
+        ok = pExaScr->info->UploadToScreen(pPix, x1 + xoff, y1 + yoff,
+                                           x2 - x1, y2 - y1, src, src_stride);
+        /* We have to fall back completely, and ignore what has already been completed.
+         * Messing with the fb layer directly like we used to is completely unacceptable.
+         */
+        if (!ok) {
+            ret = FALSE;
+            break;
+        }
     }
 
     if (ret)
-	exaMarkSync(pDrawable->pScreen);
+        exaMarkSync(pDrawable->pScreen);
 
     return ret;
 }
 
 static void
-exaPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
-	     int w, int h, int leftPad, int format, char *bits)
+exaPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
+            int w, int h, int leftPad, int format, char *bits)
 {
     if (!exaDoPutImage(pDrawable, pGC, depth, x, y, w, h, format, bits,
-		       PixmapBytePad(w, pDrawable->depth)))
-	ExaCheckPutImage(pDrawable, pGC, depth, x, y, w, h, leftPad, format,
-			 bits);
+                       PixmapBytePad(w, pDrawable->depth)))
+        ExaCheckPutImage(pDrawable, pGC, depth, x, y, w, h, leftPad, format,
+                         bits);
 }
 
 static Bool inline
-exaCopyNtoNTwoDir (DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
-		   GCPtr pGC, BoxPtr pbox, int nbox, int dx, int dy)
+exaCopyNtoNTwoDir(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
+                  GCPtr pGC, BoxPtr pbox, int nbox, int dx, int dy)
 {
-    ExaScreenPriv (pDstDrawable->pScreen);
+    ExaScreenPriv(pDstDrawable->pScreen);
     PixmapPtr pSrcPixmap, pDstPixmap;
     int src_off_x, src_off_y, dst_off_x, dst_off_y;
     int dirsetup;
 
     /* Need to get both pixmaps to call the driver routines */
-    pSrcPixmap = exaGetOffscreenPixmap (pSrcDrawable, &src_off_x, &src_off_y);
-    pDstPixmap = exaGetOffscreenPixmap (pDstDrawable, &dst_off_x, &dst_off_y);
+    pSrcPixmap = exaGetOffscreenPixmap(pSrcDrawable, &src_off_x, &src_off_y);
+    pDstPixmap = exaGetOffscreenPixmap(pDstDrawable, &dst_off_x, &dst_off_y);
     if (!pSrcPixmap || !pDstPixmap)
-	return FALSE;
+        return FALSE;
 
     /*
      * Now the case of a chip that only supports xdir = ydir = 1 or
      * xdir = ydir = -1, but we have xdir != ydir.
      */
-    dirsetup = 0;	/* No direction set up yet. */
+    dirsetup = 0;               /* No direction set up yet. */
     for (; nbox; pbox++, nbox--) {
-	if (dx >= 0 && (src_off_y + pbox->y1 + dy) != pbox->y1) {
-	    /* Do a xdir = ydir = -1 blit instead. */
-	    if (dirsetup != -1) {
-		if (dirsetup != 0)
-		    pExaScr->info->DoneCopy(pDstPixmap);
-		dirsetup = -1;
-		if (!(*pExaScr->info->PrepareCopy)(pSrcPixmap,
-						   pDstPixmap,
-						   -1, -1,
-						   pGC ? pGC->alu : GXcopy,
-						   pGC ? pGC->planemask :
-							 FB_ALLONES))
-		    return FALSE;
-	    }
-	    (*pExaScr->info->Copy)(pDstPixmap,
-				   src_off_x + pbox->x1 + dx,
-				   src_off_y + pbox->y1 + dy,
-				   dst_off_x + pbox->x1,
-				   dst_off_y + pbox->y1,
-				   pbox->x2 - pbox->x1,
-				   pbox->y2 - pbox->y1);
-	} else if (dx < 0 && (src_off_y + pbox->y1 + dy) != pbox->y1) {
-	    /* Do a xdir = ydir = 1 blit instead. */
-	    if (dirsetup != 1) {
-		if (dirsetup != 0)
-		    pExaScr->info->DoneCopy(pDstPixmap);
-		dirsetup = 1;
-		if (!(*pExaScr->info->PrepareCopy)(pSrcPixmap,
-						   pDstPixmap,
-						   1, 1,
-						   pGC ? pGC->alu : GXcopy,
-						   pGC ? pGC->planemask :
-							 FB_ALLONES))
-		    return FALSE;
-	    }
-	    (*pExaScr->info->Copy)(pDstPixmap,
-				   src_off_x + pbox->x1 + dx,
-				   src_off_y + pbox->y1 + dy,
-				   dst_off_x + pbox->x1,
-				   dst_off_y + pbox->y1,
-				   pbox->x2 - pbox->x1,
-				   pbox->y2 - pbox->y1);
-	} else if (dx >= 0) {
-	    /*
-	     * xdir = 1, ydir = -1.
-	     * Perform line-by-line xdir = ydir = 1 blits, going up.
-	     */
-	    int i;
-	    if (dirsetup != 1) {
-		if (dirsetup != 0)
-		    pExaScr->info->DoneCopy(pDstPixmap);
-		dirsetup = 1;
-		if (!(*pExaScr->info->PrepareCopy)(pSrcPixmap,
-						   pDstPixmap,
-						   1, 1,
-						   pGC ? pGC->alu : GXcopy,
-						   pGC ? pGC->planemask :
-							 FB_ALLONES))
-		    return FALSE;
-	    }
-	    for (i = pbox->y2 - pbox->y1 - 1; i >= 0; i--)
-		(*pExaScr->info->Copy)(pDstPixmap,
-				       src_off_x + pbox->x1 + dx,
-				       src_off_y + pbox->y1 + dy + i,
-				       dst_off_x + pbox->x1,
-				       dst_off_y + pbox->y1 + i,
-				       pbox->x2 - pbox->x1, 1);
-	} else {
-	    /*
-	     * xdir = -1, ydir = 1.
-	     * Perform line-by-line xdir = ydir = -1 blits, going down.
-	     */
-	    int i;
-	    if (dirsetup != -1) {
-		if (dirsetup != 0)
-		    pExaScr->info->DoneCopy(pDstPixmap);
-		dirsetup = -1;
-		if (!(*pExaScr->info->PrepareCopy)(pSrcPixmap,
-						   pDstPixmap,
-						   -1, -1,
-						   pGC ? pGC->alu : GXcopy,
-						   pGC ? pGC->planemask :
-							 FB_ALLONES))
-		    return FALSE;
-	    }
-	    for (i = 0; i < pbox->y2 - pbox->y1; i++)
-		(*pExaScr->info->Copy)(pDstPixmap,
-				       src_off_x + pbox->x1 + dx,
-				       src_off_y + pbox->y1 + dy + i,
-				       dst_off_x + pbox->x1,
-				       dst_off_y + pbox->y1 + i,
-				       pbox->x2 - pbox->x1, 1);
-	}
+        if (dx >= 0 && (src_off_y + pbox->y1 + dy) != pbox->y1) {
+            /* Do a xdir = ydir = -1 blit instead. */
+            if (dirsetup != -1) {
+                if (dirsetup != 0)
+                    pExaScr->info->DoneCopy(pDstPixmap);
+                dirsetup = -1;
+                if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap,
+                                                    pDstPixmap,
+                                                    -1, -1,
+                                                    pGC ? pGC->alu : GXcopy,
+                                                    pGC ? pGC->planemask :
+                                                    FB_ALLONES))
+                    return FALSE;
+            }
+            (*pExaScr->info->Copy) (pDstPixmap,
+                                    src_off_x + pbox->x1 + dx,
+                                    src_off_y + pbox->y1 + dy,
+                                    dst_off_x + pbox->x1,
+                                    dst_off_y + pbox->y1,
+                                    pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);
+        }
+        else if (dx < 0 && (src_off_y + pbox->y1 + dy) != pbox->y1) {
+            /* Do a xdir = ydir = 1 blit instead. */
+            if (dirsetup != 1) {
+                if (dirsetup != 0)
+                    pExaScr->info->DoneCopy(pDstPixmap);
+                dirsetup = 1;
+                if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap,
+                                                    pDstPixmap,
+                                                    1, 1,
+                                                    pGC ? pGC->alu : GXcopy,
+                                                    pGC ? pGC->planemask :
+                                                    FB_ALLONES))
+                    return FALSE;
+            }
+            (*pExaScr->info->Copy) (pDstPixmap,
+                                    src_off_x + pbox->x1 + dx,
+                                    src_off_y + pbox->y1 + dy,
+                                    dst_off_x + pbox->x1,
+                                    dst_off_y + pbox->y1,
+                                    pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);
+        }
+        else if (dx >= 0) {
+            /*
+             * xdir = 1, ydir = -1.
+             * Perform line-by-line xdir = ydir = 1 blits, going up.
+             */
+            int i;
+
+            if (dirsetup != 1) {
+                if (dirsetup != 0)
+                    pExaScr->info->DoneCopy(pDstPixmap);
+                dirsetup = 1;
+                if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap,
+                                                    pDstPixmap,
+                                                    1, 1,
+                                                    pGC ? pGC->alu : GXcopy,
+                                                    pGC ? pGC->planemask :
+                                                    FB_ALLONES))
+                    return FALSE;
+            }
+            for (i = pbox->y2 - pbox->y1 - 1; i >= 0; i--)
+                (*pExaScr->info->Copy) (pDstPixmap,
+                                        src_off_x + pbox->x1 + dx,
+                                        src_off_y + pbox->y1 + dy + i,
+                                        dst_off_x + pbox->x1,
+                                        dst_off_y + pbox->y1 + i,
+                                        pbox->x2 - pbox->x1, 1);
+        }
+        else {
+            /*
+             * xdir = -1, ydir = 1.
+             * Perform line-by-line xdir = ydir = -1 blits, going down.
+             */
+            int i;
+
+            if (dirsetup != -1) {
+                if (dirsetup != 0)
+                    pExaScr->info->DoneCopy(pDstPixmap);
+                dirsetup = -1;
+                if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap,
+                                                    pDstPixmap,
+                                                    -1, -1,
+                                                    pGC ? pGC->alu : GXcopy,
+                                                    pGC ? pGC->planemask :
+                                                    FB_ALLONES))
+                    return FALSE;
+            }
+            for (i = 0; i < pbox->y2 - pbox->y1; i++)
+                (*pExaScr->info->Copy) (pDstPixmap,
+                                        src_off_x + pbox->x1 + dx,
+                                        src_off_y + pbox->y1 + dy + i,
+                                        dst_off_x + pbox->x1,
+                                        dst_off_y + pbox->y1 + i,
+                                        pbox->x2 - pbox->x1, 1);
+        }
     }
     if (dirsetup != 0)
-	pExaScr->info->DoneCopy(pDstPixmap);
+        pExaScr->info->DoneCopy(pDstPixmap);
     exaMarkSync(pDstDrawable->pScreen);
     return TRUE;
 }
 
 Bool
-exaHWCopyNtoN (DrawablePtr    pSrcDrawable,
-	     DrawablePtr    pDstDrawable,
-	     GCPtr	    pGC,
-	     BoxPtr	    pbox,
-	     int	    nbox,
-	     int	    dx,
-	     int	    dy,
-	     Bool	    reverse,
-	     Bool	    upsidedown)
+exaHWCopyNtoN(DrawablePtr pSrcDrawable,
+              DrawablePtr pDstDrawable,
+              GCPtr pGC,
+              BoxPtr pbox,
+              int nbox, int dx, int dy, Bool reverse, Bool upsidedown)
 {
-    ExaScreenPriv (pDstDrawable->pScreen);
+    ExaScreenPriv(pDstDrawable->pScreen);
     PixmapPtr pSrcPixmap, pDstPixmap;
     ExaPixmapPrivPtr pSrcExaPixmap, pDstExaPixmap;
-    int	    src_off_x, src_off_y;
-    int	    dst_off_x, dst_off_y;
+    int src_off_x, src_off_y;
+    int dst_off_x, dst_off_y;
     RegionPtr srcregion = NULL, dstregion = NULL;
     xRectangle *rects;
     Bool ret = TRUE;
 
     /* avoid doing copy operations if no boxes */
     if (nbox == 0)
-	return TRUE;
+        return TRUE;
 
-    pSrcPixmap = exaGetDrawablePixmap (pSrcDrawable);
-    pDstPixmap = exaGetDrawablePixmap (pDstDrawable);
+    pSrcPixmap = exaGetDrawablePixmap(pSrcDrawable);
+    pDstPixmap = exaGetDrawablePixmap(pDstDrawable);
 
-    exaGetDrawableDeltas (pSrcDrawable, pSrcPixmap, &src_off_x, &src_off_y);
-    exaGetDrawableDeltas (pDstDrawable, pDstPixmap, &dst_off_x, &dst_off_y);
+    exaGetDrawableDeltas(pSrcDrawable, pSrcPixmap, &src_off_x, &src_off_y);
+    exaGetDrawableDeltas(pDstDrawable, pDstPixmap, &dst_off_x, &dst_off_y);
 
     rects = malloc(nbox * sizeof(xRectangle));
 
     if (rects) {
-	int i;
-	int ordering;
-
-	for (i = 0; i < nbox; i++) {
-	    rects[i].x = pbox[i].x1 + dx + src_off_x;
-	    rects[i].y = pbox[i].y1 + dy + src_off_y;
-	    rects[i].width = pbox[i].x2 - pbox[i].x1;
-	    rects[i].height = pbox[i].y2 - pbox[i].y1;
-	}
-
-	/* This must match the RegionCopy() logic for reversing rect order */
-	if (nbox == 1 || (dx > 0 && dy > 0) ||
-	    (pDstDrawable != pSrcDrawable &&
-	     (pDstDrawable->type != DRAWABLE_WINDOW ||
-	      pSrcDrawable->type != DRAWABLE_WINDOW)))
-	    ordering = CT_YXBANDED;
-	else
-	    ordering = CT_UNSORTED;
-
-	srcregion  = RegionFromRects(nbox, rects, ordering);
-	free(rects);
-
-	if (!pGC || !exaGCReadsDestination(pDstDrawable, pGC->planemask,
-					   pGC->fillStyle, pGC->alu,
-					   pGC->clientClipType)) {
-	    dstregion = RegionCreate(NullBox, 0);
-	    RegionCopy(dstregion, srcregion);
-	    RegionTranslate(dstregion, dst_off_x - dx - src_off_x,
-			     dst_off_y - dy - src_off_y);
-	}
-    }
+        int i;
+        int ordering;
+
+        for (i = 0; i < nbox; i++) {
+            rects[i].x = pbox[i].x1 + dx + src_off_x;
+            rects[i].y = pbox[i].y1 + dy + src_off_y;
+            rects[i].width = pbox[i].x2 - pbox[i].x1;
+            rects[i].height = pbox[i].y2 - pbox[i].y1;
+        }
 
+        /* This must match the RegionCopy() logic for reversing rect order */
+        if (nbox == 1 || (dx > 0 && dy > 0) ||
+            (pDstDrawable != pSrcDrawable &&
+             (pDstDrawable->type != DRAWABLE_WINDOW ||
+              pSrcDrawable->type != DRAWABLE_WINDOW)))
+            ordering = CT_YXBANDED;
+        else
+            ordering = CT_UNSORTED;
+
+        srcregion = RegionFromRects(nbox, rects, ordering);
+        free(rects);
+
+        if (!pGC || !exaGCReadsDestination(pDstDrawable, pGC->planemask,
+                                           pGC->fillStyle, pGC->alu,
+                                           pGC->clientClipType)) {
+            dstregion = RegionCreate(NullBox, 0);
+            RegionCopy(dstregion, srcregion);
+            RegionTranslate(dstregion, dst_off_x - dx - src_off_x,
+                            dst_off_y - dy - src_off_y);
+        }
+    }
 
-    pSrcExaPixmap = ExaGetPixmapPriv (pSrcPixmap);
-    pDstExaPixmap = ExaGetPixmapPriv (pDstPixmap);
+    pSrcExaPixmap = ExaGetPixmapPriv(pSrcPixmap);
+    pDstExaPixmap = ExaGetPixmapPriv(pDstPixmap);
 
     /* Check whether the accelerator can use this pixmap.
      * If the pitch of the pixmaps is out of range, there's nothing
@@ -439,7 +430,7 @@ exaHWCopyNtoN (DrawablePtr    pSrcDrawable,
      */
     if (pSrcExaPixmap->accel_blocked & EXA_RANGE_PITCH ||
         pDstExaPixmap->accel_blocked & EXA_RANGE_PITCH)
-	goto fallback;
+        goto fallback;
 
     /* If the width or the height of either of the pixmaps
      * is out of range, check whether the boxes are actually out of the
@@ -463,158 +454,167 @@ exaHWCopyNtoN (DrawablePtr    pSrcDrawable,
     }
 
     if (pExaScr->do_migration) {
-	ExaMigrationRec pixmaps[2];
-
-	pixmaps[0].as_dst = TRUE;
-	pixmaps[0].as_src = FALSE;
-	pixmaps[0].pPix = pDstPixmap;
-	pixmaps[0].pReg = dstregion;
-	pixmaps[1].as_dst = FALSE;
-	pixmaps[1].as_src = TRUE;
-	pixmaps[1].pPix = pSrcPixmap;
-	pixmaps[1].pReg = srcregion;
-
-	exaDoMigration (pixmaps, 2, TRUE);
+        ExaMigrationRec pixmaps[2];
+
+        pixmaps[0].as_dst = TRUE;
+        pixmaps[0].as_src = FALSE;
+        pixmaps[0].pPix = pDstPixmap;
+        pixmaps[0].pReg = dstregion;
+        pixmaps[1].as_dst = FALSE;
+        pixmaps[1].as_src = TRUE;
+        pixmaps[1].pPix = pSrcPixmap;
+        pixmaps[1].pReg = srcregion;
+
+        exaDoMigration(pixmaps, 2, TRUE);
     }
 
     /* Mixed directions must be handled specially if the card is lame */
     if ((pExaScr->info->flags & EXA_TWO_BITBLT_DIRECTIONS) &&
-	reverse != upsidedown) {
-	if (exaCopyNtoNTwoDir(pSrcDrawable, pDstDrawable, pGC, pbox, nbox,
-			       dx, dy))
-	    goto out;
-	goto fallback;
+        reverse != upsidedown) {
+        if (exaCopyNtoNTwoDir(pSrcDrawable, pDstDrawable, pGC, pbox, nbox,
+                              dx, dy))
+            goto out;
+        goto fallback;
     }
 
     if (exaPixmapHasGpuCopy(pDstPixmap)) {
-	/* Normal blitting. */
-	if (exaPixmapHasGpuCopy(pSrcPixmap)) {
-	    if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap, pDstPixmap, reverse ? -1 : 1,
-						upsidedown ? -1 : 1,
-						pGC ? pGC->alu : GXcopy,
-						pGC ? pGC->planemask : FB_ALLONES)) {
-		goto fallback;
-	    }
-
-	    while (nbox--)
-	    {
-		(*pExaScr->info->Copy) (pDstPixmap,
-					pbox->x1 + dx + src_off_x,
-					pbox->y1 + dy + src_off_y,
-					pbox->x1 + dst_off_x, pbox->y1 + dst_off_y,
-					pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);
-		pbox++;
-	    }
-
-	    (*pExaScr->info->DoneCopy) (pDstPixmap);
-	    exaMarkSync (pDstDrawable->pScreen);
-	/* UTS: mainly for SHM PutImage's secondary path.
-	 *
-	 * Only taking this path for directly accessible pixmaps.
-	 */
-	} else if (!pDstExaPixmap->pDamage && pSrcExaPixmap->sys_ptr) {
-	    int bpp = pSrcDrawable->bitsPerPixel;
-	    int src_stride = exaGetPixmapPitch(pSrcPixmap);
-	    CARD8 *src = NULL;
-
-	    if (!pExaScr->info->UploadToScreen)
-		goto fallback;
-
-	    if (pSrcDrawable->bitsPerPixel != pDstDrawable->bitsPerPixel)
-		goto fallback;
-
-	    if (pSrcDrawable->bitsPerPixel < 8)
-		goto fallback;
-
-	    if (pGC && !(pGC->alu == GXcopy && EXA_PM_IS_SOLID(pSrcDrawable,  pGC->planemask)))
-		goto fallback;
-
-	    while (nbox--)
-	    {
-		src = pSrcExaPixmap->sys_ptr + (pbox->y1 + dy + src_off_y) * src_stride + (pbox->x1 + dx + src_off_x) * (bpp / 8);
-		if (!pExaScr->info->UploadToScreen(pDstPixmap, pbox->x1 + dst_off_x,
-				pbox->y1 + dst_off_y, pbox->x2 - pbox->x1, pbox->y2 - pbox->y1,
-				(char *) src, src_stride))
-		    goto fallback;
-
-		pbox++;
-	    }
-	} else
-	    goto fallback;
-    } else
-	goto fallback;
+        /* Normal blitting. */
+        if (exaPixmapHasGpuCopy(pSrcPixmap)) {
+            if (!(*pExaScr->info->PrepareCopy)
+                (pSrcPixmap, pDstPixmap, reverse ? -1 : 1, upsidedown ? -1 : 1,
+                 pGC ? pGC->alu : GXcopy, pGC ? pGC->planemask : FB_ALLONES)) {
+                goto fallback;
+            }
+
+            while (nbox--) {
+                (*pExaScr->info->Copy) (pDstPixmap,
+                                        pbox->x1 + dx + src_off_x,
+                                        pbox->y1 + dy + src_off_y,
+                                        pbox->x1 + dst_off_x,
+                                        pbox->y1 + dst_off_y,
+                                        pbox->x2 - pbox->x1,
+                                        pbox->y2 - pbox->y1);
+                pbox++;
+            }
+
+            (*pExaScr->info->DoneCopy) (pDstPixmap);
+            exaMarkSync(pDstDrawable->pScreen);
+            /* UTS: mainly for SHM PutImage's secondary path.
+             *
+             * Only taking this path for directly accessible pixmaps.
+             */
+        }
+        else if (!pDstExaPixmap->pDamage && pSrcExaPixmap->sys_ptr) {
+            int bpp = pSrcDrawable->bitsPerPixel;
+            int src_stride = exaGetPixmapPitch(pSrcPixmap);
+            CARD8 *src = NULL;
+
+            if (!pExaScr->info->UploadToScreen)
+                goto fallback;
+
+            if (pSrcDrawable->bitsPerPixel != pDstDrawable->bitsPerPixel)
+                goto fallback;
+
+            if (pSrcDrawable->bitsPerPixel < 8)
+                goto fallback;
+
+            if (pGC &&
+                !(pGC->alu == GXcopy &&
+                  EXA_PM_IS_SOLID(pSrcDrawable, pGC->planemask)))
+                goto fallback;
+
+            while (nbox--) {
+                src =
+                    pSrcExaPixmap->sys_ptr + (pbox->y1 + dy +
+                                              src_off_y) * src_stride +
+                    (pbox->x1 + dx + src_off_x) * (bpp / 8);
+                if (!pExaScr->info->
+                    UploadToScreen(pDstPixmap, pbox->x1 + dst_off_x,
+                                   pbox->y1 + dst_off_y, pbox->x2 - pbox->x1,
+                                   pbox->y2 - pbox->y1, (char *) src,
+                                   src_stride))
+                    goto fallback;
+
+                pbox++;
+            }
+        }
+        else
+            goto fallback;
+    }
+    else
+        goto fallback;
 
     goto out;
 
-fallback:
+ fallback:
     ret = FALSE;
 
-out:
+ out:
     if (dstregion) {
-	RegionUninit(dstregion);
-	RegionDestroy(dstregion);
+        RegionUninit(dstregion);
+        RegionDestroy(dstregion);
     }
     if (srcregion) {
-	RegionUninit(srcregion);
-	RegionDestroy(srcregion);
+        RegionUninit(srcregion);
+        RegionDestroy(srcregion);
     }
 
     return ret;
 }
 
 void
-exaCopyNtoN (DrawablePtr    pSrcDrawable,
-	     DrawablePtr    pDstDrawable,
-	     GCPtr	    pGC,
-	     BoxPtr	    pbox,
-	     int	    nbox,
-	     int	    dx,
-	     int	    dy,
-	     Bool	    reverse,
-	     Bool	    upsidedown,
-	     Pixel	    bitplane,
-	     void	    *closure)
+exaCopyNtoN(DrawablePtr pSrcDrawable,
+            DrawablePtr pDstDrawable,
+            GCPtr pGC,
+            BoxPtr pbox,
+            int nbox,
+            int dx,
+            int dy,
+            Bool reverse, Bool upsidedown, Pixel bitplane, void *closure)
 {
     ExaScreenPriv(pDstDrawable->pScreen);
 
     if (pExaScr->fallback_counter ||
-	    (pExaScr->fallback_flags & EXA_FALLBACK_COPYWINDOW))
-	return;
+        (pExaScr->fallback_flags & EXA_FALLBACK_COPYWINDOW))
+        return;
 
-    if (exaHWCopyNtoN(pSrcDrawable, pDstDrawable, pGC, pbox, nbox, dx, dy, reverse, upsidedown))
-	return;
+    if (exaHWCopyNtoN
+        (pSrcDrawable, pDstDrawable, pGC, pbox, nbox, dx, dy, reverse,
+         upsidedown))
+        return;
 
     /* This is a CopyWindow, it's cleaner to fallback at the original call. */
     if (pExaScr->fallback_flags & EXA_ACCEL_COPYWINDOW) {
-	pExaScr->fallback_flags |= EXA_FALLBACK_COPYWINDOW;
-	return;
+        pExaScr->fallback_flags |= EXA_FALLBACK_COPYWINDOW;
+        return;
     }
 
     /* fallback */
-    ExaCheckCopyNtoN(pSrcDrawable, pDstDrawable, pGC, pbox, nbox, dx, dy, reverse, upsidedown, bitplane, closure);
+    ExaCheckCopyNtoN(pSrcDrawable, pDstDrawable, pGC, pbox, nbox, dx, dy,
+                     reverse, upsidedown, bitplane, closure);
 }
 
 RegionPtr
 exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
-	    int srcx, int srcy, int width, int height, int dstx, int dsty)
+            int srcx, int srcy, int width, int height, int dstx, int dsty)
 {
-    ExaScreenPriv (pDstDrawable->pScreen);
+    ExaScreenPriv(pDstDrawable->pScreen);
 
     if (pExaScr->fallback_counter || pExaScr->swappedOut) {
-        return  ExaCheckCopyArea(pSrcDrawable, pDstDrawable, pGC,
-                                 srcx, srcy, width, height, dstx, dsty);
+        return ExaCheckCopyArea(pSrcDrawable, pDstDrawable, pGC,
+                                srcx, srcy, width, height, dstx, dsty);
     }
 
-    return  miDoCopy (pSrcDrawable, pDstDrawable, pGC,
-                      srcx, srcy, width, height,
-                      dstx, dsty, exaCopyNtoN, 0, NULL);
+    return miDoCopy(pSrcDrawable, pDstDrawable, pGC,
+                    srcx, srcy, width, height,
+                    dstx, dsty, exaCopyNtoN, 0, NULL);
 }
 
 static void
 exaPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
-	     DDXPointPtr ppt)
+             DDXPointPtr ppt)
 {
-    ExaScreenPriv (pDrawable->pScreen);
+    ExaScreenPriv(pDrawable->pScreen);
     int i;
     xRectangle *prect;
 
@@ -622,20 +622,20 @@ exaPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
      * points.
      */
     if (pExaScr->fallback_counter || pGC->fillStyle != FillSolid) {
-	ExaCheckPolyPoint(pDrawable, pGC, mode, npt, ppt);
-	return;
+        ExaCheckPolyPoint(pDrawable, pGC, mode, npt, ppt);
+        return;
     }
 
     prect = malloc(sizeof(xRectangle) * npt);
     for (i = 0; i < npt; i++) {
-	prect[i].x = ppt[i].x;
-	prect[i].y = ppt[i].y;
-	if (i > 0 && mode == CoordModePrevious) {
-	    prect[i].x += prect[i - 1].x;
-	    prect[i].y += prect[i - 1].y;
-	}
-	prect[i].width = 1;
-	prect[i].height = 1;
+        prect[i].x = ppt[i].x;
+        prect[i].y = ppt[i].y;
+        if (i > 0 && mode == CoordModePrevious) {
+            prect[i].x += prect[i - 1].x;
+            prect[i].y += prect[i - 1].y;
+        }
+        prect[i].width = 1;
+        prect[i].height = 1;
     }
     pGC->ops->PolyFillRect(pDrawable, pGC, npt, prect);
     free(prect);
@@ -648,23 +648,23 @@ exaPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
  */
 static void
 exaPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
-	     DDXPointPtr ppt)
+             DDXPointPtr ppt)
 {
-    ExaScreenPriv (pDrawable->pScreen);
+    ExaScreenPriv(pDrawable->pScreen);
     xRectangle *prect;
     int x1, x2, y1, y2;
     int i;
 
     if (pExaScr->fallback_counter) {
-	ExaCheckPolylines(pDrawable, pGC, mode, npt, ppt);
-	return;
+        ExaCheckPolylines(pDrawable, pGC, mode, npt, ppt);
+        return;
     }
 
     /* Don't try to do wide lines or non-solid fill style. */
     if (pGC->lineWidth != 0 || pGC->lineStyle != LineSolid ||
-	pGC->fillStyle != FillSolid) {
-	ExaCheckPolylines(pDrawable, pGC, mode, npt, ppt);
-	return;
+        pGC->fillStyle != FillSolid) {
+        ExaCheckPolylines(pDrawable, pGC, mode, npt, ppt);
+        return;
     }
 
     prect = malloc(sizeof(xRectangle) * (npt - 1));
@@ -672,37 +672,40 @@ exaPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
     y1 = ppt[0].y;
     /* If we have any non-horizontal/vertical, fall back. */
     for (i = 0; i < npt - 1; i++) {
-	if (mode == CoordModePrevious) {
-	    x2 = x1 + ppt[i + 1].x;
-	    y2 = y1 + ppt[i + 1].y;
-	} else {
-	    x2 = ppt[i + 1].x;
-	    y2 = ppt[i + 1].y;
-	}
-
-	if (x1 != x2 && y1 != y2) {
-	    free(prect);
-	    ExaCheckPolylines(pDrawable, pGC, mode, npt, ppt);
-	    return;
-	}
-
-	if (x1 < x2) {
-	    prect[i].x = x1;
-	    prect[i].width = x2 - x1 + 1;
-	} else {
-	    prect[i].x = x2;
-	    prect[i].width = x1 - x2 + 1;
-	}
-	if (y1 < y2) {
-	    prect[i].y = y1;
-	    prect[i].height = y2 - y1 + 1;
-	} else {
-	    prect[i].y = y2;
-	    prect[i].height = y1 - y2 + 1;
-	}
-
-	x1 = x2;
-	y1 = y2;
+        if (mode == CoordModePrevious) {
+            x2 = x1 + ppt[i + 1].x;
+            y2 = y1 + ppt[i + 1].y;
+        }
+        else {
+            x2 = ppt[i + 1].x;
+            y2 = ppt[i + 1].y;
+        }
+
+        if (x1 != x2 && y1 != y2) {
+            free(prect);
+            ExaCheckPolylines(pDrawable, pGC, mode, npt, ppt);
+            return;
+        }
+
+        if (x1 < x2) {
+            prect[i].x = x1;
+            prect[i].width = x2 - x1 + 1;
+        }
+        else {
+            prect[i].x = x2;
+            prect[i].width = x1 - x2 + 1;
+        }
+        if (y1 < y2) {
+            prect[i].y = y1;
+            prect[i].height = y2 - y1 + 1;
+        }
+        else {
+            prect[i].y = y2;
+            prect[i].height = y1 - y2 + 1;
+        }
+
+        x1 = x2;
+        y1 = y2;
     }
     pGC->ops->PolyFillRect(pDrawable, pGC, npt - 1, prect);
     free(prect);
@@ -714,80 +717,78 @@ exaPolylines(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
  * acceleration if so.
  */
 static void
-exaPolySegment (DrawablePtr pDrawable, GCPtr pGC, int nseg,
-		xSegment *pSeg)
+exaPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment * pSeg)
 {
-    ExaScreenPriv (pDrawable->pScreen);
+    ExaScreenPriv(pDrawable->pScreen);
     xRectangle *prect;
     int i;
 
     /* Don't try to do wide lines or non-solid fill style. */
     if (pExaScr->fallback_counter || pGC->lineWidth != 0 ||
-	pGC->lineStyle != LineSolid || pGC->fillStyle != FillSolid)
-    {
-	ExaCheckPolySegment(pDrawable, pGC, nseg, pSeg);
-	return;
+        pGC->lineStyle != LineSolid || pGC->fillStyle != FillSolid) {
+        ExaCheckPolySegment(pDrawable, pGC, nseg, pSeg);
+        return;
     }
 
     /* If we have any non-horizontal/vertical, fall back. */
     for (i = 0; i < nseg; i++) {
-	if (pSeg[i].x1 != pSeg[i].x2 && pSeg[i].y1 != pSeg[i].y2) {
-	    ExaCheckPolySegment(pDrawable, pGC, nseg, pSeg);
-	    return;
-	}
+        if (pSeg[i].x1 != pSeg[i].x2 && pSeg[i].y1 != pSeg[i].y2) {
+            ExaCheckPolySegment(pDrawable, pGC, nseg, pSeg);
+            return;
+        }
     }
 
     prect = malloc(sizeof(xRectangle) * nseg);
     for (i = 0; i < nseg; i++) {
-	if (pSeg[i].x1 < pSeg[i].x2) {
-	    prect[i].x = pSeg[i].x1;
-	    prect[i].width = pSeg[i].x2 - pSeg[i].x1 + 1;
-	} else {
-	    prect[i].x = pSeg[i].x2;
-	    prect[i].width = pSeg[i].x1 - pSeg[i].x2 + 1;
-	}
-	if (pSeg[i].y1 < pSeg[i].y2) {
-	    prect[i].y = pSeg[i].y1;
-	    prect[i].height = pSeg[i].y2 - pSeg[i].y1 + 1;
-	} else {
-	    prect[i].y = pSeg[i].y2;
-	    prect[i].height = pSeg[i].y1 - pSeg[i].y2 + 1;
-	}
-
-	/* don't paint last pixel */
-	if (pGC->capStyle == CapNotLast) {
-	    if (prect[i].width == 1)
-		prect[i].height--;
-	    else
-		prect[i].width--;
-	}
+        if (pSeg[i].x1 < pSeg[i].x2) {
+            prect[i].x = pSeg[i].x1;
+            prect[i].width = pSeg[i].x2 - pSeg[i].x1 + 1;
+        }
+        else {
+            prect[i].x = pSeg[i].x2;
+            prect[i].width = pSeg[i].x1 - pSeg[i].x2 + 1;
+        }
+        if (pSeg[i].y1 < pSeg[i].y2) {
+            prect[i].y = pSeg[i].y1;
+            prect[i].height = pSeg[i].y2 - pSeg[i].y1 + 1;
+        }
+        else {
+            prect[i].y = pSeg[i].y2;
+            prect[i].height = pSeg[i].y1 - pSeg[i].y2 + 1;
+        }
+
+        /* don't paint last pixel */
+        if (pGC->capStyle == CapNotLast) {
+            if (prect[i].width == 1)
+                prect[i].height--;
+            else
+                prect[i].width--;
+        }
     }
     pGC->ops->PolyFillRect(pDrawable, pGC, nseg, prect);
     free(prect);
 }
 
-static Bool exaFillRegionSolid (DrawablePtr pDrawable, RegionPtr pRegion,
-				Pixel pixel, CARD32 planemask, CARD32 alu,
-				unsigned int clientClipType);
+static Bool exaFillRegionSolid(DrawablePtr pDrawable, RegionPtr pRegion,
+                               Pixel pixel, CARD32 planemask, CARD32 alu,
+                               unsigned int clientClipType);
 
 static void
-exaPolyFillRect(DrawablePtr pDrawable,
-		GCPtr	    pGC,
-		int	    nrect,
-		xRectangle  *prect)
+exaPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrect, xRectangle *prect)
 {
-    ExaScreenPriv (pDrawable->pScreen);
-    RegionPtr	    pClip = fbGetCompositeClip(pGC);
-    PixmapPtr	    pPixmap = exaGetDrawablePixmap(pDrawable);
-    ExaPixmapPriv (pPixmap);
+    ExaScreenPriv(pDrawable->pScreen);
+    RegionPtr pClip = fbGetCompositeClip(pGC);
+    PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
+
+    ExaPixmapPriv(pPixmap);
     register BoxPtr pbox;
-    BoxPtr	    pextent;
-    int		    extentX1, extentX2, extentY1, extentY2;
-    int		    fullX1, fullX2, fullY1, fullY2;
-    int		    partX1, partX2, partY1, partY2;
-    int		    xoff, yoff;
-    int		    xorg, yorg;
-    int		    n;
+    BoxPtr pextent;
+    int extentX1, extentX2, extentY1, extentY2;
+    int fullX1, fullX2, fullY1, fullY2;
+    int partX1, partX2, partY1, partY2;
+    int xoff, yoff;
+    int xorg, yorg;
+    int n;
     RegionPtr pReg = RegionFromRects(nrect, prect, CT_UNSORTED);
 
     /* Compute intersection of rects and clip region */
@@ -795,62 +796,58 @@ exaPolyFillRect(DrawablePtr pDrawable,
     RegionIntersect(pReg, pClip, pReg);
 
     if (!RegionNumRects(pReg)) {
-	goto out;
+        goto out;
     }
 
     exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);
 
     if (pExaScr->fallback_counter || pExaScr->swappedOut ||
-	    pExaPixmap->accel_blocked)
-    {
-	goto fallback;
+        pExaPixmap->accel_blocked) {
+        goto fallback;
     }
 
     /* For ROPs where overlaps don't matter, convert rectangles to region and
      * call exaFillRegion{Solid,Tiled}.
      */
     if ((pGC->fillStyle == FillSolid || pGC->fillStyle == FillTiled) &&
-	(nrect == 1 || pGC->alu == GXcopy || pGC->alu == GXclear ||
-	 pGC->alu == GXnoop || pGC->alu == GXcopyInverted ||
-	 pGC->alu == GXset)) {
-	if (((pGC->fillStyle == FillSolid || pGC->tileIsPixel) &&
-	     exaFillRegionSolid(pDrawable, pReg, pGC->fillStyle == FillSolid ?
-				pGC->fgPixel : pGC->tile.pixel,	pGC->planemask,
-				pGC->alu, pGC->clientClipType)) ||
-	    (pGC->fillStyle == FillTiled && !pGC->tileIsPixel &&
-	     exaFillRegionTiled(pDrawable, pReg, pGC->tile.pixmap, &pGC->patOrg,
-				pGC->planemask, pGC->alu,
-				pGC->clientClipType))) {
-	    goto out;
-	}
+        (nrect == 1 || pGC->alu == GXcopy || pGC->alu == GXclear ||
+         pGC->alu == GXnoop || pGC->alu == GXcopyInverted ||
+         pGC->alu == GXset)) {
+        if (((pGC->fillStyle == FillSolid || pGC->tileIsPixel) &&
+             exaFillRegionSolid(pDrawable, pReg, pGC->fillStyle == FillSolid ?
+                                pGC->fgPixel : pGC->tile.pixel, pGC->planemask,
+                                pGC->alu, pGC->clientClipType)) ||
+            (pGC->fillStyle == FillTiled && !pGC->tileIsPixel &&
+             exaFillRegionTiled(pDrawable, pReg, pGC->tile.pixmap, &pGC->patOrg,
+                                pGC->planemask, pGC->alu,
+                                pGC->clientClipType))) {
+            goto out;
+        }
     }
 
     if (pGC->fillStyle != FillSolid &&
-	!(pGC->tileIsPixel && pGC->fillStyle == FillTiled))
-    {
-	goto fallback;
+        !(pGC->tileIsPixel && pGC->fillStyle == FillTiled)) {
+        goto fallback;
     }
 
     if (pExaScr->do_migration) {
-	ExaMigrationRec pixmaps[1];
+        ExaMigrationRec pixmaps[1];
 
-	pixmaps[0].as_dst = TRUE;
-	pixmaps[0].as_src = FALSE;
-	pixmaps[0].pPix = pPixmap;
-	pixmaps[0].pReg = NULL;
+        pixmaps[0].as_dst = TRUE;
+        pixmaps[0].as_src = FALSE;
+        pixmaps[0].pPix = pPixmap;
+        pixmaps[0].pReg = NULL;
 
-	exaDoMigration (pixmaps, 1, TRUE);
+        exaDoMigration(pixmaps, 1, TRUE);
     }
 
-    if (!exaPixmapHasGpuCopy (pPixmap) ||
-	!(*pExaScr->info->PrepareSolid) (pPixmap,
-					 pGC->alu,
-					 pGC->planemask,
-					 pGC->fgPixel))
-    {
-fallback:
-	ExaCheckPolyFillRect (pDrawable, pGC, nrect, prect);
-	goto out;
+    if (!exaPixmapHasGpuCopy(pPixmap) ||
+        !(*pExaScr->info->PrepareSolid) (pPixmap,
+                                         pGC->alu,
+                                         pGC->planemask, pGC->fgPixel)) {
+ fallback:
+        ExaCheckPolyFillRect(pDrawable, pGC, nrect, prect);
+        goto out;
     }
 
     xorg = pDrawable->x;
@@ -861,72 +858,68 @@ fallback:
     extentY1 = pextent->y1;
     extentX2 = pextent->x2;
     extentY2 = pextent->y2;
-    while (nrect--)
-    {
-	fullX1 = prect->x + xorg;
-	fullY1 = prect->y + yorg;
-	fullX2 = fullX1 + (int) prect->width;
-	fullY2 = fullY1 + (int) prect->height;
-	prect++;
-
-	if (fullX1 < extentX1)
-	    fullX1 = extentX1;
-
-	if (fullY1 < extentY1)
-	    fullY1 = extentY1;
-
-	if (fullX2 > extentX2)
-	    fullX2 = extentX2;
-
-	if (fullY2 > extentY2)
-	    fullY2 = extentY2;
-
-	if ((fullX1 >= fullX2) || (fullY1 >= fullY2))
-	    continue;
-	n = RegionNumRects (pClip);
-	if (n == 1)
-	{
-	    (*pExaScr->info->Solid) (pPixmap,
-				     fullX1 + xoff, fullY1 + yoff,
-				     fullX2 + xoff, fullY2 + yoff);
-	}
-	else
-	{
-	    pbox = RegionRects(pClip);
-	    /*
-	     * clip the rectangle to each box in the clip region
-	     * this is logically equivalent to calling Intersect(),
-	     * but rectangles may overlap each other here.
-	     */
-	    while(n--)
-	    {
-		partX1 = pbox->x1;
-		if (partX1 < fullX1)
-		    partX1 = fullX1;
-		partY1 = pbox->y1;
-		if (partY1 < fullY1)
-		    partY1 = fullY1;
-		partX2 = pbox->x2;
-		if (partX2 > fullX2)
-		    partX2 = fullX2;
-		partY2 = pbox->y2;
-		if (partY2 > fullY2)
-		    partY2 = fullY2;
-
-		pbox++;
-
-		if (partX1 < partX2 && partY1 < partY2) {
-		    (*pExaScr->info->Solid) (pPixmap,
-					     partX1 + xoff, partY1 + yoff,
-					     partX2 + xoff, partY2 + yoff);
-		}
-	    }
-	}
+    while (nrect--) {
+        fullX1 = prect->x + xorg;
+        fullY1 = prect->y + yorg;
+        fullX2 = fullX1 + (int) prect->width;
+        fullY2 = fullY1 + (int) prect->height;
+        prect++;
+
+        if (fullX1 < extentX1)
+            fullX1 = extentX1;
+
+        if (fullY1 < extentY1)
+            fullY1 = extentY1;
+
+        if (fullX2 > extentX2)
+            fullX2 = extentX2;
+
+        if (fullY2 > extentY2)
+            fullY2 = extentY2;
+
+        if ((fullX1 >= fullX2) || (fullY1 >= fullY2))
+            continue;
+        n = RegionNumRects(pClip);
+        if (n == 1) {
+            (*pExaScr->info->Solid) (pPixmap,
+                                     fullX1 + xoff, fullY1 + yoff,
+                                     fullX2 + xoff, fullY2 + yoff);
+        }
+        else {
+            pbox = RegionRects(pClip);
+            /*
+             * clip the rectangle to each box in the clip region
+             * this is logically equivalent to calling Intersect(),
+             * but rectangles may overlap each other here.
+             */
+            while (n--) {
+                partX1 = pbox->x1;
+                if (partX1 < fullX1)
+                    partX1 = fullX1;
+                partY1 = pbox->y1;
+                if (partY1 < fullY1)
+                    partY1 = fullY1;
+                partX2 = pbox->x2;
+                if (partX2 > fullX2)
+                    partX2 = fullX2;
+                partY2 = pbox->y2;
+                if (partY2 > fullY2)
+                    partY2 = fullY2;
+
+                pbox++;
+
+                if (partX1 < partX2 && partY1 < partY2) {
+                    (*pExaScr->info->Solid) (pPixmap,
+                                             partX1 + xoff, partY1 + yoff,
+                                             partX2 + xoff, partY2 + yoff);
+                }
+            }
+        }
     }
     (*pExaScr->info->DoneSolid) (pPixmap);
     exaMarkSync(pDrawable->pScreen);
 
-out:
+ out:
     RegionUninit(pReg);
     RegionDestroy(pReg);
 }
@@ -957,9 +950,10 @@ const GCOps exaOps = {
 void
 exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 {
-    RegionRec	rgnDst;
-    int		dx, dy;
-    PixmapPtr	pPixmap = (*pWin->drawable.pScreen->GetWindowPixmap) (pWin);
+    RegionRec rgnDst;
+    int dx, dy;
+    PixmapPtr pPixmap = (*pWin->drawable.pScreen->GetWindowPixmap) (pWin);
+
     ExaScreenPriv(pWin->drawable.pScreen);
 
     dx = ptOldOrg.x - pWin->drawable.x;
@@ -971,38 +965,37 @@ exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
     RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
 #ifdef COMPOSITE
     if (pPixmap->screen_x || pPixmap->screen_y)
-	RegionTranslate(&rgnDst,
-			  -pPixmap->screen_x, -pPixmap->screen_y);
+        RegionTranslate(&rgnDst, -pPixmap->screen_x, -pPixmap->screen_y);
 #endif
 
     if (pExaScr->fallback_counter) {
-	pExaScr->fallback_flags |= EXA_FALLBACK_COPYWINDOW;
-	goto fallback;
+        pExaScr->fallback_flags |= EXA_FALLBACK_COPYWINDOW;
+        goto fallback;
     }
 
     pExaScr->fallback_flags |= EXA_ACCEL_COPYWINDOW;
-    miCopyRegion (&pPixmap->drawable, &pPixmap->drawable,
-		  NULL,
-		  &rgnDst, dx, dy, exaCopyNtoN, 0, NULL);
+    miCopyRegion(&pPixmap->drawable, &pPixmap->drawable,
+                 NULL, &rgnDst, dx, dy, exaCopyNtoN, 0, NULL);
     pExaScr->fallback_flags &= ~EXA_ACCEL_COPYWINDOW;
 
-fallback:
+ fallback:
     RegionUninit(&rgnDst);
 
     if (pExaScr->fallback_flags & EXA_FALLBACK_COPYWINDOW) {
-	pExaScr->fallback_flags &= ~EXA_FALLBACK_COPYWINDOW;
-	RegionTranslate(prgnSrc, dx, dy);
-	ExaCheckCopyWindow(pWin, ptOldOrg, prgnSrc);
+        pExaScr->fallback_flags &= ~EXA_FALLBACK_COPYWINDOW;
+        RegionTranslate(prgnSrc, dx, dy);
+        ExaCheckCopyWindow(pWin, ptOldOrg, prgnSrc);
     }
 }
 
 static Bool
-exaFillRegionSolid (DrawablePtr	pDrawable, RegionPtr pRegion, Pixel pixel,
-		    CARD32 planemask, CARD32 alu, unsigned int clientClipType)
+exaFillRegionSolid(DrawablePtr pDrawable, RegionPtr pRegion, Pixel pixel,
+                   CARD32 planemask, CARD32 alu, unsigned int clientClipType)
 {
     ExaScreenPriv(pDrawable->pScreen);
-    PixmapPtr pPixmap = exaGetDrawablePixmap (pDrawable);
-    ExaPixmapPriv (pPixmap);
+    PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
+
+    ExaPixmapPriv(pPixmap);
     int xoff, yoff;
     Bool ret = FALSE;
 
@@ -1010,69 +1003,67 @@ exaFillRegionSolid (DrawablePtr	pDrawable, RegionPtr pRegion, Pixel pixel,
     RegionTranslate(pRegion, xoff, yoff);
 
     if (pExaScr->fallback_counter || pExaPixmap->accel_blocked)
-	goto out;
+        goto out;
 
     if (pExaScr->do_migration) {
-	ExaMigrationRec pixmaps[1];
+        ExaMigrationRec pixmaps[1];
 
-	pixmaps[0].as_dst = TRUE;
-	pixmaps[0].as_src = FALSE;
-	pixmaps[0].pPix = pPixmap;
-	pixmaps[0].pReg = exaGCReadsDestination(pDrawable, planemask, FillSolid,
-						alu, clientClipType) ? NULL : pRegion;
+        pixmaps[0].as_dst = TRUE;
+        pixmaps[0].as_src = FALSE;
+        pixmaps[0].pPix = pPixmap;
+        pixmaps[0].pReg = exaGCReadsDestination(pDrawable, planemask, FillSolid,
+                                                alu,
+                                                clientClipType) ? NULL :
+            pRegion;
 
-	exaDoMigration (pixmaps, 1, TRUE);
+        exaDoMigration(pixmaps, 1, TRUE);
     }
 
-    if (exaPixmapHasGpuCopy (pPixmap) &&
-	(*pExaScr->info->PrepareSolid) (pPixmap, alu, planemask, pixel))
-    {
-	int nbox;
-	BoxPtr pBox;
-
-	nbox = RegionNumRects (pRegion);
-	pBox = RegionRects (pRegion);
-
-	while (nbox--)
-	{
-	    (*pExaScr->info->Solid) (pPixmap, pBox->x1, pBox->y1, pBox->x2,
-				     pBox->y2);
-	    pBox++;
-	}
-	(*pExaScr->info->DoneSolid) (pPixmap);
-	exaMarkSync(pDrawable->pScreen);
-
-	if (pExaPixmap->pDamage &&
-	    pExaPixmap->sys_ptr && pDrawable->type == DRAWABLE_PIXMAP &&
-	    pDrawable->width == 1 && pDrawable->height == 1 &&
-	    pDrawable->bitsPerPixel != 24) {
-	    ExaPixmapPriv(pPixmap);
-	    RegionPtr pending_damage = DamagePendingRegion(pExaPixmap->pDamage);
-
-	    switch (pDrawable->bitsPerPixel) {
-	    case 32:
-		*(CARD32*)pExaPixmap->sys_ptr = pixel;
-		break;
-	    case 16:
-		*(CARD16*)pExaPixmap->sys_ptr = pixel;
-		break;
-	    case 8:
-	    case 4:
-	    case 1:
-		*(CARD8*)pExaPixmap->sys_ptr = pixel;
-	    }
-
-	    RegionUnion(&pExaPixmap->validSys, &pExaPixmap->validSys,
-			 pRegion);
-	    RegionUnion(&pExaPixmap->validFB, &pExaPixmap->validFB,
-			 pRegion);
-	    RegionSubtract(pending_damage, pending_damage, pRegion);
-	}
-
-	ret = TRUE;
+    if (exaPixmapHasGpuCopy(pPixmap) &&
+        (*pExaScr->info->PrepareSolid) (pPixmap, alu, planemask, pixel)) {
+        int nbox;
+        BoxPtr pBox;
+
+        nbox = RegionNumRects(pRegion);
+        pBox = RegionRects(pRegion);
+
+        while (nbox--) {
+            (*pExaScr->info->Solid) (pPixmap, pBox->x1, pBox->y1, pBox->x2,
+                                     pBox->y2);
+            pBox++;
+        }
+        (*pExaScr->info->DoneSolid) (pPixmap);
+        exaMarkSync(pDrawable->pScreen);
+
+        if (pExaPixmap->pDamage &&
+            pExaPixmap->sys_ptr && pDrawable->type == DRAWABLE_PIXMAP &&
+            pDrawable->width == 1 && pDrawable->height == 1 &&
+            pDrawable->bitsPerPixel != 24) {
+            ExaPixmapPriv(pPixmap);
+            RegionPtr pending_damage = DamagePendingRegion(pExaPixmap->pDamage);
+
+            switch (pDrawable->bitsPerPixel) {
+            case 32:
+                *(CARD32 *) pExaPixmap->sys_ptr = pixel;
+                break;
+            case 16:
+                *(CARD16 *) pExaPixmap->sys_ptr = pixel;
+                break;
+            case 8:
+            case 4:
+            case 1:
+                *(CARD8 *) pExaPixmap->sys_ptr = pixel;
+            }
+
+            RegionUnion(&pExaPixmap->validSys, &pExaPixmap->validSys, pRegion);
+            RegionUnion(&pExaPixmap->validFB, &pExaPixmap->validFB, pRegion);
+            RegionSubtract(pending_damage, pending_damage, pRegion);
+        }
+
+        ret = TRUE;
     }
 
-out:
+ out:
     RegionTranslate(pRegion, -xoff, -yoff);
 
     return ret;
@@ -1082,9 +1073,9 @@ out:
  * Based on fbFillRegionTiled(), fbTile().
  */
 Bool
-exaFillRegionTiled (DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
-		    DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
-		    unsigned int clientClipType)
+exaFillRegionTiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
+                   DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
+                   unsigned int clientClipType)
 {
     ExaScreenPriv(pDrawable->pScreen);
     PixmapPtr pPixmap;
@@ -1092,8 +1083,8 @@ exaFillRegionTiled (DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
     ExaPixmapPrivPtr pTileExaPixmap = ExaGetPixmapPriv(pTile);
     int xoff, yoff;
     int tileWidth, tileHeight;
-    int nbox = RegionNumRects (pRegion);
-    BoxPtr pBox = RegionRects (pRegion);
+    int nbox = RegionNumRects(pRegion);
+    BoxPtr pBox = RegionRects(pRegion);
     Bool ret = FALSE;
     int i;
 
@@ -1104,156 +1095,158 @@ exaFillRegionTiled (DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
      * FillRegionSolid, saving numerous copies.
      */
     if (tileWidth == 1 && tileHeight == 1)
-	return exaFillRegionSolid(pDrawable, pRegion,
-				  exaGetPixmapFirstPixel (pTile), planemask,
-				  alu, clientClipType);
+        return exaFillRegionSolid(pDrawable, pRegion,
+                                  exaGetPixmapFirstPixel(pTile), planemask,
+                                  alu, clientClipType);
 
-    pPixmap = exaGetDrawablePixmap (pDrawable);
-    pExaPixmap = ExaGetPixmapPriv (pPixmap);
+    pPixmap = exaGetDrawablePixmap(pDrawable);
+    pExaPixmap = ExaGetPixmapPriv(pPixmap);
 
     if (pExaScr->fallback_counter || pExaPixmap->accel_blocked ||
-	    pTileExaPixmap->accel_blocked)
-	return FALSE;
+        pTileExaPixmap->accel_blocked)
+        return FALSE;
 
     if (pExaScr->do_migration) {
-	ExaMigrationRec pixmaps[2];
-
-	pixmaps[0].as_dst = TRUE;
-	pixmaps[0].as_src = FALSE;
-	pixmaps[0].pPix = pPixmap;
-	pixmaps[0].pReg = exaGCReadsDestination(pDrawable, planemask, FillTiled,
-						alu, clientClipType) ? NULL : pRegion;
-	pixmaps[1].as_dst = FALSE;
-	pixmaps[1].as_src = TRUE;
-	pixmaps[1].pPix = pTile;
-	pixmaps[1].pReg = NULL;
-
-	exaDoMigration (pixmaps, 2, TRUE);
+        ExaMigrationRec pixmaps[2];
+
+        pixmaps[0].as_dst = TRUE;
+        pixmaps[0].as_src = FALSE;
+        pixmaps[0].pPix = pPixmap;
+        pixmaps[0].pReg = exaGCReadsDestination(pDrawable, planemask, FillTiled,
+                                                alu,
+                                                clientClipType) ? NULL :
+            pRegion;
+        pixmaps[1].as_dst = FALSE;
+        pixmaps[1].as_src = TRUE;
+        pixmaps[1].pPix = pTile;
+        pixmaps[1].pReg = NULL;
+
+        exaDoMigration(pixmaps, 2, TRUE);
     }
 
-    pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff);
+    pPixmap = exaGetOffscreenPixmap(pDrawable, &xoff, &yoff);
 
     if (!pPixmap || !exaPixmapHasGpuCopy(pTile))
-	return FALSE;
-
-    if ((*pExaScr->info->PrepareCopy) (pTile, pPixmap, 1, 1, alu, planemask))
-    {
-	if (xoff || yoff)
-	    RegionTranslate(pRegion, xoff, yoff);
-
-	for (i = 0; i < nbox; i++)
-	{
-	    int height = pBox[i].y2 - pBox[i].y1;
-	    int dstY = pBox[i].y1;
-	    int tileY;
-
-	    if (alu == GXcopy)
-		height = min(height, tileHeight);
-
-	    modulus(dstY - yoff - pDrawable->y - pPatOrg->y, tileHeight, tileY);
-
-	    while (height > 0) {
-		int width = pBox[i].x2 - pBox[i].x1;
-		int dstX = pBox[i].x1;
-		int tileX;
-		int h = tileHeight - tileY;
-
-		if (alu == GXcopy)
-		    width = min(width, tileWidth);
-
-		if (h > height)
-		    h = height;
-		height -= h;
-
-		modulus(dstX - xoff - pDrawable->x - pPatOrg->x, tileWidth,
-			tileX);
-
-		while (width > 0) {
-		    int w = tileWidth - tileX;
-		    if (w > width)
-			w = width;
-		    width -= w;
-
-		    (*pExaScr->info->Copy) (pPixmap, tileX, tileY, dstX, dstY,
-					    w, h);
-		    dstX += w;
-		    tileX = 0;
-		}
-		dstY += h;
-		tileY = 0;
-	    }
-	}
-	(*pExaScr->info->DoneCopy) (pPixmap);
-
-	/* With GXcopy, we only need to do the basic algorithm up to the tile
-	 * size; then, we can just keep doubling the destination in each
-	 * direction until it fills the box. This way, the number of copy
-	 * operations is O(log(rx)) + O(log(ry)) instead of O(rx * ry), where
-	 * rx/ry is the ratio between box and tile width/height. This can make
-	 * a big difference if each driver copy incurs a significant constant
-	 * overhead.
-	 */
-	if (alu != GXcopy)
-	    ret = TRUE;
-	else {
-	    Bool more_copy = FALSE;
-
-	    for (i = 0; i < nbox; i++) {
-		int dstX = pBox[i].x1 + tileWidth;
-		int dstY = pBox[i].y1 + tileHeight;
-
-		if ((dstX < pBox[i].x2) || (dstY < pBox[i].y2)) {
-		    more_copy = TRUE;
-		    break;
-		}
-	    }
-
-	    if (more_copy == FALSE)
-		ret = TRUE;
-
-	    if (more_copy && (*pExaScr->info->PrepareCopy) (pPixmap, pPixmap,
-							    1, 1, alu, planemask)) {
-		for (i = 0; i < nbox; i++)
-		{
-		    int dstX = pBox[i].x1 + tileWidth;
-		    int dstY = pBox[i].y1 + tileHeight;
-		    int width = min(pBox[i].x2 - dstX, tileWidth);
-		    int height = min(pBox[i].y2 - pBox[i].y1, tileHeight);
-
-		    while (dstX < pBox[i].x2) {
-			(*pExaScr->info->Copy) (pPixmap, pBox[i].x1, pBox[i].y1,
-						dstX, pBox[i].y1, width, height);
-			dstX += width;
-			width = min(pBox[i].x2 - dstX, width * 2);
-		    }
-
-		    width = pBox[i].x2 - pBox[i].x1;
-		    height = min(pBox[i].y2 - dstY, tileHeight);
-
-		    while (dstY < pBox[i].y2) {
-			(*pExaScr->info->Copy) (pPixmap, pBox[i].x1, pBox[i].y1,
-						pBox[i].x1, dstY, width, height);
-			dstY += height;
-			height = min(pBox[i].y2 - dstY, height * 2);
-		    }
-		}
-
-		(*pExaScr->info->DoneCopy) (pPixmap);
-
-		ret = TRUE;
-	    }
-	}
-
-	exaMarkSync(pDrawable->pScreen);
-
-	if (xoff || yoff)
-	    RegionTranslate(pRegion, -xoff, -yoff);
+        return FALSE;
+
+    if ((*pExaScr->info->PrepareCopy) (pTile, pPixmap, 1, 1, alu, planemask)) {
+        if (xoff || yoff)
+            RegionTranslate(pRegion, xoff, yoff);
+
+        for (i = 0; i < nbox; i++) {
+            int height = pBox[i].y2 - pBox[i].y1;
+            int dstY = pBox[i].y1;
+            int tileY;
+
+            if (alu == GXcopy)
+                height = min(height, tileHeight);
+
+            modulus(dstY - yoff - pDrawable->y - pPatOrg->y, tileHeight, tileY);
+
+            while (height > 0) {
+                int width = pBox[i].x2 - pBox[i].x1;
+                int dstX = pBox[i].x1;
+                int tileX;
+                int h = tileHeight - tileY;
+
+                if (alu == GXcopy)
+                    width = min(width, tileWidth);
+
+                if (h > height)
+                    h = height;
+                height -= h;
+
+                modulus(dstX - xoff - pDrawable->x - pPatOrg->x, tileWidth,
+                        tileX);
+
+                while (width > 0) {
+                    int w = tileWidth - tileX;
+
+                    if (w > width)
+                        w = width;
+                    width -= w;
+
+                    (*pExaScr->info->Copy) (pPixmap, tileX, tileY, dstX, dstY,
+                                            w, h);
+                    dstX += w;
+                    tileX = 0;
+                }
+                dstY += h;
+                tileY = 0;
+            }
+        }
+        (*pExaScr->info->DoneCopy) (pPixmap);
+
+        /* With GXcopy, we only need to do the basic algorithm up to the tile
+         * size; then, we can just keep doubling the destination in each
+         * direction until it fills the box. This way, the number of copy
+         * operations is O(log(rx)) + O(log(ry)) instead of O(rx * ry), where
+         * rx/ry is the ratio between box and tile width/height. This can make
+         * a big difference if each driver copy incurs a significant constant
+         * overhead.
+         */
+        if (alu != GXcopy)
+            ret = TRUE;
+        else {
+            Bool more_copy = FALSE;
+
+            for (i = 0; i < nbox; i++) {
+                int dstX = pBox[i].x1 + tileWidth;
+                int dstY = pBox[i].y1 + tileHeight;
+
+                if ((dstX < pBox[i].x2) || (dstY < pBox[i].y2)) {
+                    more_copy = TRUE;
+                    break;
+                }
+            }
+
+            if (more_copy == FALSE)
+                ret = TRUE;
+
+            if (more_copy && (*pExaScr->info->PrepareCopy) (pPixmap, pPixmap,
+                                                            1, 1, alu,
+                                                            planemask)) {
+                for (i = 0; i < nbox; i++) {
+                    int dstX = pBox[i].x1 + tileWidth;
+                    int dstY = pBox[i].y1 + tileHeight;
+                    int width = min(pBox[i].x2 - dstX, tileWidth);
+                    int height = min(pBox[i].y2 - pBox[i].y1, tileHeight);
+
+                    while (dstX < pBox[i].x2) {
+                        (*pExaScr->info->Copy) (pPixmap, pBox[i].x1, pBox[i].y1,
+                                                dstX, pBox[i].y1, width,
+                                                height);
+                        dstX += width;
+                        width = min(pBox[i].x2 - dstX, width * 2);
+                    }
+
+                    width = pBox[i].x2 - pBox[i].x1;
+                    height = min(pBox[i].y2 - dstY, tileHeight);
+
+                    while (dstY < pBox[i].y2) {
+                        (*pExaScr->info->Copy) (pPixmap, pBox[i].x1, pBox[i].y1,
+                                                pBox[i].x1, dstY, width,
+                                                height);
+                        dstY += height;
+                        height = min(pBox[i].y2 - dstY, height * 2);
+                    }
+                }
+
+                (*pExaScr->info->DoneCopy) (pPixmap);
+
+                ret = TRUE;
+            }
+        }
+
+        exaMarkSync(pDrawable->pScreen);
+
+        if (xoff || yoff)
+            RegionTranslate(pRegion, -xoff, -yoff);
     }
 
     return ret;
 }
 
-
 /**
  * Accelerates GetImage for solid ZPixmap downloads from framebuffer memory.
  *
@@ -1262,45 +1255,46 @@ exaFillRegionTiled (DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
  * the pixmap out of framebuffer.
  */
 void
-exaGetImage (DrawablePtr pDrawable, int x, int y, int w, int h,
-	     unsigned int format, unsigned long planeMask, char *d)
+exaGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
+            unsigned int format, unsigned long planeMask, char *d)
 {
-    ExaScreenPriv (pDrawable->pScreen);
-    PixmapPtr pPix = exaGetDrawablePixmap (pDrawable);
+    ExaScreenPriv(pDrawable->pScreen);
+    PixmapPtr pPix = exaGetDrawablePixmap(pDrawable);
+
     ExaPixmapPriv(pPix);
     int xoff, yoff;
     Bool ok;
 
     if (pExaScr->fallback_counter || pExaScr->swappedOut)
-	goto fallback;
+        goto fallback;
 
     /* If there's a system copy, we want to save the result there */
     if (pExaPixmap->pDamage)
-	goto fallback;
+        goto fallback;
 
-    pPix = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff);
+    pPix = exaGetOffscreenPixmap(pDrawable, &xoff, &yoff);
 
     if (pPix == NULL || pExaScr->info->DownloadFromScreen == NULL)
-	goto fallback;
+        goto fallback;
 
     /* Only cover the ZPixmap, solid copy case. */
     if (format != ZPixmap || !EXA_PM_IS_SOLID(pDrawable, planeMask))
-	goto fallback;
+        goto fallback;
 
     /* Only try to handle the 8bpp and up cases, since we don't want to think
      * about <8bpp.
      */
     if (pDrawable->bitsPerPixel < 8)
-	goto fallback;
+        goto fallback;
 
     ok = pExaScr->info->DownloadFromScreen(pPix, pDrawable->x + x + xoff,
-					   pDrawable->y + y + yoff, w, h, d,
-					   PixmapBytePad(w, pDrawable->depth));
+                                           pDrawable->y + y + yoff, w, h, d,
+                                           PixmapBytePad(w, pDrawable->depth));
     if (ok) {
-	exaWaitSync(pDrawable->pScreen);
-	return;
+        exaWaitSync(pDrawable->pScreen);
+        return;
     }
 
-fallback:
+ fallback:
     ExaCheckGetImage(pDrawable, x, y, w, h, format, planeMask, d);
 }