svn merge ^/branches/released

1 files changed, 277 insertions, 70 deletions

diff --git a/xorg-server/exa/exa_unaccel.c b/xorg-server/exa/exa_unaccel.c
index 510d89af6..adbee8413 100644
--- a/xorg-server/exa/exa_unaccel.c
+++ b/xorg-server/exa/exa_unaccel.c
@@ -123,11 +123,36 @@ ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst,  GCPtr pGC,
 	     BoxPtr	pbox, int nbox, int dx, int dy, Bool	reverse, 

 	     Bool upsidedown, Pixel bitplane, void *closure)

 {

+    RegionRec reg;

+    int xoff, yoff;

     EXA_PRE_FALLBACK_GC(pGC);

     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,

 		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));

-    exaPrepareAccess (pDst, EXA_PREPARE_DEST);

-    exaPrepareAccess (pSrc, EXA_PREPARE_SRC);

+

+    if (pExaScr->prepare_access_reg) {

+	PixmapPtr pPixmap = exaGetDrawablePixmap(pSrc);

+

+	exaGetDrawableDeltas(pSrc, pPixmap, &xoff, &yoff);

+	REGION_INIT(pScreen, &reg, pbox, nbox);

+	REGION_TRANSLATE(pScreen, &reg, xoff + dx, yoff + dy);

+	pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_SRC, &reg);

+	REGION_UNINIT(pScreen, &reg);

+    } else

+	exaPrepareAccess (pSrc, EXA_PREPARE_SRC);

+

+    if (pExaScr->prepare_access_reg &&

+	!exaGCReadsDestination(pDst, pGC->planemask, pGC->fillStyle,

+			       pGC->alu, pGC->clientClipType)) {

+	PixmapPtr pPixmap = exaGetDrawablePixmap(pDst);

+

+	exaGetDrawableDeltas(pSrc, pPixmap, &xoff, &yoff);

+	REGION_INIT(pScreen, &reg, pbox, nbox);

+	REGION_TRANSLATE(pScreen, &reg, xoff, yoff);

+	pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_DEST, &reg);

+	REGION_UNINIT(pScreen, &reg);

+    } else

+	exaPrepareAccess (pDst, EXA_PREPARE_DEST);

+

     /* This will eventually call fbCopyNtoN, with some calculation overhead. */

     while (nbox--) {

 	pGC->ops->CopyArea (pSrc, pDst, pGC, pbox->x1 - pSrc->x + dx, pbox->y1 - pSrc->y + dy, 

@@ -139,6 +164,40 @@ ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst,  GCPtr pGC,
     EXA_POST_FALLBACK_GC(pGC);

 }

 

+static void

+ExaFallbackPrepareReg(DrawablePtr pDrawable,

+		      GCPtr pGC,

+		      int x, int y, int width, int height,

+		      int index, Bool checkReads)

+{

+    ScreenPtr pScreen = pDrawable->pScreen;

+    ExaScreenPriv(pScreen);

+

+    if (pExaScr->prepare_access_reg &&

+	!(checkReads && exaGCReadsDestination(pDrawable,

+					      pGC->planemask,

+					      pGC->fillStyle,

+					      pGC->alu,

+					      pGC->clientClipType))) {

+	BoxRec box;

+	RegionRec reg;

+	int xoff, yoff;

+	PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);

+

+	exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);

+	box.x1 = pDrawable->x + x + xoff;

+	box.y1 = pDrawable->y + y + yoff;

+	box.x2 = box.x1 + width;

+	box.y2 = box.y1 + height;

+

+	REGION_INIT(pScreen, &reg, &box, 1);

+	pExaScr->prepare_access_reg(pPixmap, index, &reg);

+	REGION_UNINIT(pScreen, &reg);

+    } else

+	exaPrepareAccess(pDrawable, index);

+}

+

+

 RegionPtr

 ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,

 		 int srcx, int srcy, int w, int h, int dstx, int dsty)

@@ -148,8 +207,10 @@ ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
     EXA_PRE_FALLBACK_GC(pGC);

     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,

 		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));

