svn merge ^/branches/released .

1 files changed, 261 insertions, 270 deletions

diff --git a/xorg-server/exa/exa_migration_mixed.c b/xorg-server/exa/exa_migration_mixed.c
index 4f49905d3..9489b2927 100644
--- a/xorg-server/exa/exa_migration_mixed.c
+++ b/xorg-server/exa/exa_migration_mixed.c
@@ -1,270 +1,261 @@
-/*
- * Copyright © 2009 Maarten Maathuis
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <string.h>
-
-#include "exa_priv.h"
-#include "exa.h"
-
-void
-exaCreateDriverPixmap_mixed(PixmapPtr pPixmap)
-{
-    ScreenPtr pScreen = pPixmap->drawable.pScreen;
-    ExaScreenPriv(pScreen);
-    ExaPixmapPriv(pPixmap);
-    int w = pPixmap->drawable.width, h = pPixmap->drawable.height;
-    int depth = pPixmap->drawable.depth, bpp = pPixmap->drawable.bitsPerPixel;
-    int usage_hint = pPixmap->usage_hint;
-    int paddedWidth = pExaPixmap->sys_pitch;
-
-    /* Already done. */
-    if (pExaPixmap->driverPriv)
-	return;
-
-    if (exaPixmapIsPinned(pPixmap))
-	return;
-
-    /* Can't accel 1/4 bpp. */
-    if (pExaPixmap->accel_blocked || bpp < 8)
-	return;
-
-    if (pExaScr->info->CreatePixmap2) {
-	int new_pitch = 0;
-        pExaPixmap->driverPriv = pExaScr->info->CreatePixmap2(pScreen, w, h, depth, usage_hint, bpp, &new_pitch);
-	paddedWidth = pExaPixmap->fb_pitch = new_pitch;
-    } else {
-	if (paddedWidth < pExaPixmap->fb_pitch)
-	    paddedWidth = pExaPixmap->fb_pitch;
-	pExaPixmap->driverPriv = pExaScr->info->CreatePixmap(pScreen, paddedWidth*h, 0);
-    }
-
-    if (!pExaPixmap->driverPriv)
-	return;
-
-    (*pScreen->ModifyPixmapHeader)(pPixmap, w, h, 0, 0,
-				paddedWidth, NULL);
-}
-
-void
-exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
-{
-    int 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))
-	{
-	    can_accel = FALSE;
-	    break;
-	}
-    }
-
-    /* We can do nothing. */
-    if (!can_accel)
-	return;
-
-    for (i = 0; i < npixmaps; i++) {
-	PixmapPtr pPixmap = pixmaps[i].pPix;
-	ExaPixmapPriv(pPixmap);
-
-	if (!pExaPixmap->driverPriv)
-	    exaCreateDriverPixmap_mixed(pPixmap);
-
-	if (pExaPixmap->pDamage && exaPixmapHasGpuCopy(pPixmap)) {
-	    ExaScreenPriv(pPixmap->drawable.pScreen);
-
-	    /* This pitch is needed for proper acceleration. For some reason
-	     * there are pixmaps without pDamage and a bad fb_pitch value.
-	     * So setting devKind when only exaPixmapHasGpuCopy() is true
-	     * causes corruption. Pixmaps without pDamage are not migrated
-	     * and should have a valid devKind at all times, so that's why this
-	     * isn't causing problems. Pixmaps have their gpu pitch set the
-	     * first time in the MPH call from exaCreateDriverPixmap_mixed().
-	     */
-	    pPixmap->devKind = pExaPixmap->fb_pitch;
-	    exaCopyDirtyToFb(pixmaps + i);
-
-	    if (pExaScr->deferred_mixed_pixmap == pPixmap &&
-		!pixmaps[i].as_dst && !pixmaps[i].pReg)
-		pExaScr->deferred_mixed_pixmap = NULL;
-	}
-
-	pExaPixmap->use_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
-    }
-}
-
-void
-exaMoveInPixmap_mixed(PixmapPtr pPixmap)
-{
-    ExaMigrationRec pixmaps[1];
-
-    pixmaps[0].as_dst = FALSE;
-    pixmaps[0].as_src = TRUE;
-    pixmaps[0].pPix = pPixmap;
-    pixmaps[0].pReg = NULL;
-
-    exaDoMigration(pixmaps, 1, TRUE);
-}
-
-void
-exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure)
-{
-    PixmapPtr pPixmap = closure;
-    ScreenPtr pScreen = pPixmap->drawable.pScreen;
-    ExaPixmapPriv(pPixmap);
-
-    /* Move back results of software rendering on system memory copy of mixed driver
-     * pixmap (see exaPrepareAccessReg_mixed).
-     *
-     * Defer moving the destination back into the driver pixmap, to try and save
-     * overhead on multiple subsequent software fallbacks.
-     */
-    if (!pExaPixmap->use_gpu_copy && exaPixmapHasGpuCopy(pPixmap)) {
-	ExaScreenPriv(pPixmap->drawable.pScreen);
-
-	/* Front buffer: Don't wait for the block handler to copy back the data.
-	 * This avoids annoying latency if you encounter a lot of software rendering.
-	 */
-	if (pPixmap == pScreen->GetScreenPixmap(pScreen))
-		exaMoveInPixmap_mixed(pPixmap);
-	else {
-		if (pExaScr->deferred_mixed_pixmap &&
-		    pExaScr->deferred_mixed_pixmap != pPixmap)
-		    exaMoveInPixmap_mixed(pExaScr->deferred_mixed_pixmap);
-
-		pExaScr->deferred_mixed_pixmap = pPixmap;
-	}
-    }
-}
-
-/* With mixed pixmaps, if we fail to get direct access to the driver pixmap, we
- * use the DownloadFromScreen hook to retrieve contents to a copy in system
- * memory, perform software rendering on that and move back the results with the
- * UploadToScreen hook (see exaDamageReport_mixed).
- */
-void
-exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
-{
-    ExaPixmapPriv(pPixmap);
-    Bool has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
-    Bool success;
-
-    success = ExaDoPrepareAccess(pPixmap, index);
-
-    if (success && has_gpu_copy && pExaPixmap->pDamage) {
-	/* You cannot do accelerated operations while a buffer is mapped. */
-	exaFinishAccess(&pPixmap->drawable, index);
-	/* Update the gpu view of both deferred destination pixmaps and of
-	 * source pixmaps that were migrated with a bounding region.
-	 */
-	exaMoveInPixmap_mixed(pPixmap);
-	success = ExaDoPrepareAccess(pPixmap, index);
-
-	if (success) {
-	    /* We have a gpu pixmap that can be accessed, we don't need the cpu
-	     * copy anymore. Drivers that prefer DFS, should fail prepare
-	     * access.
-	     */
-	    DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
-	    DamageDestroy(pExaPixmap->pDamage);
-	    pExaPixmap->pDamage = NULL;
-
-	    free(pExaPixmap->sys_ptr);
-	    pExaPixmap->sys_ptr = NULL;
-
-	    return;
-	}
-    }
-
-    if (!success) {
-	ExaMigrationRec pixmaps[1];
-
-	/* Do we need to allocate our system buffer? */
-	if (!pExaPixmap->sys_ptr) {
-	    pExaPixmap->sys_ptr = malloc(pExaPixmap->sys_pitch *
-					 pPixmap->drawable.height);
-	    if (!pExaPixmap->sys_ptr)
-		FatalError("EXA: malloc failed for size %d bytes\n",
-			   pExaPixmap->sys_pitch * pPixmap->drawable.height);
-	}
-
-	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].pPix = pPixmap;
-	pixmaps[0].pReg = pReg;
-
-	if (!pExaPixmap->pDamage &&
-		(has_gpu_copy || !exaPixmapIsPinned(pPixmap))) {
-	    Bool as_dst = pixmaps[0].as_dst;
-
-	    /* 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);
-
-	    if (has_gpu_copy) {
-		exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
-			       pPixmap->drawable.height);
-
-		/* We don't know which region of the destination will be damaged,
-		 * have to assume all of it
-		 */
-		if (as_dst) {
-		    pixmaps[0].as_dst = FALSE;
-		    pixmaps[0].as_src = TRUE;
-		    pixmaps[0].pReg = NULL;
-		}
-		exaCopyDirtyToSys(pixmaps);
-	    }
-
-	    if (as_dst)
-		exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
-			       pPixmap->drawable.height);
-	} else if (has_gpu_copy)
-	    exaCopyDirtyToSys(pixmaps);
-
-	pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
-	pPixmap->devKind = pExaPixmap->sys_pitch;
-	pExaPixmap->use_gpu_copy = FALSE;
-    }
-}
-
+/*

+ * Copyright © 2009 Maarten Maathuis

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include <string.h>

+

+#include "exa_priv.h"

+#include "exa.h"

+

+void

+exaCreateDriverPixmap_mixed(PixmapPtr pPixmap)

+{

+    ScreenPtr pScreen = pPixmap->drawable.pScreen;

+    ExaScreenPriv(pScreen);

+    ExaPixmapPriv(pPixmap);

+    int w = pPixmap->drawable.width, h = pPixmap->drawable.height;

+    int depth = pPixmap->drawable.depth, bpp = pPixmap->drawable.bitsPerPixel;

+    int usage_hint = pPixmap->usage_hint;

+    int paddedWidth = pExaPixmap->sys_pitch;

+

+    /* Already done. */

