libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 359 insertions, 343 deletions

diff --git a/xorg-server/exa/exa_migration_classic.c b/xorg-server/exa/exa_migration_classic.c
index dd3cd491e..e890f6754 100644
--- a/xorg-server/exa/exa_migration_classic.c
+++ b/xorg-server/exa/exa_migration_classic.c
@@ -46,9 +46,9 @@
  * and exaCopyDirtyToFb both needed to do this loop.
  */
 static void
-exaMemcpyBox (PixmapPtr pPixmap, BoxPtr pbox, CARD8 *src, int src_pitch,
-	      CARD8 *dst, int dst_pitch)
- {
+exaMemcpyBox(PixmapPtr pPixmap, BoxPtr pbox, CARD8 *src, int src_pitch,
+             CARD8 *dst, int dst_pitch)
+{
     int i, cpp = pPixmap->drawable.bitsPerPixel / 8;
     int bytes = (pbox->x2 - pbox->x1) * cpp;
 
@@ -56,9 +56,9 @@ exaMemcpyBox (PixmapPtr pPixmap, BoxPtr pbox, CARD8 *src, int src_pitch,
     dst += pbox->y1 * dst_pitch + pbox->x1 * cpp;
 
     for (i = pbox->y2 - pbox->y1; i; i--) {
-	memcpy (dst, src, bytes);
-	src += src_pitch;
-	dst += dst_pitch;
+        memcpy(dst, src, bytes);
+        src += src_pitch;
+        dst += dst_pitch;
     }
 }
 
@@ -68,18 +68,18 @@ exaMemcpyBox (PixmapPtr pPixmap, BoxPtr pbox, CARD8 *src, int src_pitch,
  * dirtiness.
  */
 static Bool
-exaPixmapIsDirty (PixmapPtr pPix)
+exaPixmapIsDirty(PixmapPtr pPix)
 {
-    ExaPixmapPriv (pPix);
+    ExaPixmapPriv(pPix);
 
     if (pExaPixmap == NULL)
-	EXA_FatalErrorDebugWithRet(("EXA bug: exaPixmapIsDirty was called on a non-exa pixmap.\n"), TRUE);
+        EXA_FatalErrorDebugWithRet(("EXA bug: exaPixmapIsDirty was called on a non-exa pixmap.\n"), TRUE);
 
     if (!pExaPixmap->pDamage)
-	return FALSE;
+        return FALSE;
 
     return RegionNotEmpty(DamageRegion(pExaPixmap->pDamage)) ||
-	!RegionEqual(&pExaPixmap->validSys, &pExaPixmap->validFB);
+        !RegionEqual(&pExaPixmap->validSys, &pExaPixmap->validFB);
 }
 
 /**
@@ -90,12 +90,12 @@ exaPixmapIsDirty (PixmapPtr pPix)
  * Only valid if using a migration scheme that tracks score.
  */
 static Bool
-exaPixmapShouldBeInFB (PixmapPtr pPix)
+exaPixmapShouldBeInFB(PixmapPtr pPix)
 {
-    ExaPixmapPriv (pPix);
+    ExaPixmapPriv(pPix);
 
-    if (exaPixmapIsPinned (pPix))
-	return TRUE;
+    if (exaPixmapIsPinned(pPix))
+        return TRUE;
 
     return pExaPixmap->score >= 0;
 }
@@ -106,13 +106,14 @@ exaPixmapShouldBeInFB (PixmapPtr pPix)
  */
 static void
 exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
-	     Bool (*transfer) (PixmapPtr pPix, int x, int y, int w, int h,
-			       char *sys, int sys_pitch), int fallback_index,
-	     void (*sync) (ScreenPtr pScreen))
+             Bool (*transfer) (PixmapPtr pPix, int x, int y, int w, int h,
+                               char *sys, int sys_pitch), int fallback_index,
+             void (*sync) (ScreenPtr pScreen))
 {
     PixmapPtr pPixmap = migrate->pPix;
-    ExaPixmapPriv (pPixmap);
-    RegionPtr damage = DamageRegion (pExaPixmap->pDamage);
+
+    ExaPixmapPriv(pPixmap);
+    RegionPtr damage = DamageRegion(pExaPixmap->pDamage);
     RegionRec CopyReg;
     Bool save_use_gpu_copy;
     int save_pitch;
@@ -123,15 +124,12 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
 
     /* Damaged bits are valid in current copy but invalid in other one */
     if (pExaPixmap->use_gpu_copy) {
-	RegionUnion(&pExaPixmap->validFB, &pExaPixmap->validFB,
-		     damage);
-	RegionSubtract(&pExaPixmap->validSys, &pExaPixmap->validSys,
-			damage);
-    } else {
-	RegionUnion(&pExaPixmap->validSys, &pExaPixmap->validSys,
-		     damage);
-	RegionSubtract(&pExaPixmap->validFB, &pExaPixmap->validFB,
-			damage);
+        RegionUnion(&pExaPixmap->validFB, &pExaPixmap->validFB, damage);
+        RegionSubtract(&pExaPixmap->validSys, &pExaPixmap->validSys, damage);
+    }
+    else {
+        RegionUnion(&pExaPixmap->validSys, &pExaPixmap->validSys, damage);
+        RegionSubtract(&pExaPixmap->validFB, &pExaPixmap->validFB, damage);
     }
 
     RegionEmpty(damage);
@@ -141,63 +139,65 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
     RegionSubtract(&CopyReg, pValidSrc, pValidDst);
 
     if (migrate->as_dst) {
-	ExaScreenPriv (pPixmap->drawable.pScreen);
+        ExaScreenPriv(pPixmap->drawable.pScreen);
 
-	/* XXX: The pending damage region will be marked as damaged after the
-	 * operation, so it should serve as an upper bound for the region that
-	 * needs to be synchronized for the operation. Unfortunately, this
-	 * causes corruption in some cases, e.g. when starting compiz. See
-	 * https://bugs.freedesktop.org/show_bug.cgi?id=12916 .
-	 */
-	if (pExaScr->optimize_migration) {
-	    RegionPtr pending_damage = DamagePendingRegion(pExaPixmap->pDamage);
+        /* XXX: The pending damage region will be marked as damaged after the
+         * operation, so it should serve as an upper bound for the region that
+         * needs to be synchronized for the operation. Unfortunately, this
+         * causes corruption in some cases, e.g. when starting compiz. See
+         * https://bugs.freedesktop.org/show_bug.cgi?id=12916 .
+         */
+        if (pExaScr->optimize_migration) {
+            RegionPtr pending_damage = DamagePendingRegion(pExaPixmap->pDamage);
 
 #if DEBUG_MIGRATE
-	    if (RegionNil(pending_damage)) {
-		static Bool firsttime = TRUE;
-
-		if (firsttime) {
-		    ErrorF("%s: Pending damage region empty!\n", __func__);
-		    firsttime = FALSE;
-		}
-	    }
+            if (RegionNil(pending_damage)) {
+                static Bool firsttime = TRUE;
+
+                if (firsttime) {
+                    ErrorF("%s: Pending damage region empty!\n", __func__);
+                    firsttime = FALSE;
+                }
+            }
 #endif
 
-	    /* Try to prevent destination valid region from growing too many
-	     * rects by filling it up to the extents of the union of the
-	     * destination valid region and the pending damage region.
-	     */
-	    if (RegionNumRects(pValidDst) > 10) {
-		BoxRec box;
-		BoxPtr pValidExt, pDamageExt;
-		RegionRec closure;
-
-		pValidExt = RegionExtents(pValidDst);
-		pDamageExt = RegionExtents(pending_damage);
-
-		box.x1 = min(pValidExt->x1, pDamageExt->x1);
-		box.y1 = min(pValidExt->y1, pDamageExt->y1);
-		box.x2 = max(pValidExt->x2, pDamageExt->x2);
-		box.y2 = max(pValidExt->y2, pDamageExt->y2);
-
-		RegionInit(&closure, &box, 0);
-		RegionIntersect(&CopyReg, &CopyReg, &closure);
-	    } else
-		RegionIntersect(&CopyReg, &CopyReg, pending_damage);
-	}
-
-	/* The caller may provide a region to be subtracted from the calculated
-	 * dirty region. This is to avoid migration of bits that don't
-	 * contribute to the result of the operation.
-	 */
-	if (migrate->pReg)
-	    RegionSubtract(&CopyReg, &CopyReg, migrate->pReg);
-    } else {
-	/* The caller may restrict the region to be migrated for source pixmaps
-	 * to what's relevant for the operation.
-	 */
-	if (migrate->pReg)
-	    RegionIntersect(&CopyReg, &CopyReg, migrate->pReg);
+            /* Try to prevent destination valid region from growing too many
+             * rects by filling it up to the extents of the union of the
+             * destination valid region and the pending damage region.
+             */
+            if (RegionNumRects(pValidDst) > 10) {
+                BoxRec box;
+                BoxPtr pValidExt, pDamageExt;
+                RegionRec closure;
+
+                pValidExt = RegionExtents(pValidDst);
+                pDamageExt = RegionExtents(pending_damage);
+
+                box.x1 = min(pValidExt->x1, pDamageExt->x1);
+                box.y1 = min(pValidExt->y1, pDamageExt->y1);
+                box.x2 = max(pValidExt->x2, pDamageExt->x2);
+                box.y2 = max(pValidExt->y2, pDamageExt->y2);
+
+                RegionInit(&closure, &box, 0);
+                RegionIntersect(&CopyReg, &CopyReg, &closure);
+            }
+            else
+                RegionIntersect(&CopyReg, &CopyReg, pending_damage);
+        }
+
+        /* The caller may provide a region to be subtracted from the calculated
+         * dirty region. This is to avoid migration of bits that don't
+         * contribute to the result of the operation.
+         */
+        if (migrate->pReg)
+            RegionSubtract(&CopyReg, &CopyReg, migrate->pReg);
+    }
+    else {
+        /* The caller may restrict the region to be migrated for source pixmaps
+         * to what's relevant for the operation.
+         */
+        if (migrate->pReg)
+            RegionIntersect(&CopyReg, &CopyReg, migrate->pReg);
     }
 
     pBox = RegionRects(&CopyReg);
@@ -209,40 +209,43 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
     pPixmap->devKind = pExaPixmap->fb_pitch;
 
     while (nbox--) {
-	pBox->x1 = max(pBox->x1, 0);
-	pBox->y1 = max(pBox->y1, 0);
-	pBox->x2 = min(pBox->x2, pPixmap->drawable.width);
-	pBox->y2 = min(pBox->y2, pPixmap->drawable.height);
-
-	if (pBox->x1 >= pBox->x2 || pBox->y1 >= pBox->y2)
-	    continue;
-
-	if (!transfer || !transfer (pPixmap,
-				    pBox->x1, pBox->y1,
-				    pBox->x2 - pBox->x1,
-				    pBox->y2 - pBox->y1,
-				    (char *) (pExaPixmap->sys_ptr
-				    + pBox->y1 * pExaPixmap->sys_pitch
-				    + pBox->x1 * pPixmap->drawable.bitsPerPixel / 8),
-				    pExaPixmap->sys_pitch))
-	{
-	    if (!access_prepared) {
-		ExaDoPrepareAccess(pPixmap, fallback_index);
-		access_prepared = TRUE;
-	    }
-	    if (fallback_index == EXA_PREPARE_DEST) {
-		exaMemcpyBox (pPixmap, pBox,
-			      pExaPixmap->sys_ptr, pExaPixmap->sys_pitch,
-			      pPixmap->devPrivate.ptr, pPixmap->devKind);
-	    } else {
-		exaMemcpyBox (pPixmap, pBox,
-			      pPixmap->devPrivate.ptr, pPixmap->devKind,
-			      pExaPixmap->sys_ptr, pExaPixmap->sys_pitch);
-	    }
-	} else
-	    need_sync = TRUE;
-
-	pBox++;
+        pBox->x1 = max(pBox->x1, 0);
+        pBox->y1 = max(pBox->y1, 0);
+        pBox->x2 = min(pBox->x2, pPixmap->drawable.width);
+        pBox->y2 = min(pBox->y2, pPixmap->drawable.height);
+
+        if (pBox->x1 >= pBox->x2 || pBox->y1 >= pBox->y2)
+            continue;
+
+        if (!transfer || !transfer(pPixmap,
+                                   pBox->x1, pBox->y1,
+                                   pBox->x2 - pBox->x1,
+                                   pBox->y2 - pBox->y1,
+                                   (char *) (pExaPixmap->sys_ptr
+                                             + pBox->y1 * pExaPixmap->sys_pitch
+                                             +
+                                             pBox->x1 *
+                                             pPixmap->drawable.bitsPerPixel /
+                                             8), pExaPixmap->sys_pitch)) {
+            if (!access_prepared) {
+                ExaDoPrepareAccess(pPixmap, fallback_index);
+                access_prepared = TRUE;
+            }
+            if (fallback_index == EXA_PREPARE_DEST) {
+                exaMemcpyBox(pPixmap, pBox,
+                             pExaPixmap->sys_ptr, pExaPixmap->sys_pitch,
+                             pPixmap->devPrivate.ptr, pPixmap->devKind);
+            }
+            else {
+                exaMemcpyBox(pPixmap, pBox,
+                             pPixmap->devPrivate.ptr, pPixmap->devKind,
+                             pExaPixmap->sys_ptr, pExaPixmap->sys_pitch);
+            }
+        }
+        else
+            need_sync = TRUE;
+
+        pBox++;
     }
 
     pExaPixmap->use_gpu_copy = save_use_gpu_copy;
@@ -253,7 +256,7 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
      * Removing anything beyond that would lead to data loss.
      */
     if (RegionNumRects(pValidSrc) > 20)
-	RegionSubtract(pValidSrc, pValidSrc, pValidDst);
+        RegionSubtract(pValidSrc, pValidSrc, pValidDst);
 
     /* The copied bits are now valid in destination */
     RegionUnion(pValidDst, pValidDst, &CopyReg);
@@ -261,9 +264,9 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
     RegionUninit(&CopyReg);
 
     if (access_prepared)
-	exaFinishAccess(&pPixmap->drawable, fallback_index);
+        exaFinishAccess(&pPixmap->drawable, fallback_index);
     else if (need_sync && sync)
-	sync (pPixmap->drawable.pScreen);
+        sync(pPixmap->drawable.pScreen);
 }
 
 /**
@@ -272,15 +275,16 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
  * allocated.
  */
 void
-exaCopyDirtyToSys (ExaMigrationPtr migrate)
+exaCopyDirtyToSys(ExaMigrationPtr migrate)
 {
     PixmapPtr pPixmap = migrate->pPix;
-    ExaScreenPriv (pPixmap->drawable.pScreen);
-    ExaPixmapPriv (pPixmap);
+
+    ExaScreenPriv(pPixmap->drawable.pScreen);
+    ExaPixmapPriv(pPixmap);
 
     exaCopyDirty(migrate, &pExaPixmap->validSys, &pExaPixmap->validFB,
-		 pExaScr->info->DownloadFromScreen, EXA_PREPARE_SRC,
-		 exaWaitSync);
+                 pExaScr->info->DownloadFromScreen, EXA_PREPARE_SRC,
+                 exaWaitSync);
 }
 
 /**
@@ -289,14 +293,15 @@ exaCopyDirtyToSys (ExaMigrationPtr migrate)
  * allocated.
  */
 void