-    exaPrepareAccess (pDst, EXA_PREPARE_DEST);

-    exaPrepareAccess (pSrc, EXA_PREPARE_SRC);

+    ExaFallbackPrepareReg(pSrc, pGC, srcx, srcy, w, h,

+			  EXA_PREPARE_SRC, FALSE);

+    ExaFallbackPrepareReg(pDst, pGC, dstx, dsty, w, h,

+			  EXA_PREPARE_DEST, TRUE);

     ret = pGC->ops->CopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty);

     exaFinishAccess (pSrc, EXA_PREPARE_SRC);

     exaFinishAccess (pDst, EXA_PREPARE_DEST);

@@ -168,8 +229,10 @@ ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
     EXA_PRE_FALLBACK_GC(pGC);

     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,

 		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));

-    exaPrepareAccess (pDst, EXA_PREPARE_DEST);

-    exaPrepareAccess (pSrc, EXA_PREPARE_SRC);

+    ExaFallbackPrepareReg(pSrc, pGC, srcx, srcy, w, h,

+			  EXA_PREPARE_SRC, FALSE);

+    ExaFallbackPrepareReg(pDst, pGC, dstx, dsty, w, h,

+			  EXA_PREPARE_DEST, TRUE);

     ret = pGC->ops->CopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty,

 		       bitPlane);

     exaFinishAccess (pSrc, EXA_PREPARE_SRC);

@@ -295,8 +358,10 @@ ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,
     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pBitmap, pDrawable,

 		  exaDrawableLocation(&pBitmap->drawable),

 		  exaDrawableLocation(pDrawable)));

-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

-    exaPrepareAccess (&pBitmap->drawable, EXA_PREPARE_SRC);

+    ExaFallbackPrepareReg(pDrawable, pGC, x, y, w, h,

+			  EXA_PREPARE_DEST, TRUE);

+    ExaFallbackPrepareReg(&pBitmap->drawable, pGC, 0, 0, w, h,

+			  EXA_PREPARE_SRC, FALSE);

     exaPrepareAccessGC (pGC);

     pGC->ops->PushPixels (pGC, pBitmap, pDrawable, w, h, x, y);

     exaFinishAccessGC (pGC);

@@ -313,8 +378,18 @@ ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
     EXA_PRE_FALLBACK(pScreen);

     EXA_FALLBACK(("from %p\n", pWin));

 

-    /* being both src and dest, src is safest. */

-    exaPrepareAccess(pDrawable, EXA_PREPARE_SRC);

+    /* Only need the source bits, the destination region will be overwritten */

+    if (pExaScr->prepare_access_reg) {

+	PixmapPtr pPixmap = pScreen->GetWindowPixmap(pWin);

+	int xoff, yoff;

+

+	exaGetDrawableDeltas(&pWin->drawable, pPixmap, &xoff, &yoff);

+	REGION_TRANSLATE(pScreen, prgnSrc, xoff, yoff);

+	pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_SRC, prgnSrc);

+	REGION_TRANSLATE(pScreen, prgnSrc, -xoff, -yoff);

+    } else

+	exaPrepareAccess(pDrawable, EXA_PREPARE_SRC);

+

     swap(pExaScr, pScreen, CopyWindow);

     pScreen->CopyWindow (pWin, ptOldOrg, prgnSrc);

     swap(pExaScr, pScreen, CopyWindow);