+    if (pExaPixmap->driverPriv)

+	return;

+

+    if (exaPixmapIsPinned(pPixmap))

+	return;

+

+    /* Can't accel 1/4 bpp. */

+    if (pExaPixmap->accel_blocked || bpp < 8)

+	return;

+

+    if (pExaScr->info->CreatePixmap2) {

+	int new_pitch = 0;

+        pExaPixmap->driverPriv = pExaScr->info->CreatePixmap2(pScreen, w, h, depth, usage_hint, bpp, &new_pitch);

+	paddedWidth = pExaPixmap->fb_pitch = new_pitch;

+    } else {

+	if (paddedWidth < pExaPixmap->fb_pitch)

+	    paddedWidth = pExaPixmap->fb_pitch;

+	pExaPixmap->driverPriv = pExaScr->info->CreatePixmap(pScreen, paddedWidth*h, 0);

+    }

+

+    if (!pExaPixmap->driverPriv)

+	return;

+

+    (*pScreen->ModifyPixmapHeader)(pPixmap, w, h, 0, 0,

+				paddedWidth, NULL);

+}

+

+void

+exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)

+{

+    int 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))

+	{

+	    can_accel = FALSE;

+	    break;

+	}

+    }

+

+    /* We can do nothing. */

+    if (!can_accel)