-exaCopyDirtyToFb (ExaMigrationPtr migrate)
+exaCopyDirtyToFb(ExaMigrationPtr migrate)
 {
     PixmapPtr pPixmap = migrate->pPix;
-    ExaScreenPriv (pPixmap->drawable.pScreen);
-    ExaPixmapPriv (pPixmap);
+
+    ExaScreenPriv(pPixmap->drawable.pScreen);
+    ExaPixmapPriv(pPixmap);
 
     exaCopyDirty(migrate, &pExaPixmap->validFB, &pExaPixmap->validSys,
-		 pExaScr->info->UploadToScreen, EXA_PREPARE_DEST, NULL);
+                 pExaScr->info->UploadToScreen, EXA_PREPARE_DEST, NULL);
 }
 
 /**
@@ -315,54 +320,55 @@ exaCopyDirtyToFb (ExaMigrationPtr migrate)
  * all the data, since it's almost surely all valid now.
  */
 static void
-exaDoMoveInPixmap (ExaMigrationPtr migrate)
+exaDoMoveInPixmap(ExaMigrationPtr migrate)
 {
     PixmapPtr pPixmap = migrate->pPix;
     ScreenPtr pScreen = pPixmap->drawable.pScreen;
-    ExaScreenPriv (pScreen);
-    ExaPixmapPriv (pPixmap);
+
+    ExaScreenPriv(pScreen);
+    ExaPixmapPriv(pPixmap);
 
     /* If we're VT-switched away, no touching card memory allowed. */
     if (pExaScr->swappedOut)
-	return;
+        return;
 
     /* If we're not allowed to move, then fail. */
     if (exaPixmapIsPinned(pPixmap))
-	return;
+        return;
 
     /* Don't migrate in pixmaps which are less than 8bpp.  This avoids a lot of
      * fragility in EXA, and <8bpp is probably not used enough any more to care
      * (at least, not in acceleratd paths).
      */
     if (pPixmap->drawable.bitsPerPixel < 8)
-	return;
+        return;
 
     if (pExaPixmap->accel_blocked)
-	return;
+        return;
 
     if (pExaPixmap->area == NULL) {
-	pExaPixmap->area =
-	    exaOffscreenAlloc (pScreen, pExaPixmap->fb_size,
-			       pExaScr->info->pixmapOffsetAlign, FALSE,
-                               exaPixmapSave, (pointer) pPixmap);
-	if (pExaPixmap->area == NULL)
-	    return;
-
-	pExaPixmap->fb_ptr = (CARD8 *) pExaScr->info->memoryBase +
-				       pExaPixmap->area->offset;
+        pExaPixmap->area =
+            exaOffscreenAlloc(pScreen, pExaPixmap->fb_size,
+                              pExaScr->info->pixmapOffsetAlign, FALSE,
+                              exaPixmapSave, (pointer) pPixmap);
+        if (pExaPixmap->area == NULL)
+            return;
+
+        pExaPixmap->fb_ptr = (CARD8 *) pExaScr->info->memoryBase +
+            pExaPixmap->area->offset;
     }
 
-    exaCopyDirtyToFb (migrate);
+    exaCopyDirtyToFb(migrate);
 
     if (exaPixmapHasGpuCopy(pPixmap))
-	return;
+        return;
 
-    DBG_MIGRATE (("-> %p (0x%x) (%dx%d) (%c)\n", pPixmap,
-		  (ExaGetPixmapPriv(pPixmap)->area ?
-                   ExaGetPixmapPriv(pPixmap)->area->offset : 0),
-		  pPixmap->drawable.width,
-		  pPixmap->drawable.height,
-		  exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));
+    DBG_MIGRATE(("-> %p (0x%x) (%dx%d) (%c)\n", pPixmap,
+                 (ExaGetPixmapPriv(pPixmap)->area ?
+                  ExaGetPixmapPriv(pPixmap)->area->offset : 0),
+                 pPixmap->drawable.width,
+                 pPixmap->drawable.height,
+                 exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));
 
     pExaPixmap->use_gpu_copy = TRUE;
 
@@ -371,13 +377,14 @@ exaDoMoveInPixmap (ExaMigrationPtr migrate)
 }
 
 void