@@ -327,29 +402,12 @@ ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
 		unsigned int format, unsigned long planeMask, char *d)

 {

     ScreenPtr pScreen = pDrawable->pScreen;

-    PixmapPtr pPix = exaGetDrawablePixmap (pDrawable);

     EXA_PRE_FALLBACK(pScreen);

     EXA_FALLBACK(("from %p (%c)\n", pDrawable,

 		  exaDrawableLocation(pDrawable)));

 

-    if (pExaScr->prepare_access_reg) {

-	int xoff, yoff;

-	BoxRec Box;

-	RegionRec Reg;

-

-	exaGetDrawableDeltas(pDrawable, pPix, &xoff, &yoff);

-

-	Box.x1 = pDrawable->y + x + xoff;

-	Box.y1 = pDrawable->y + y + yoff;

-	Box.x2 = Box.x1 + w;

-	Box.y2 = Box.y1 + h;

-

-	REGION_INIT(pScreen, &Reg, &Box, 1);

-

-	pExaScr->prepare_access_reg(pPix, EXA_PREPARE_SRC, &Reg);

-    } else

-	exaPrepareAccess(pDrawable, EXA_PREPARE_SRC);

-

+    ExaFallbackPrepareReg(pDrawable, NULL, x, y, w, h,

+			  EXA_PREPARE_SRC, FALSE);

     swap(pExaScr, pScreen, GetImage);

     pScreen->GetImage (pDrawable, x, y, w, h, format, planeMask, d);

     swap(pExaScr, pScreen, GetImage);

@@ -377,6 +435,173 @@ ExaCheckGetSpans (DrawablePtr pDrawable,
     EXA_POST_FALLBACK(pScreen);

 }

 

+static void

+ExaSrcValidate(DrawablePtr pDrawable,

+	       int x,

+	       int y,

+	       int width,

+	       int height)

+{

+    ScreenPtr pScreen = pDrawable->pScreen;

+    ExaScreenPriv(pScreen);

+    PixmapPtr pPix = exaGetDrawablePixmap (pDrawable);

+    BoxRec box;

+    RegionRec reg;

+    RegionPtr dst;

+    int xoff, yoff;

+

+    exaGetDrawableDeltas(pDrawable, pPix, &xoff, &yoff);

+

+    box.x1 = x + xoff;

+    box.y1 = y + yoff;

+    box.x2 = box.x1 + width;

+    box.y2 = box.y1 + height;

+

+    dst = (pExaScr->srcPix == pPix) ? &pExaScr->srcReg :

+	&pExaScr->maskReg;

+

+    REGION_INIT(pScreen, &reg, &box, 1);

+    REGION_UNION(pScreen, dst, dst, &reg);

+    REGION_UNINIT(pScreen, &reg);

+

+    swap(pExaScr, pScreen, SourceValidate);

+    pScreen->SourceValidate(pDrawable, x, y, width, height);

+    swap(pExaScr, pScreen, SourceValidate);

+}

+

+static Bool

+ExaPrepareCompositeReg(ScreenPtr  pScreen,

+		       CARD8      op,

+		       PicturePtr pSrc,

+		       PicturePtr pMask,

+		       PicturePtr pDst,

+		       INT16      xSrc,

+		       INT16      ySrc,

+		       INT16      xMask,

+		       INT16      yMask,

+		       INT16      xDst,

+		       INT16      yDst,

+		       CARD16     width,

+		       CARD16     height)

+{

+    RegionRec region;

+    RegionPtr dstReg = NULL;

+    RegionPtr srcReg = NULL;

+    RegionPtr maskReg = NULL;

+    PixmapPtr pSrcPix = NULL;

+    PixmapPtr pMaskPix = NULL;

+    PixmapPtr pDstPix;

+    ExaScreenPriv(pScreen);

+    Bool ret;

+

+

+    REGION_NULL(pScreen, &region);

+

+    if (pSrc->pDrawable) {

+	pSrcPix = exaGetDrawablePixmap(pSrc->pDrawable);

+	REGION_NULL(pScreen, &pExaScr->srcReg);

+	srcReg = &pExaScr->srcReg;

+	pExaScr->srcPix = pSrcPix;

+	if (pSrc != pDst)

+	    REGION_TRANSLATE(pScreen, pSrc->pCompositeClip,

+			     -pSrc->pDrawable->x,

+			     -pSrc->pDrawable->y);

+    }

+

+    if (pMask && pMask->pDrawable) {

+	pMaskPix = exaGetDrawablePixmap(pMask->pDrawable);

+	REGION_NULL(pScreen, &pExaScr->maskReg);

+	maskReg = &pExaScr->maskReg;

+	if (pMask != pDst && pMask != pSrc)

+	    REGION_TRANSLATE(pScreen, pMask->pCompositeClip,

+			     -pMask->pDrawable->x,

+			     -pMask->pDrawable->y);

+    }

+

+    REGION_TRANSLATE(pScreen, pDst->pCompositeClip,

+		     -pDst->pDrawable->x,

+		     -pDst->pDrawable->y);

+

+    pExaScr->SavedSourceValidate = ExaSrcValidate;

+    swap(pExaScr, pScreen, SourceValidate);

+    ret = miComputeCompositeRegion (&region, pSrc, pMask, pDst,

+				    xSrc, ySrc, xMask, yMask,

+				    xDst,

+				    yDst,

+				    width, height);

+    swap(pExaScr, pScreen, SourceValidate);

+

+    REGION_TRANSLATE(pScreen, pDst->pCompositeClip,

+		     pDst->pDrawable->x,

+		     pDst->pDrawable->y);

+    if (pSrc->pDrawable && pSrc != pDst)

+	REGION_TRANSLATE(pScreen, pSrc->pCompositeClip,

+			 pSrc->pDrawable->x,

+			 pSrc->pDrawable->y);

+    if (pMask && pMask->pDrawable && pMask != pDst && pMask != pSrc)

+	REGION_TRANSLATE(pScreen, pMask->pCompositeClip,

+			 pMask->pDrawable->x,

+			 pMask->pDrawable->y);

+

+    if (!ret) {

+	if (srcReg)

+	    REGION_UNINIT(pScreen, srcReg);

+	if (maskReg)

+	    REGION_UNINIT(pScreen, maskReg);

+

+	return FALSE;

+    }

+

+    /**

+     * Don't limit alphamaps readbacks for now until we've figured out how that

+     * should be done.

+     */

+

+    if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)

+	pExaScr->prepare_access_reg(exaGetDrawablePixmap(pSrc->alphaMap->pDrawable),

+				    EXA_PREPARE_AUX_SRC,

+				    NULL);

+    if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)