+	return;

+

+    for (i = 0; i < npixmaps; i++) {

+	PixmapPtr pPixmap = pixmaps[i].pPix;

+	ExaPixmapPriv(pPixmap);

+

+	if (!pExaPixmap->driverPriv)

+	    exaCreateDriverPixmap_mixed(pPixmap);

+

+	if (pExaPixmap->pDamage && exaPixmapHasGpuCopy(pPixmap)) {

+	    ExaScreenPriv(pPixmap->drawable.pScreen);

+

+	    /* This pitch is needed for proper acceleration. For some reason

+	     * there are pixmaps without pDamage and a bad fb_pitch value.

+	     * So setting devKind when only exaPixmapHasGpuCopy() is true

+	     * causes corruption. Pixmaps without pDamage are not migrated

+	     * and should have a valid devKind at all times, so that's why this

+	     * isn't causing problems. Pixmaps have their gpu pitch set the

+	     * first time in the MPH call from exaCreateDriverPixmap_mixed().

+	     */

+	    pPixmap->devKind = pExaPixmap->fb_pitch;

+	    exaCopyDirtyToFb(pixmaps + i);

+

+	    if (pExaScr->deferred_mixed_pixmap == pPixmap &&

+		!pixmaps[i].as_dst && !pixmaps[i].pReg)

+		pExaScr->deferred_mixed_pixmap = NULL;

+	}

+

+	pExaPixmap->use_gpu_copy = exaPixmapHasGpuCopy(pPixmap);

+    }

+}

+

+void

+exaMoveInPixmap_mixed(PixmapPtr pPixmap)

+{

+    ExaMigrationRec pixmaps[1];

+

+    pixmaps[0].as_dst = FALSE;

+    pixmaps[0].as_src = TRUE;

+    pixmaps[0].pPix = pPixmap;

+    pixmaps[0].pReg = NULL;

+

+    exaDoMigration(pixmaps, 1, TRUE);

+}