-exaMoveInPixmap_classic (PixmapPtr pPixmap)
+exaMoveInPixmap_classic(PixmapPtr pPixmap)
 {
-    static ExaMigrationRec migrate = { .as_dst = FALSE, .as_src = TRUE,
-				       .pReg = NULL };
+    static ExaMigrationRec migrate = {.as_dst = FALSE,.as_src = TRUE,
+        .pReg = NULL
+    };
 
     migrate.pPix = pPixmap;
-    exaDoMoveInPixmap (&migrate);
+    exaDoMoveInPixmap(&migrate);
 }
 
 /**
@@ -385,52 +392,54 @@ exaMoveInPixmap_classic (PixmapPtr pPixmap)
  * updated data out if necessary.
  */
 static void
-exaDoMoveOutPixmap (ExaMigrationPtr migrate)
+exaDoMoveOutPixmap(ExaMigrationPtr migrate)
 {
     PixmapPtr pPixmap = migrate->pPix;
-    ExaPixmapPriv (pPixmap);
+
+    ExaPixmapPriv(pPixmap);
 
     if (!pExaPixmap->area || exaPixmapIsPinned(pPixmap))
-	return;
+        return;
 
-    exaCopyDirtyToSys (migrate);
+    exaCopyDirtyToSys(migrate);
 
     if (exaPixmapHasGpuCopy(pPixmap)) {
 
-	DBG_MIGRATE (("<- %p (%p) (%dx%d) (%c)\n", pPixmap,
-		      (void*)(ExaGetPixmapPriv(pPixmap)->area ?
-			      ExaGetPixmapPriv(pPixmap)->area->offset : 0),
-		      pPixmap->drawable.width,
-		      pPixmap->drawable.height,
-		      exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));
+        DBG_MIGRATE(("<- %p (%p) (%dx%d) (%c)\n", pPixmap,
+                     (void *) (ExaGetPixmapPriv(pPixmap)->area ?
+                               ExaGetPixmapPriv(pPixmap)->area->offset : 0),
+                     pPixmap->drawable.width,
+                     pPixmap->drawable.height,
+                     exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));
 
-	pExaPixmap->use_gpu_copy = FALSE;
+        pExaPixmap->use_gpu_copy = FALSE;
 
-	pPixmap->devKind = pExaPixmap->sys_pitch;
-	pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+        pPixmap->devKind = pExaPixmap->sys_pitch;
+        pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
     }
 }
 
 void