+	pExaScr->prepare_access_reg(exaGetDrawablePixmap(pMask->alphaMap->pDrawable),

+				    EXA_PREPARE_AUX_MASK,

+				    NULL);

+

+    if (pSrcPix)

+	pExaScr->prepare_access_reg(pSrcPix,

+				    EXA_PREPARE_SRC,

+				    srcReg);

+

+    if (pMaskPix)

+	pExaScr->prepare_access_reg(pMaskPix,

+				    EXA_PREPARE_MASK,

+				    maskReg);

+

+    if (srcReg)

+	REGION_UNINIT(pScreen, srcReg);

+    if (maskReg)

+	REGION_UNINIT(pScreen, maskReg);

+

+    pDstPix = exaGetDrawablePixmap(pDst->pDrawable);

+    if (!exaOpReadsDestination(op)) {

+	int xoff;

+	int yoff;

+

+	exaGetDrawableDeltas (pDst->pDrawable, pDstPix, &xoff, &yoff);

+	REGION_TRANSLATE(pScreen, &region, pDst->pDrawable->x + xoff,

+			 pDst->pDrawable->y + yoff);

+	dstReg = &region;

+    }

+

+    if (pDst->alphaMap && pDst->alphaMap->pDrawable)

+	pExaScr->prepare_access_reg(exaGetDrawablePixmap(pDst->alphaMap->pDrawable),

+				    EXA_PREPARE_AUX_DEST,

+				    dstReg);

+    pExaScr->prepare_access_reg(pDstPix, EXA_PREPARE_DEST, dstReg);

+

+    REGION_UNINIT(pScreen, &region);

+    return TRUE;

+}