+

+void

+exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure)

+{

+    PixmapPtr pPixmap = closure;

+    ExaPixmapPriv(pPixmap);

+

+    /* Move back results of software rendering on system memory copy of mixed driver

+     * pixmap (see exaPrepareAccessReg_mixed).

+     *

+     * Defer moving the destination back into the driver pixmap, to try and save

+     * overhead on multiple subsequent software fallbacks.

+     */

+    if (!pExaPixmap->use_gpu_copy && exaPixmapHasGpuCopy(pPixmap)) {

+	ExaScreenPriv(pPixmap->drawable.pScreen);

+

+	if (pExaScr->deferred_mixed_pixmap &&

+	    pExaScr->deferred_mixed_pixmap != pPixmap)

+	    exaMoveInPixmap_mixed(pExaScr->deferred_mixed_pixmap);

+	pExaScr->deferred_mixed_pixmap = pPixmap;

+    }

+}

+

+/* With mixed pixmaps, if we fail to get direct access to the driver pixmap, we

+ * use the DownloadFromScreen hook to retrieve contents to a copy in system

+ * memory, perform software rendering on that and move back the results with the

+ * UploadToScreen hook (see exaDamageReport_mixed).

+ */

+void

+exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)

+{

+    ExaPixmapPriv(pPixmap);

+    Bool has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);

+    Bool success;

+

+    success = ExaDoPrepareAccess(pPixmap, index);

+

+    if (success && has_gpu_copy && pExaPixmap->pDamage) {

+	/* You cannot do accelerated operations while a buffer is mapped. */

+	exaFinishAccess(&pPixmap->drawable, index);

+	/* Update the gpu view of both deferred destination pixmaps and of

+	 * source pixmaps that were migrated with a bounding region.

+	 */

+	exaMoveInPixmap_mixed(pPixmap);

+	success = ExaDoPrepareAccess(pPixmap, index);

+

+	if (success) {

+	    /* We have a gpu pixmap that can be accessed, we don't need the cpu

+	     * copy anymore. Drivers that prefer DFS, should fail prepare

+	     * access.

+	     */

+	    DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);

+	    DamageDestroy(pExaPixmap->pDamage);

+	    pExaPixmap->pDamage = NULL;

+

+	    free(pExaPixmap->sys_ptr);

+	    pExaPixmap->sys_ptr = NULL;

+

+	    return;

+	}

+    }

+

+    if (!success) {

+	ExaMigrationRec pixmaps[1];

+

+	/* Do we need to allocate our system buffer? */

+	if (!pExaPixmap->sys_ptr) {

+	    pExaPixmap->sys_ptr = malloc(pExaPixmap->sys_pitch *

+					 pPixmap->drawable.height);

+	    if (!pExaPixmap->sys_ptr)

+		FatalError("EXA: malloc failed for size %d bytes\n",

+			   pExaPixmap->sys_pitch * pPixmap->drawable.height);

+	}

+

+	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].pPix = pPixmap;

+	pixmaps[0].pReg = pReg;

+

+	if (!pExaPixmap->pDamage &&

+		(has_gpu_copy || !exaPixmapIsPinned(pPixmap))) {

+	    Bool as_dst = pixmaps[0].as_dst;

+

+	    /* 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);

+

+	    if (has_gpu_copy) {

+		exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,

+			       pPixmap->drawable.height);

+

+		/* We don't know which region of the destination will be damaged,

+		 * have to assume all of it

+		 */

+		if (as_dst) {

+		    pixmaps[0].as_dst = FALSE;

+		    pixmaps[0].as_src = TRUE;

+		    pixmaps[0].pReg = NULL;

+		}

+		exaCopyDirtyToSys(pixmaps);

+	    }

+

+	    if (as_dst)

+		exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,

+			       pPixmap->drawable.height);

+	} else if (has_gpu_copy)

+	    exaCopyDirtyToSys(pixmaps);

+

+	pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;

+	pPixmap->devKind = pExaPixmap->sys_pitch;

+	pExaPixmap->use_gpu_copy = FALSE;

+    }

+}

+