-exaMoveOutPixmap_classic (PixmapPtr pPixmap)
+exaMoveOutPixmap_classic(PixmapPtr pPixmap)
 {
-    static ExaMigrationRec migrate = { .as_dst = FALSE, .as_src = TRUE,
-				       .pReg = NULL };
+    static ExaMigrationRec migrate = {.as_dst = FALSE,.as_src = TRUE,
+        .pReg = NULL
+    };
 
     migrate.pPix = pPixmap;
-    exaDoMoveOutPixmap (&migrate);
+    exaDoMoveOutPixmap(&migrate);
 }
 
-
 /**
  * Copies out important pixmap data and removes references to framebuffer area.
  * Called when the memory manager decides it's time to kick the pixmap out of
  * framebuffer entirely.
  */
 void
-exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area)
+exaPixmapSave(ScreenPtr pScreen, ExaOffscreenArea * area)
 {
     PixmapPtr pPixmap = area->privData;
+
     ExaPixmapPriv(pPixmap);
 
     exaMoveOutPixmap(pPixmap);
@@ -448,39 +457,40 @@ exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area)
  * framebuffer memory.
  */
 static void
-exaMigrateTowardFb (ExaMigrationPtr migrate)
+exaMigrateTowardFb(ExaMigrationPtr migrate)
 {
     PixmapPtr pPixmap = migrate->pPix;
-    ExaPixmapPriv (pPixmap);
+
+    ExaPixmapPriv(pPixmap);
 
     if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED) {
-	DBG_MIGRATE(("UseScreen: not migrating pinned pixmap %p\n",
-		     (pointer)pPixmap));
-	return;
+        DBG_MIGRATE(("UseScreen: not migrating pinned pixmap %p\n",
+                     (pointer) pPixmap));
+        return;
     }
 
     DBG_MIGRATE(("UseScreen %p score %d\n",
-		 (pointer)pPixmap, pExaPixmap->score));
+                 (pointer) pPixmap, pExaPixmap->score));
 
     if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT) {
-	exaDoMoveInPixmap(migrate);
-	pExaPixmap->score = 0;
+        exaDoMoveInPixmap(migrate);
+        pExaPixmap->score = 0;
     }
 
     if (pExaPixmap->score < EXA_PIXMAP_SCORE_MAX)
