1 files changed, 112 insertions, 109 deletions

diff --git a/xorg-server/exa/exa_mixed.c b/xorg-server/exa/exa_mixed.c
index 0b1a4a4a4..06817313f 100644
--- a/xorg-server/exa/exa_mixed.c
+++ b/xorg-server/exa/exa_mixed.c
@@ -34,7 +34,7 @@
 /* This file holds the driver allocated pixmaps + better initial placement code.
  */
 
-static _X_INLINE void*
+static _X_INLINE void *
 ExaGetPixmapAddress(PixmapPtr p)
 {
     ExaPixmapPriv(p);
@@ -47,16 +47,17 @@ ExaGetPixmapAddress(PixmapPtr p)
  */
 PixmapPtr
 exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
-		unsigned usage_hint)
+                      unsigned usage_hint)
 {
     PixmapPtr pPixmap;
-    ExaPixmapPrivPtr	pExaPixmap;
+    ExaPixmapPrivPtr pExaPixmap;
     int bpp;
     size_t paddedWidth;
+
     ExaScreenPriv(pScreen);
 
     if (w > 32767 || h > 32767)
-	return NullPixmap;
+        return NullPixmap;
 
     swap(pExaScr, pScreen, CreatePixmap);
     pPixmap = pScreen->CreatePixmap(pScreen, 0, 0, depth, usage_hint);
@@ -84,45 +85,44 @@ exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
     pExaPixmap->pDamage = NULL;
 
     exaSetFbPitch(pExaScr, pExaPixmap, w, h, bpp);
-    exaSetAccelBlock(pExaScr, pExaPixmap,
-	w, h, bpp);
+    exaSetAccelBlock(pExaScr, pExaPixmap, w, h, bpp);
 
-    (*pScreen->ModifyPixmapHeader)(pPixmap, w, h, 0, 0,
-				    paddedWidth, NULL);
+    (*pScreen->ModifyPixmapHeader) (pPixmap, w, h, 0, 0, paddedWidth, NULL);
 
     /* A scratch pixmap will become a driver pixmap right away. */
     if (!w || !h) {
-	exaCreateDriverPixmap_mixed(pPixmap);
-	pExaPixmap->use_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
-    } else {
-	pExaPixmap->use_gpu_copy = FALSE;
-
-	if (w == 1 && h == 1) {
-	    pExaPixmap->sys_ptr = malloc(paddedWidth);
-
-	    /* Set up damage tracking */
-	    pExaPixmap->pDamage = DamageCreate(exaDamageReport_mixed, NULL,
-					       DamageReportNonEmpty, TRUE,
-					       pPixmap->drawable.pScreen,
-					       pPixmap);
-
-	    DamageRegister(&pPixmap->drawable, pExaPixmap->pDamage);
-	    /* This ensures that pending damage reflects the current operation. */
-	    /* This is used by exa to optimize migration. */
-	    DamageSetReportAfterOp(pExaPixmap->pDamage, TRUE);
-	}
+        exaCreateDriverPixmap_mixed(pPixmap);
+        pExaPixmap->use_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
+    }
+    else {
+        pExaPixmap->use_gpu_copy = FALSE;
+
+        if (w == 1 && h == 1) {
+            pExaPixmap->sys_ptr = malloc(paddedWidth);
+
+            /* Set up damage tracking */
+            pExaPixmap->pDamage = DamageCreate(exaDamageReport_mixed, NULL,
+                                               DamageReportNonEmpty, TRUE,
+                                               pPixmap->drawable.pScreen,
+                                               pPixmap);
+
+            DamageRegister(&pPixmap->drawable, pExaPixmap->pDamage);
+            /* This ensures that pending damage reflects the current operation. */
+            /* This is used by exa to optimize migration. */
+            DamageSetReportAfterOp(pExaPixmap->pDamage, TRUE);
+        }
     }
 
     /* During a fallback we must prepare access. */
     if (pExaScr->fallback_counter)
-	exaPrepareAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);
+        exaPrepareAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);
 
     return pPixmap;
 }
 
 Bool
 exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
