drv: add imped pict back in

5 files changed, 438 insertions, 6 deletions

diff --git a/drv/Makefile.am b/drv/Makefile.am
index 51d107108..bbf0c23fa 100644
--- a/drv/Makefile.am
+++ b/drv/Makefile.am
@@ -32,4 +32,5 @@ libdrv_la_SOURCES = 	\
 	drv_picture.c \
 	drv_damage.c \
 	impedscrn.c \
-	impedgc.c
+	impedgc.c \
+	impedpict.c
diff --git a/drv/drv_imped.h b/drv/drv_imped.h
index cc52b2040..3b14b5c7c 100644
--- a/drv/drv_imped.h
+++ b/drv/drv_imped.h
@@ -6,6 +6,7 @@
 #include "scrnintstr.h"
 #include "pixmapstr.h"
 #include "gcstruct.h"
+#include "picturestr.h"
 /*
  * XFree86 empties the root BorderClip when the VT is inactive,
  * here's a macro which uses that to disable GetImage and GetSpans
@@ -23,15 +24,16 @@ typedef struct _impedPixmapPriv {
 
 typedef struct _impedGCPriv {
   DrvGCPtr gpu[MAX_GPU];
-} impedGCPrivRec;
+} impedGCPrivRec, *impedGCPrivPtr;
 
 typedef struct _impedPicturePriv {
   DrvPicturePtr gpu[MAX_GPU];
-} impedPicturePrivRec, *impedGCPrivPtr;
+} impedPictPrivRec, *impedPictPrivPtr;
 
 DevPrivateKey impedGetScreenPrivKey(void);
 DevPrivateKey impedGetPixmapPrivKey(void);
 DevPrivateKey impedGetGCPrivKey(void);
+DevPrivateKey impedGetPictPrivKey(void);
 
 static inline impedScreenPrivPtr impedGetScreen(ScreenPtr pScreen)
 {
@@ -48,6 +50,11 @@ static inline impedGCPrivPtr impedGetGC(GCPtr pGC)
     return dixLookupPrivate(&pGC->devPrivates, impedGetGCPrivKey());
 }
 
+static inline impedGCPrivPtr impedGetPict(PicturePtr pPicture)
+{
+    return dixLookupPrivate(&pPicture->devPrivates, impedGetPictPrivKey());
+}
+
 #define impedWindowEnabled(pWin) \
     RegionNotEmpty(&(pWin)->drawable.pScreen->root->borderClip)
 
diff --git a/drv/drv_impedpict.h b/drv/drv_impedpict.h
new file mode 100644
index 000000000..8596a3d4f
--- /dev/null
+++ b/drv/drv_impedpict.h
@@ -0,0 +1,6 @@
+
+#ifndef IMPED_PICT_H
+#define IMPED_PICT_H
+extern _X_EXPORT Bool impedPictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats);
+
+#endif
diff --git a/drv/impedpict.c b/drv/impedpict.c
new file mode 100644
index 000000000..19c30ac2e
--- /dev/null
+++ b/drv/impedpict.c
@@ -0,0 +1,415 @@
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <string.h>
+
+#include "fb.h"
+
+#include "picturestr.h"
+#include "mipict.h"
+#include "drv_imped.h"
+#include "drv_impedpict.h"
+
+#include "drv_picturestr.h"
+#include "drv_scrnintstr.h"
+#include "drv_pixmapstr.h"
+
+
+static void SyncDrvPicture(PicturePtr pPicture, DrvPicturePtr pDrvPicture,
+			   int index)
+{
+    pDrvPicture->repeat = pPicture->repeat;
+    pDrvPicture->polyEdge = pPicture->polyEdge;
+    pDrvPicture->polyMode = pPicture->polyMode;
+    pDrvPicture->repeatType = pPicture->repeatType;
+    pDrvPicture->filter = pPicture->filter;
+    pDrvPicture->componentAlpha = pPicture->componentAlpha;
+
+    pDrvPicture->transform = pPicture->transform;
+
+    pDrvPicture->pSourcePict = pPicture->pSourcePict;
+    if (pPicture->pNext) {
+	impedPictPrivPtr imped_next = impedGetPict(pPicture->pNext);
+	pDrvPicture->pNext = imped_next->gpu[index];
+    }
+    if (pPicture->alphaMap) {
+	impedPictPrivPtr imped_alphamap = impedGetPict(pPicture->alphaMap);
+	pDrvPicture->alphaMap = imped_alphamap->gpu[index];
+    }
+
+    if (!pDrvPicture->pCompositeClip)
+	pDrvPicture->pCompositeClip = RegionCreate(NullBox, 0);
+
+    if (pPicture->pCompositeClip)
+	RegionCopy(pDrvPicture->pCompositeClip, pPicture->pCompositeClip);
+    else
+	RegionNull(pDrvPicture->pCompositeClip);
+
+}
+
+static Bool CreateSourcePict(PicturePtr pPicture, PictureScreenPtr ps)
+{
+    impedPictPrivPtr imped_pict = impedGetPict(pPicture);
+
+    if (!imped_pict->gpu[0]) {
+	imped_pict->gpu[0] = DrvCreatePicture(NULL, pPicture->pFormat, 0, NULL);
+	if (!imped_pict->gpu[0])
+	    return FALSE;
+    }
+    return TRUE;
+}
+
+static int
+impedCreatePicture (PicturePtr pPicture)
+{
+    PictureScreenPtr ps;
+    int i;
+    PixmapPtr pPixmap;
+    impedPictPrivPtr imped_pict = impedGetPict(pPicture);
+    impedPixmapPrivPtr imped_pixmap;
+    ps = GetPictureScreen(pPicture->pDrawable->pScreen);
+
+    pPixmap = GetDrawablePixmap(pPicture->pDrawable);
+    
+    imped_pixmap = impedGetPixmap(pPixmap);
+    imped_pict->gpu[0] = DrvCreatePicture(imped_pixmap->gpu[0], pPicture->pFormat,
+					0, 0);
+
+    if (!imped_pict->gpu[0])
+      ErrorF("no gpu 0 picture\n");
+    SyncDrvPicture(pPicture, imped_pict->gpu[0], 0);
+    return 0;
+}
+
+static void
+impedComposite (CARD8      op,
+		PicturePtr pSrc,
+		PicturePtr pMask,
+		PicturePtr pDst,
+		INT16      xSrc,
+		INT16      ySrc,
+		INT16      xMask,
+		INT16      yMask,
+		INT16      xDst,
+		INT16      yDst,
+		CARD16     width,
+		CARD16     height)
+{
+    int x_off, y_off;
+    PixmapPtr pSrcPixmap = NULL, pDstPixmap, pMaskPixmap = NULL;
+    DrvPicturePtr pDrvSrc, pDrvMask = NULL, pDrvDst;
+    ScreenPtr pScreen = pDst->pDrawable->pScreen;
+    PictureScreenPtr ps = GetPictureScreen(pDst);
+    impedScreenPrivPtr imped_screen = impedGetScreen(pScreen);
+    DrvPictureScreenPtr drv_ps = DrvGetPictureScreen(imped_screen->gpu[0]);
+    impedPictPrivPtr imped_src;
+    impedPictPrivPtr imped_mask;
+    impedPictPrivPtr imped_dst;
+    impedPixmapPrivPtr imped_src_pixmap, imped_mask_pixmap, imped_dst_pixmap;
+
+    if (pSrc->pDrawable) {
+	pSrcPixmap = GetDrawablePixmap(pSrc->pDrawable);
+	imped_src_pixmap = impedGetPixmap(pSrcPixmap);
+    } 
+    else {
+	Bool ret;
+	ret = CreateSourcePict(pSrc, ps);
+	if (!ret)
+	    return;
+    }
+    imped_src = impedGetPict(pSrc);
+	
+    if (pMask) {
+	imped_mask = impedGetPict(pMask);
+	pMaskPixmap = GetDrawablePixmap(pMask->pDrawable);
+	imped_mask_pixmap = impedGetPixmap(pMaskPixmap);
+    }
+    imped_dst = impedGetPict(pDst);
+    pDstPixmap = GetDrawablePixmap(pDst->pDrawable);
+    imped_dst_pixmap = impedGetPixmap(pDstPixmap);
+
+    miCompositeSourceValidate (pSrc);
+    if (pMask)
+	miCompositeSourceValidate (pMask);
+
+    if (pSrc->pDrawable) {
+	impedGetDrawableDeltas(pSrc->pDrawable, pSrcPixmap, &x_off, &y_off);
+	xSrc += x_off;
+	ySrc += y_off;
+    }
+
+    if (pMask) {
+	impedGetDrawableDeltas(pMask->pDrawable, pMaskPixmap, &x_off, &y_off);
+	xMask += x_off;
+	yMask += y_off;
+    }
+
+    impedGetDrawableDeltas(pDst->pDrawable, pDstPixmap, &x_off, &y_off);
+    xDst += x_off;
+    yDst += y_off;
+
+    pDrvSrc = imped_src->gpu[0];
+    SyncDrvPicture(pSrc, pDrvSrc, 0);
+    if (pMask) {
+	pDrvMask = imped_mask->gpu[0];
+	SyncDrvPicture(pMask, pDrvMask, 0);
+    }
+    pDrvDst = imped_dst->gpu[0];
+    SyncDrvPicture(pDst, pDrvDst, 0);
+
+    if (pSrcPixmap)
+	pDrvSrc->pPixmap = imped_src_pixmap->gpu[0];
+    if (pDrvMask)
+	pDrvMask->pPixmap = imped_mask_pixmap->gpu[0];
+    pDrvDst->pPixmap = imped_dst_pixmap->gpu[0];
+
+    drv_ps->Composite(op, pDrvSrc, pDrvMask, pDrvDst,
+		      xSrc, ySrc, xMask, yMask,
+		      xDst, yDst, width, height);
+}
+
+static void
+impedRasterizeTrapezoid (PicturePtr    pPicture,
+			 xTrapezoid  *trap,
+			 int	    x_off,
+			 int	    y_off)
+{
+    PixmapPtr pPixmap = GetDrawablePixmap(pPicture->pDrawable);
+    impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pPixmap);
+    impedPictPrivPtr imped_picture = impedGetPict(pPicture);
+    DrvPicturePtr pDrvPicture;
+    impedScreenPrivPtr imped_screen = impedGetScreen(pPicture->pDrawable->pScreen);
+    DrvPictureScreenPtr drv_ps;
+
+    pDrvPicture = imped_picture->gpu[0];
+    pDrvPicture->pPixmap = imped_pixmap->gpu[0];
+    drv_ps = DrvGetPictureScreen(imped_screen->gpu[0]);
+    drv_ps->RasterizeTrapezoid(pDrvPicture, trap, x_off, y_off);
+}
+
+static void
+impedAddTraps (PicturePtr	pPicture,
+	       INT16	x_off,
+	       INT16	y_off,
+	       int		ntrap,
+	       xTrap	*traps)
+{
+    DrvPictureScreenPtr drv_ps;
+    impedScreenPrivPtr imped_screen = impedGetScreen(pPicture->pDrawable->pScreen);
+    PixmapPtr pPixmap = GetDrawablePixmap(pPicture->pDrawable);
+    DrvPicturePtr pDrvPicture;
+    impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pPixmap);
+    impedPictPrivPtr imped_picture = impedGetPict(pPicture);
+    pDrvPicture = imped_picture->gpu[0];
+    pDrvPicture->pPixmap = imped_pixmap->gpu[0];
+    drv_ps = DrvGetPictureScreen(imped_screen->gpu[0]);
+    drv_ps->AddTraps(pDrvPicture, x_off, y_off, ntrap, traps);
+}
+
+static void
+impedTrapezoids (CARD8	    op,
+		 PicturePtr    pSrc,
+		 PicturePtr    pDst,
+		 PictFormatPtr maskFormat,
+		 INT16	    xSrc,
+		 INT16	    ySrc,
+		 int	    ntrap,
+		 xTrapezoid    *traps)
+{
+    impedScreenPrivPtr imped_screen = impedGetScreen(pDst->pDrawable->pScreen);
+    DrvPictureScreenPtr drv_ps = DrvGetPictureScreen(imped_screen->gpu[0]);
+    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);
+    PixmapPtr pSrcPixmap = NULL, pDstPixmap;
+    DrvPicturePtr pDrvSrc = NULL, pDrvDst;
+    impedPictPrivPtr imped_src = NULL, imped_dst;
+    impedPixmapPrivPtr imped_src_pixmap = NULL, imped_dst_pixmap;
+    int i;
+    int x_off, y_off;
+    Bool ret;
+
+    if (pSrc) {
+	if (pSrc->pDrawable) {
+	    pSrcPixmap = GetDrawablePixmap(pSrc->pDrawable);
+	    imped_src_pixmap = impedGetPixmap(pSrcPixmap);
+	    impedGetDrawableDeltas(pSrc->pDrawable, pSrcPixmap, &x_off, &y_off);
+	    xSrc += x_off;
+	    ySrc += y_off;
+	} else {
+	    ret = CreateSourcePict(pSrc, ps);
+	    if (!ret)
+		return;
+	}
+    }
+    
+    pDstPixmap = GetDrawablePixmap(pDst->pDrawable);
+    imped_dst_pixmap = impedGetPixmap(pDstPixmap);
+    impedGetDrawableDeltas(pDst->pDrawable, pDstPixmap, &x_off, &y_off);
+    if (x_off || y_off) {
+    	for (i = 0; i < ntrap; i++) {
+	    traps[i].top += y_off << 16;
+	    traps[i].bottom += y_off << 16;
+	    traps[i].left.p1.x += x_off << 16;
+	    traps[i].left.p1.y += y_off << 16;
+	    traps[i].left.p2.x += x_off << 16;
+	    traps[i].left.p2.y += y_off << 16;
+	    traps[i].right.p1.x += x_off << 16;
+	    traps[i].right.p1.y += y_off << 16;
+	    traps[i].right.p2.x += x_off << 16;
+	    traps[i].right.p2.y += y_off << 16;
+	}
+    }
+
+    if (pSrc) {
+	imped_src = impedGetPict(pSrc);
+	pDrvSrc = imped_src->gpu[0];
+	if (imped_src_pixmap)
+	    pDrvSrc->pPixmap = imped_src_pixmap->gpu[0];
+	if (pDrvSrc)
+	    SyncDrvPicture(pSrc, pDrvSrc, 0);
+    }
+    imped_dst = impedGetPict(pDst);
+    pDrvDst = imped_dst->gpu[0];
+    pDrvDst->pPixmap = imped_dst_pixmap->gpu[0];
+    SyncDrvPicture(pDst, pDrvDst, 0);
+
+    drv_ps->Trapezoids(op, pDrvSrc, pDrvDst, maskFormat, xSrc, ySrc, ntrap, traps);
+}
+
+static void
+impedAddTriangles (PicturePtr  pPicture,
+		   INT16	    x_off_orig,
+		   INT16	    y_off_orig,
+		   int	    ntri,
+		   xTriangle *tris)
+{
+    impedScreenPrivPtr imped_screen = impedGetScreen(pPicture->pDrawable->pScreen);
+    DrvPictureScreenPtr drv_ps = DrvGetPictureScreen(imped_screen->gpu[0]);
+    impedPictPrivPtr imped_picture = impedGetPict(pPicture);
+    int x_off, y_off;
+    PixmapPtr pPixmap = GetDrawablePixmap(pPicture->pDrawable);
+    impedPixmapPrivPtr imped_pixmap = impedGetPixmap(pPixmap);
+    DrvPicturePtr pDrvPicture;
+
+    impedGetDrawableDeltas(pPicture->pDrawable, pPixmap, &x_off, &y_off);
+    x_off_orig += x_off;
+    y_off_orig += y_off;
+    pDrvPicture = imped_picture->gpu[0];
+    pDrvPicture->pPixmap = imped_pixmap->gpu[0];
+    drv_ps->AddTriangles(pDrvPicture, x_off_orig, y_off_orig, ntri, tris);
+}
+
+static void
+impedTriangles (CARD8	    op,
+		PicturePtr    pSrc,
+		PicturePtr    pDst,
+		PictFormatPtr maskFormat,
+		INT16	    xSrc,
+		INT16	    ySrc,
+		int	    ntris,
+		xTriangle    *tris)
+{
+    impedScreenPrivPtr imped_screen = impedGetScreen(pDst->pDrawable->pScreen);
+    DrvPictureScreenPtr drv_ps = DrvGetPictureScreen(imped_screen->gpu[0]);
+    int x_off, y_off, i;
+    PixmapPtr pSrcPixmap, pDstPixmap;
+    DrvPicturePtr pDrvSrc = NULL, pDrvDst;
+    impedPixmapPrivPtr imped_src_pixmap, imped_dst_pixmap;
+    impedPictPrivPtr imped_src, imped_dst;
+
+    imped_src = impedGetPict(pSrc);
+    pSrcPixmap = GetDrawablePixmap(pSrc->pDrawable);
+    imped_src_pixmap = impedGetPixmap(pSrcPixmap);
+    impedGetDrawableDeltas(pSrc->pDrawable, pSrcPixmap, &x_off, &y_off);
+    xSrc += x_off;
+    ySrc += y_off;
+
+    imped_dst = impedGetPict(pDst);
+    pDstPixmap = GetDrawablePixmap(pDst->pDrawable);
+    imped_dst_pixmap = impedGetPixmap(pDstPixmap);
+    impedGetDrawableDeltas(pSrc->pDrawable, pSrcPixmap, &x_off, &y_off);
+    if (x_off || y_off) {
+	for (i = 0; i < ntris; i++) {
+	    tris[i].p1.x += x_off << 16;
+	    tris[i].p1.y += y_off << 16;
+	    tris[i].p2.x += x_off << 16;
+	    tris[i].p2.y += y_off << 16;
+	    tris[i].p3.x += x_off << 16;
+	    tris[i].p3.y += y_off << 16;
+	}
+    }
+
+    pDrvSrc = imped_src->gpu[0];
+    pDrvSrc->pPixmap = imped_src_pixmap->gpu[0];
+    pDrvDst = imped_dst->gpu[0];
+    pDrvDst->pPixmap = imped_dst_pixmap->gpu[0];
+
+    SyncDrvPicture(pSrc, pDrvSrc, 0);
+    SyncDrvPicture(pDst, pDrvDst, 0);
+    drv_ps->Triangles(op, pDrvSrc, pDrvDst, maskFormat, xSrc, ySrc, ntris, tris);
+}
+
+static void
+impedGlyphs(CARD8      op,
+	    PicturePtr pSrc,
+	    PicturePtr pDst,
+	    PictFormatPtr  maskFormat,
+	    INT16      xSrc,
+	    INT16      ySrc,
+	    int	nlists,
+	    GlyphListPtr   lists,
+	    GlyphPtr	*glyphs)
+{
+    impedScreenPrivPtr imped_screen = impedGetScreen(pDst->pDrawable->pScreen);
+    DrvPictureScreenPtr drv_ps = DrvGetPictureScreen(imped_screen->gpu[0]);
+    PixmapPtr pSrcPixmap, pDstPixmap;
+    int x_off, y_off;
+    DrvPicturePtr pDrvSrc = NULL, pDrvDst;
+    impedPixmapPrivPtr imped_src_pixmap, imped_dst_pixmap;
+    impedPictPrivPtr imped_src, imped_dst;
+
+    imped_src = impedGetPict(pSrc);
+    pSrcPixmap = GetDrawablePixmap(pSrc->pDrawable);
+    imped_src_pixmap = impedGetPixmap(pSrcPixmap);
+    impedGetDrawableDeltas(pSrc->pDrawable, pSrcPixmap, &x_off, &y_off);
+    xSrc += x_off;
+    ySrc += y_off;
+
+    imped_dst = impedGetPict(pDst);
+    pDstPixmap = GetDrawablePixmap(pDst->pDrawable);
+    imped_dst_pixmap = impedGetPixmap(pDstPixmap);
+    impedGetDrawableDeltas(pDst->pDrawable, pDstPixmap, &x_off, &y_off);
+
+    pDrvSrc = imped_src->gpu[0];
+    pDrvSrc->pPixmap = imped_src_pixmap->gpu[0];
+    pDrvDst = imped_dst->gpu[0];
+    pDrvDst->pPixmap = imped_dst_pixmap->gpu[0];
+
+    SyncDrvPicture(pSrc, pDrvSrc, 0);
+    SyncDrvPicture(pDst, pDrvDst, 0);
+    drv_ps->Glyphs(op, pDrvSrc, pDrvDst, maskFormat, xSrc, ySrc, nlists, lists, glyphs, 0);
+
+}
+
+Bool
+impedPictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
+{
+    PictureScreenPtr ps;
+
+    if (!miPictureInit (pScreen, formats, nformats))
+	return FALSE;
+
+    ps = GetPictureScreen(pScreen);
+
+    ps->CreatePicture = impedCreatePicture;
+    ps->Composite = impedComposite;
+    ps->RasterizeTrapezoid = impedRasterizeTrapezoid;
+    ps->AddTraps = impedAddTraps;
+    ps->Trapezoids = impedTrapezoids;
+    ps->AddTriangles = impedAddTriangles;
+    ps->Triangles = impedTriangles;
+    ps->Glyphs = impedGlyphs;
+    return TRUE;
+}
+
diff --git a/drv/impedscrn.c b/drv/impedscrn.c
index 848c547be..088f7a526 100644
--- a/drv/impedscrn.c
+++ b/drv/impedscrn.c
@@ -20,7 +20,7 @@ DevPrivateKeyRec drvZeroLineScreenKeyRec;
 DevPrivateKeyRec impedScreenPrivateKeyRec;
 DevPrivateKeyRec impedPixmapPrivateKeyRec;
 DevPrivateKeyRec impedGCPrivateKeyRec;
-DevPrivateKeyRec impedPicturePrivateKeyRec;
+DevPrivateKeyRec impedPictPrivateKeyRec;
 
 DevPrivateKey
 impedGetScreenPrivKey(void) { return &impedScreenPrivateKeyRec; }
@@ -31,6 +31,9 @@ impedGetPixmapPrivKey(void) { return &impedPixmapPrivateKeyRec; }
 DevPrivateKey
 impedGetGCPrivKey(void) { return &impedGCPrivateKeyRec; }
 
+DevPrivateKey
+impedGetPictPrivKey(void) { return &impedPictPrivateKeyRec; }
+
 static DevPrivateKeyRec impedWinPrivateKeyRec;
 static DevPrivateKey
 impedGetWinPrivateKey (void) { return &impedWinPrivateKeyRec; }
@@ -58,8 +61,8 @@ impedAllocatePrivates(ScreenPtr pScreen, DevPrivateKey *pGCKey)
 			       sizeof(impedGCPrivRec)))
         return FALSE;
 
-    if (!dixRegisterPrivateKey(&impedPicturePrivateKeyRec, PRIVATE_PICTURE,
-			       sizeof(impedPicturePrivRec)))
+    if (!dixRegisterPrivateKey(&impedPictPrivateKeyRec, PRIVATE_PICTURE,
+			       sizeof(impedPictPrivRec)))
         return FALSE;
 
     return TRUE;