-	pExaPixmap->score++;
+        pExaPixmap->score++;
 
     if (pExaPixmap->score >= EXA_PIXMAP_SCORE_MOVE_IN &&
-	!exaPixmapHasGpuCopy(pPixmap))
-    {
-	exaDoMoveInPixmap(migrate);
+        !exaPixmapHasGpuCopy(pPixmap)) {
+        exaDoMoveInPixmap(migrate);
     }
 
     if (exaPixmapHasGpuCopy(pPixmap)) {
-	exaCopyDirtyToFb (migrate);
-	ExaOffscreenMarkUsed (pPixmap);
-    } else
-	exaCopyDirtyToSys (migrate);
+        exaCopyDirtyToFb(migrate);
+        ExaOffscreenMarkUsed(pPixmap);
+    }
+    else
+        exaCopyDirtyToSys(migrate);
 }
 
 /**
@@ -488,30 +498,33 @@ exaMigrateTowardFb (ExaMigrationPtr migrate)
  * system memory.
  */
 static void
-exaMigrateTowardSys (ExaMigrationPtr migrate)
+exaMigrateTowardSys(ExaMigrationPtr migrate)
 {
     PixmapPtr pPixmap = migrate->pPix;
-    ExaPixmapPriv (pPixmap);
 
-    DBG_MIGRATE(("UseMem: %p score %d\n", (pointer)pPixmap, pExaPixmap->score));
+    ExaPixmapPriv(pPixmap);
+
+    DBG_MIGRATE(("UseMem: %p score %d\n", (pointer) pPixmap,
+                 pExaPixmap->score));
 
     if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED)