-		      int bitsPerPixel, int devKind, pointer pPixData)
+                            int bitsPerPixel, int devKind, pointer pPixData)
 {
     ScreenPtr pScreen;
     ExaScreenPrivPtr pExaScr;
@@ -137,100 +137,102 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
     pExaPixmap = ExaGetPixmapPriv(pPixmap);
 
     if (pPixData) {
-	if (pExaPixmap->driverPriv) {
-	    if (pExaPixmap->pDamage) {
-		DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
-		DamageDestroy(pExaPixmap->pDamage);
-		pExaPixmap->pDamage = NULL;
-	    }
-
-	    pExaScr->info->DestroyPixmap(pScreen, pExaPixmap->driverPriv);
-	    pExaPixmap->driverPriv = NULL;
-	}
-
-	pExaPixmap->use_gpu_copy = FALSE;
-	pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
+        if (pExaPixmap->driverPriv) {
+            if (pExaPixmap->pDamage) {
+                DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
+                DamageDestroy(pExaPixmap->pDamage);
+                pExaPixmap->pDamage = NULL;
+            }
+
+            pExaScr->info->DestroyPixmap(pScreen, pExaPixmap->driverPriv);
+            pExaPixmap->driverPriv = NULL;
+        }
+
+        pExaPixmap->use_gpu_copy = FALSE;
+        pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
     }
 
     has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
 
     if (width <= 0)
-	width = pPixmap->drawable.width;
+        width = pPixmap->drawable.width;
 
     if (height <= 0)
-	height = pPixmap->drawable.height;
+        height = pPixmap->drawable.height;
 
     if (bitsPerPixel <= 0) {
-	if (depth <= 0)
-	    bitsPerPixel = pPixmap->drawable.bitsPerPixel;
-	else
-	    bitsPerPixel = BitsPerPixel(depth);
+        if (depth <= 0)
+            bitsPerPixel = pPixmap->drawable.bitsPerPixel;
+        else
+            bitsPerPixel = BitsPerPixel(depth);
     }
 
     if (depth <= 0)
-	depth = pPixmap->drawable.depth;
+        depth = pPixmap->drawable.depth;
 
     if (width != pPixmap->drawable.width ||
-	height != pPixmap->drawable.height ||
-	depth != pPixmap->drawable.depth ||
-	bitsPerPixel != pPixmap->drawable.bitsPerPixel) {
-	if (pExaPixmap->driverPriv) {
-	    if (devKind > 0)
-		pExaPixmap->fb_pitch = devKind;
-	    else
-		exaSetFbPitch(pExaScr, pExaPixmap, width, height, bitsPerPixel);
-
-            exaSetAccelBlock(pExaScr, pExaPixmap,
-                             width, height, bitsPerPixel);
+        height != pPixmap->drawable.height ||
+        depth != pPixmap->drawable.depth ||
+        bitsPerPixel != pPixmap->drawable.bitsPerPixel) {
+        if (pExaPixmap->driverPriv) {
+            if (devKind > 0)
+                pExaPixmap->fb_pitch = devKind;
+            else
+                exaSetFbPitch(pExaScr, pExaPixmap, width, height, bitsPerPixel);
+
+            exaSetAccelBlock(pExaScr, pExaPixmap, width, height, bitsPerPixel);
             RegionEmpty(&pExaPixmap->validFB);
         }
 
-	/* Need to re-create system copy if there's also a GPU copy */
-	if (has_gpu_copy) {
-	    if (pExaPixmap->sys_ptr) {
-		free(pExaPixmap->sys_ptr);
-		pExaPixmap->sys_ptr = NULL;
-		DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
-		DamageDestroy(pExaPixmap->pDamage);
-		pExaPixmap->pDamage = NULL;
-		RegionEmpty(&pExaPixmap->validSys);
-
-		if (pExaScr->deferred_mixed_pixmap == pPixmap)
-		    pExaScr->deferred_mixed_pixmap = NULL;
-	    }
-
-	    pExaPixmap->sys_pitch = PixmapBytePad(width, depth);
-	}
+        /* Need to re-create system copy if there's also a GPU copy */
+        if (has_gpu_copy) {
+            if (pExaPixmap->sys_ptr) {
+                free(pExaPixmap->sys_ptr);
+                pExaPixmap->sys_ptr = NULL;
+                DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
+                DamageDestroy(pExaPixmap->pDamage);
+                pExaPixmap->pDamage = NULL;
+                RegionEmpty(&pExaPixmap->validSys);
+
+                if (pExaScr->deferred_mixed_pixmap == pPixmap)
+                    pExaScr->deferred_mixed_pixmap = NULL;
+            }
+
+            pExaPixmap->sys_pitch = PixmapBytePad(width, depth);
+        }
     }
 
     if (has_gpu_copy) {
-	pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
-	pPixmap->devKind = pExaPixmap->fb_pitch;
-    } else {
-	pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
-	pPixmap->devKind = pExaPixmap->sys_pitch;
+        pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
+        pPixmap->devKind = pExaPixmap->fb_pitch;
+    }
+    else {
+        pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
+        pPixmap->devKind = pExaPixmap->sys_pitch;
     }
 
     /* Only pass driver pixmaps to the driver. */
     if (pExaScr->info->ModifyPixmapHeader && pExaPixmap->driverPriv) {
-	ret = pExaScr->info->ModifyPixmapHeader(pPixmap, width, height, depth,
-						bitsPerPixel, devKind, pPixData);
-	if (ret == TRUE)
-	    goto out;
+        ret = pExaScr->info->ModifyPixmapHeader(pPixmap, width, height, depth,
+                                                bitsPerPixel, devKind,
+                                                pPixData);
+        if (ret == TRUE)
+            goto out;
     }
 
     swap(pExaScr, pScreen, ModifyPixmapHeader);
     ret = pScreen->ModifyPixmapHeader(pPixmap, width, height, depth,
-					    bitsPerPixel, devKind, pPixData);
+                                      bitsPerPixel, devKind, pPixData);
     swap(pExaScr, pScreen, ModifyPixmapHeader);
 
-out:
+ out:
     if (has_gpu_copy) {
-	pExaPixmap->fb_ptr = pPixmap->devPrivate.ptr;
-	pExaPixmap->fb_pitch = pPixmap->devKind;
-    } else {
-	pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;
-	pExaPixmap->sys_pitch = pPixmap->devKind;
+        pExaPixmap->fb_ptr = pPixmap->devPrivate.ptr;
+        pExaPixmap->fb_pitch = pPixmap->devKind;
+    }
+    else {
+        pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;
+        pExaPixmap->sys_pitch = pPixmap->devKind;
     }
     /* Always NULL this, we don't want lingering pointers. */
     pPixmap->devPrivate.ptr = NULL;
@@ -241,32 +243,32 @@ out:
 Bool
 exaDestroyPixmap_mixed(PixmapPtr pPixmap)
 {
-    ScreenPtr	pScreen = pPixmap->drawable.pScreen;
+    ScreenPtr pScreen = pPixmap->drawable.pScreen;
+
     ExaScreenPriv(pScreen);
     Bool ret;
 
-    if (pPixmap->refcnt == 1)
-    {
-	ExaPixmapPriv (pPixmap);
+    if (pPixmap->refcnt == 1) {
+        ExaPixmapPriv(pPixmap);
 
-	exaDestroyPixmap(pPixmap);
+        exaDestroyPixmap(pPixmap);
 
-	if (pExaScr->deferred_mixed_pixmap == pPixmap)
-	    pExaScr->deferred_mixed_pixmap = NULL;
+        if (pExaScr->deferred_mixed_pixmap == pPixmap)
+            pExaScr->deferred_mixed_pixmap = NULL;
 
-	if (pExaPixmap->driverPriv)
-	    pExaScr->info->DestroyPixmap(pScreen, pExaPixmap->driverPriv);
-	pExaPixmap->driverPriv = NULL;
+        if (pExaPixmap->driverPriv)
+            pExaScr->info->DestroyPixmap(pScreen, pExaPixmap->driverPriv);
+        pExaPixmap->driverPriv = NULL;
 
-	if (pExaPixmap->pDamage) {
-	    free(pExaPixmap->sys_ptr);
-	    pExaPixmap->sys_ptr = NULL;
-	    pExaPixmap->pDamage = NULL;
-	}
+        if (pExaPixmap->pDamage) {
+            free(pExaPixmap->sys_ptr);
+            pExaPixmap->sys_ptr = NULL;
+            pExaPixmap->pDamage = NULL;
+        }
     }
 
     swap(pExaScr, pScreen, DestroyPixmap);
-    ret = pScreen->DestroyPixmap (pPixmap);
+    ret = pScreen->DestroyPixmap(pPixmap);
     swap(pExaScr, pScreen, DestroyPixmap);
 
     return ret;
@@ -276,13 +278,14 @@ Bool
 exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap)
 {
     ScreenPtr pScreen = pPixmap->drawable.pScreen;
+
     ExaScreenPriv(pScreen);
     ExaPixmapPriv(pPixmap);
     pointer saved_ptr;
     Bool ret;
 
     if (!pExaPixmap->driverPriv)
-	return FALSE;
+        return FALSE;
 
     saved_ptr = pPixmap->devPrivate.ptr;
     pPixmap->devPrivate.ptr = ExaGetPixmapAddress(pPixmap);