+

 void

 ExaCheckComposite (CARD8      op,

                    PicturePtr pSrc,

@@ -395,54 +620,38 @@ ExaCheckComposite (CARD8      op,
 #ifdef RENDER

     PictureScreenPtr	ps = GetPictureScreen(pScreen);

 #endif /* RENDER */

-    RegionRec region;

-    int xoff, yoff;

     EXA_PRE_FALLBACK(pScreen);

 

-    REGION_NULL(pScreen, &region);

-

-    /* We need to prepare access to any separate alpha maps first, in case the

-     * driver doesn't support EXA_PREPARE_AUX*, in which case EXA_PREPARE_SRC

-     * may be used for moving them out.

-     */

-    if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)

-	exaPrepareAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);

-    if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)

-	exaPrepareAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);

-

-    if (!exaOpReadsDestination(op) && pExaScr->prepare_access_reg) {

-	PixmapPtr pDstPix;

-

-	if (!miComputeCompositeRegion (&region, pSrc, pMask, pDst,

-				       xSrc, ySrc, xMask, yMask,

-				       xDst + pDst->pDrawable->x,

-				       yDst + pDst->pDrawable->y,

-				       width, height))

-	    goto skip;

-

-	pDstPix = exaGetDrawablePixmap(pDst->pDrawable);

-	exaGetDrawableDeltas (pDst->pDrawable, pDstPix, &xoff, &yoff);

-	REGION_TRANSLATE(pScreen, &region, xoff, yoff);

+    if (pExaScr->prepare_access_reg) {

+	if (!ExaPrepareCompositeReg(pScreen, op, pSrc, pMask, pDst, xSrc,

+				   ySrc, xMask, yMask, xDst, yDst, width,

+				   height))

+	    goto out_no_clip;

+    } else {

 

-	if (pDst->alphaMap && pDst->alphaMap->pDrawable)

-	    pExaScr->prepare_access_reg(exaGetDrawablePixmap(pDst->alphaMap->pDrawable),

-					EXA_PREPARE_AUX_DEST, &region);

+	/* We need to prepare access to any separate alpha maps first,

+	 * in case the driver doesn't support EXA_PREPARE_AUX*,

+	 * in which case EXA_PREPARE_SRC may be used for moving them out.

+	 */

 

-	pExaScr->prepare_access_reg(pDstPix, EXA_PREPARE_DEST, &region);

-    } else {

+	if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)

+	    exaPrepareAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);

+	if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)

+	    exaPrepareAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);

 	if (pDst->alphaMap && pDst->alphaMap->pDrawable)

 	    exaPrepareAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);

 

 	exaPrepareAccess (pDst->pDrawable, EXA_PREPARE_DEST);

-    }

 

-    EXA_FALLBACK(("from picts %p/%p to pict %p\n",

-		 pSrc, pMask, pDst));

+	EXA_FALLBACK(("from picts %p/%p to pict %p\n",

+		      pSrc, pMask, pDst));

+

+	if (pSrc->pDrawable != NULL)

+	    exaPrepareAccess (pSrc->pDrawable, EXA_PREPARE_SRC);

+	if (pMask && pMask->pDrawable != NULL)

+	    exaPrepareAccess (pMask->pDrawable, EXA_PREPARE_MASK);

+    }

 

-    if (pSrc->pDrawable != NULL)

-	exaPrepareAccess (pSrc->pDrawable, EXA_PREPARE_SRC);

-    if (pMask && pMask->pDrawable != NULL)

-	exaPrepareAccess (pMask->pDrawable, EXA_PREPARE_MASK);

 #ifdef RENDER

     swap(pExaScr, ps, Composite);

     ps->Composite (op,

@@ -466,14 +675,12 @@ ExaCheckComposite (CARD8      op,
     exaFinishAccess (pDst->pDrawable, EXA_PREPARE_DEST);

     if (pDst->alphaMap && pDst->alphaMap->pDrawable)

 	exaFinishAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);

-

-skip:

     if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)

 	exaFinishAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);

     if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)

 	exaFinishAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);

 

-    REGION_UNINIT(pScreen, &region);

+out_no_clip:

     EXA_POST_FALLBACK(pScreen);

 }