-	return;
+        return;
 
     if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT)
-	pExaPixmap->score = 0;
+        pExaPixmap->score = 0;
 
     if (pExaPixmap->score > EXA_PIXMAP_SCORE_MIN)
-	pExaPixmap->score--;
+        pExaPixmap->score--;
 
     if (pExaPixmap->score <= EXA_PIXMAP_SCORE_MOVE_OUT && pExaPixmap->area)
-	exaDoMoveOutPixmap(migrate);
+        exaDoMoveOutPixmap(migrate);
 
     if (exaPixmapHasGpuCopy(pPixmap)) {
-	exaCopyDirtyToFb (migrate);
-	ExaOffscreenMarkUsed (pPixmap);
-    } else
-	exaCopyDirtyToSys (migrate);
+        exaCopyDirtyToFb(migrate);
+        ExaOffscreenMarkUsed(pPixmap);
+    }
+    else
+        exaCopyDirtyToSys(migrate);
 }
 
 /**
@@ -519,9 +532,9 @@ exaMigrateTowardSys (ExaMigrationPtr migrate)
  * asserts that both of them are the same.
  */
 static Bool
-exaAssertNotDirty (PixmapPtr pPixmap)
+exaAssertNotDirty(PixmapPtr pPixmap)
 {
-    ExaPixmapPriv (pPixmap);
+    ExaPixmapPriv(pPixmap);
     CARD8 *dst, *src;
     RegionRec ValidReg;
     int dst_pitch, src_pitch, cpp, y, nbox, save_pitch;
@@ -529,15 +542,14 @@ exaAssertNotDirty (PixmapPtr pPixmap)
     Bool ret = TRUE, save_use_gpu_copy;
 
     if (exaPixmapIsPinned(pPixmap) || pExaPixmap->area == NULL)
-	return ret;
+        return ret;
 
     RegionNull(&ValidReg);
-    RegionIntersect(&ValidReg, &pExaPixmap->validFB,
-		     &pExaPixmap->validSys);
+    RegionIntersect(&ValidReg, &pExaPixmap->validFB, &pExaPixmap->validSys);
     nbox = RegionNumRects(&ValidReg);
 
     if (!nbox)
-	goto out;
+        goto out;
 
     pBox = RegionRects(&ValidReg);
 
@@ -551,41 +563,42 @@ exaAssertNotDirty (PixmapPtr pPixmap)
     pPixmap->devKind = pExaPixmap->fb_pitch;
 
     if (!ExaDoPrepareAccess(pPixmap, EXA_PREPARE_SRC))
-	goto skip;
+        goto skip;
 
     while (nbox--) {
-	    int rowbytes;
-
-	    pBox->x1 = max(pBox->x1, 0);
-	    pBox->y1 = max(pBox->y1, 0);
-	    pBox->x2 = min(pBox->x2, pPixmap->drawable.width);
-	    pBox->y2 = min(pBox->y2, pPixmap->drawable.height);
-
-	    if (pBox->x1 >= pBox->x2 || pBox->y1 >= pBox->y2)
-		continue;
-
-	    rowbytes = (pBox->x2 - pBox->x1) * cpp;
-	    src = (CARD8 *) pPixmap->devPrivate.ptr + pBox->y1 * src_pitch + pBox->x1 * cpp;
-	    dst = pExaPixmap->sys_ptr + pBox->y1 * dst_pitch + pBox->x1 * cpp;
-
-	    for (y = pBox->y1; y < pBox->y2;
-		 y++, src += src_pitch, dst += dst_pitch) {
-		if (memcmp(dst, src, rowbytes) != 0) {
-		    ret = FALSE;
-		    exaPixmapDirty(pPixmap, pBox->x1, pBox->y1, pBox->x2,
-				   pBox->y2);
-		    break;
-		}
-	    }
+        int rowbytes;
+
+        pBox->x1 = max(pBox->x1, 0);
+        pBox->y1 = max(pBox->y1, 0);
+        pBox->x2 = min(pBox->x2, pPixmap->drawable.width);
+        pBox->y2 = min(pBox->y2, pPixmap->drawable.height);
+
+        if (pBox->x1 >= pBox->x2 || pBox->y1 >= pBox->y2)
+            continue;
+
+        rowbytes = (pBox->x2 - pBox->x1) * cpp;
+        src =
+            (CARD8 *) pPixmap->devPrivate.ptr + pBox->y1 * src_pitch +
+            pBox->x1 * cpp;
+        dst = pExaPixmap->sys_ptr + pBox->y1 * dst_pitch + pBox->x1 * cpp;
+
+        for (y = pBox->y1; y < pBox->y2;
+             y++, src += src_pitch, dst += dst_pitch) {
+            if (memcmp(dst, src, rowbytes) != 0) {
+                ret = FALSE;
+                exaPixmapDirty(pPixmap, pBox->x1, pBox->y1, pBox->x2, pBox->y2);
+                break;
+            }
+        }
     }
 
-skip:
+ skip:
     exaFinishAccess(&pPixmap->drawable, EXA_PREPARE_SRC);
 
     pExaPixmap->use_gpu_copy = save_use_gpu_copy;
     pPixmap->devKind = save_pitch;
 
-out:
+ out:
     RegionUninit(&ValidReg);
     return ret;
 }
@@ -596,9 +609,10 @@ out:
  * config file.
  */
 void
-exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
+exaDoMigration_classic(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
 {
     ScreenPtr pScreen = pixmaps[0].pPix->drawable.pScreen;
+
     ExaScreenPriv(pScreen);
     int i, j;
 
@@ -610,117 +624,118 @@ exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
      * to the pixmap last shouldn't be hard.
      */
     if (pExaScr->checkDirtyCorrectness) {
-	for (i = 0; i < npixmaps; i++) {
-	    if (!exaPixmapIsDirty (pixmaps[i].pPix) &&
-		!exaAssertNotDirty (pixmaps[i].pPix))
-		ErrorF("%s: Pixmap %d dirty but not marked as such!\n", __func__, i);
-	}
+        for (i = 0; i < npixmaps; i++) {
+            if (!exaPixmapIsDirty(pixmaps[i].pPix) &&
+                !exaAssertNotDirty(pixmaps[i].pPix))
+                ErrorF("%s: Pixmap %d dirty but not marked as such!\n",
+                       __func__, i);
+        }
     }
     /* If anything is pinned in system memory, we won't be able to
      * accelerate.
      */
     for (i = 0; i < npixmaps; i++) {
-	if (exaPixmapIsPinned (pixmaps[i].pPix) &&
-	    !exaPixmapHasGpuCopy (pixmaps[i].pPix))
-	{
-	    EXA_FALLBACK(("Pixmap %p (%dx%d) pinned in sys\n", pixmaps[i].pPix,
-		      pixmaps[i].pPix->drawable.width,
-		      pixmaps[i].pPix->drawable.height));
-	    can_accel = FALSE;
-	    break;
-	}
+        if (exaPixmapIsPinned(pixmaps[i].pPix) &&
+            !exaPixmapHasGpuCopy(pixmaps[i].pPix)) {
+            EXA_FALLBACK(("Pixmap %p (%dx%d) pinned in sys\n", pixmaps[i].pPix,
+                          pixmaps[i].pPix->drawable.width,
+                          pixmaps[i].pPix->drawable.height));
+            can_accel = FALSE;
+            break;
+        }
     }
 
     if (pExaScr->migration == ExaMigrationSmart) {
-	/* If we've got something as a destination that we shouldn't cause to
-	 * become newly dirtied, take the unaccelerated route.
-	 */
-	for (i = 0; i < npixmaps; i++) {
-	    if (pixmaps[i].as_dst && !exaPixmapShouldBeInFB (pixmaps[i].pPix) &&
-		!exaPixmapIsDirty (pixmaps[i].pPix))
-	    {
-		for (i = 0; i < npixmaps; i++) {
-		    if (!exaPixmapIsDirty (pixmaps[i].pPix))
-			exaDoMoveOutPixmap (pixmaps + i);
-		}
-		return;
-	    }
-	}
-
-	/* If we aren't going to accelerate, then we migrate everybody toward
-	 * system memory, and kick out if it's free.
-	 */
-	if (!can_accel) {
-	    for (i = 0; i < npixmaps; i++) {
-		exaMigrateTowardSys (pixmaps + i);
-		if (!exaPixmapIsDirty (pixmaps[i].pPix))
-		    exaDoMoveOutPixmap (pixmaps + i);
-	    }
-	    return;
-	}
-
-	/* Finally, the acceleration path.  Move them all in. */
-	for (i = 0; i < npixmaps; i++) {
-	    exaMigrateTowardFb(pixmaps + i);
-	    exaDoMoveInPixmap(pixmaps + i);
-	}
-    } else if (pExaScr->migration == ExaMigrationGreedy) {
-	/* If we can't accelerate, either because the driver can't or because one of
-	 * the pixmaps is pinned in system memory, then we migrate everybody toward
-	 * system memory.
-	 *
-	 * We also migrate toward system if all pixmaps involved are currently in
-	 * system memory -- this can mitigate thrashing when there are significantly
-	 * more pixmaps active than would fit in memory.
-	 *
-	 * If not, then we migrate toward FB so that hopefully acceleration can
-	 * happen.
-	 */
-	if (!can_accel) {
-	    for (i = 0; i < npixmaps; i++)
-		exaMigrateTowardSys (pixmaps + i);
-	    return;
-	}
-
-	for (i = 0; i < npixmaps; i++) {
-	    if (exaPixmapHasGpuCopy(pixmaps[i].pPix)) {
-		/* Found one in FB, so move all to FB. */
-		for (j = 0; j < npixmaps; j++)
-		    exaMigrateTowardFb(pixmaps + i);
-		return;
-	    }
-	}
-
-	/* Nobody's in FB, so move all away from FB. */
-	for (i = 0; i < npixmaps; i++)
-	    exaMigrateTowardSys(pixmaps + i);
-    } else if (pExaScr->migration == ExaMigrationAlways) {
-	/* Always move the pixmaps out if we can't accelerate.  If we can
-	 * accelerate, try to move them all in.  If that fails, then move them
-	 * back out.
-	 */
-	if (!can_accel) {
-	    for (i = 0; i < npixmaps; i++)
-		exaDoMoveOutPixmap(pixmaps + i);
-	    return;
-	}
-
-	/* Now, try to move them all into FB */
-	for (i = 0; i < npixmaps; i++) {
-	    exaDoMoveInPixmap(pixmaps + i);
-	}
-
-	/* If we couldn't fit everything in, abort */
-	for (i = 0; i < npixmaps; i++) {
-	    if (!exaPixmapHasGpuCopy(pixmaps[i].pPix)) {
-		return;
-	    }
-	}
-
-	/* Yay, everything has a gpu copy, mark memory as used */
-	for (i = 0; i < npixmaps; i++) {
-	    ExaOffscreenMarkUsed (pixmaps[i].pPix);
-	}
+        /* If we've got something as a destination that we shouldn't cause to
+         * become newly dirtied, take the unaccelerated route.
+         */
+        for (i = 0; i < npixmaps; i++) {
+            if (pixmaps[i].as_dst && !exaPixmapShouldBeInFB(pixmaps[i].pPix) &&
+                !exaPixmapIsDirty(pixmaps[i].pPix)) {
+                for (i = 0; i < npixmaps; i++) {
+                    if (!exaPixmapIsDirty(pixmaps[i].pPix))
+                        exaDoMoveOutPixmap(pixmaps + i);
+                }
+                return;
+            }
+        }
+
+        /* If we aren't going to accelerate, then we migrate everybody toward
+         * system memory, and kick out if it's free.
+         */
+        if (!can_accel) {
+            for (i = 0; i < npixmaps; i++) {
+                exaMigrateTowardSys(pixmaps + i);
+                if (!exaPixmapIsDirty(pixmaps[i].pPix))
+                    exaDoMoveOutPixmap(pixmaps + i);
+            }
+            return;
+        }
+
+        /* Finally, the acceleration path.  Move them all in. */
+        for (i = 0; i < npixmaps; i++) {
+            exaMigrateTowardFb(pixmaps + i);
+            exaDoMoveInPixmap(pixmaps + i);
+        }
+    }
+    else if (pExaScr->migration == ExaMigrationGreedy) {
+        /* If we can't accelerate, either because the driver can't or because one of
+         * the pixmaps is pinned in system memory, then we migrate everybody toward
+         * system memory.
+         *
+         * We also migrate toward system if all pixmaps involved are currently in
+         * system memory -- this can mitigate thrashing when there are significantly
+         * more pixmaps active than would fit in memory.
+         *
+         * If not, then we migrate toward FB so that hopefully acceleration can
+         * happen.
+         */
+        if (!can_accel) {
+            for (i = 0; i < npixmaps; i++)
+                exaMigrateTowardSys(pixmaps + i);
+            return;
+        }
+
+        for (i = 0; i < npixmaps; i++) {
+            if (exaPixmapHasGpuCopy(pixmaps[i].pPix)) {
+                /* Found one in FB, so move all to FB. */
+                for (j = 0; j < npixmaps; j++)
+                    exaMigrateTowardFb(pixmaps + i);
+                return;
+            }
+        }
+
+        /* Nobody's in FB, so move all away from FB. */
+        for (i = 0; i < npixmaps; i++)
+            exaMigrateTowardSys(pixmaps + i);
+    }
+    else if (pExaScr->migration == ExaMigrationAlways) {
+        /* Always move the pixmaps out if we can't accelerate.  If we can
+         * accelerate, try to move them all in.  If that fails, then move them
+         * back out.
+         */
+        if (!can_accel) {
+            for (i = 0; i < npixmaps; i++)
+                exaDoMoveOutPixmap(pixmaps + i);
+            return;
+        }
+
+        /* Now, try to move them all into FB */
+        for (i = 0; i < npixmaps; i++) {
+            exaDoMoveInPixmap(pixmaps + i);
+        }
+
+        /* If we couldn't fit everything in, abort */
+        for (i = 0; i < npixmaps; i++) {
+            if (!exaPixmapHasGpuCopy(pixmaps[i].pPix)) {
+                return;
+            }
+        }
+
+        /* Yay, everything has a gpu copy, mark memory as used */
+        for (i = 0; i < npixmaps; i++) {
+            ExaOffscreenMarkUsed(pixmaps[i].pPix);
+        }
     }
 }
 
@@ -730,16 +745,17 @@ exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg)
     ExaMigrationRec pixmaps[1];
 
     if (index == EXA_PREPARE_DEST || index == EXA_PREPARE_AUX_DEST) {
-	pixmaps[0].as_dst = TRUE;
-	pixmaps[0].as_src = FALSE;
-    } else {
-	pixmaps[0].as_dst = FALSE;
-	pixmaps[0].as_src = TRUE;
+        pixmaps[0].as_dst = TRUE;
+        pixmaps[0].as_src = FALSE;
+    }
+    else {
+        pixmaps[0].as_dst = FALSE;
+        pixmaps[0].as_src = TRUE;
     }
     pixmaps[0].pPix = pPixmap;
     pixmaps[0].pReg = pReg;
 
     exaDoMigration(pixmaps, 1, FALSE);
 
-    (void)ExaDoPrepareAccess(pPixmap, index);
+    (void) ExaDoPrepareAccess(pPixmap, index);
 }