From 3a5a88ec354de45434b9e037d21cc56c3079f4b2 Mon Sep 17 00:00:00 2001

From: Adam Jackson <ajax@redhat.com>

Date: Wed, 5 Nov 2008 14:59:27 -0500

Subject: [PATCH] Upgrade to master EXA

---

 exa/Makefile.am            |    1 +

 exa/exa.c                  |   95 +++--

 exa/exa.h                  |   19 +-

 exa/exa_accel.c            |  144 ++++++--

 exa/exa_glyphs.c           |  897 ++++++++++++++++++++++++++++++++++++++++++++

 exa/exa_migration.c        |   45 ++-

 exa/exa_priv.h             |   76 +++-

 exa/exa_render.c           |  280 +++++++++++++--

 exa/exa_unaccel.c          |   30 +-

 hw/xfree86/exa/exa.man.pre |    6 -

 hw/xfree86/exa/examodule.c |    9 +-

 11 files changed, 1446 insertions(+), 156 deletions(-)

 create mode 100644 exa/exa_glyphs.c

diff --git a/exa/Makefile.am b/exa/Makefile.am

index e2f7ed3..2b3f1e4 100644

--- a/exa/Makefile.am

+++ b/exa/Makefile.am

@@ -18,6 +18,7 @@ libexa_la_SOURCES = \

 	exa.c \

 	exa.h \

 	exa_accel.c \

+	exa_glyphs.c \

 	exa_migration.c \

 	exa_offscreen.c \

 	exa_render.c \

diff --git a/exa/exa.c b/exa/exa.c

index 72539c0..22f3ab9 100644

--- a/exa/exa.c

+++ b/exa/exa.c

@@ -35,8 +35,6 @@

 #include <stdlib.h>

 #include "exa_priv.h"

-#include <X11/fonts/fontstruct.h>

-#include "dixfontstr.h"

 #include "exa.h"

 #include "cw.h"

@@ -165,7 +163,7 @@ exaPixmapDirty (PixmapPtr pPix, int x1, int y1, int x2, int y2)

     RegionPtr pDamageReg;

     RegionRec region;

-    if (!pExaPixmap)

+    if (!pExaPixmap || !pExaPixmap->pDamage)

 	return;

     box.x1 = max(x1, 0);

@@ -265,6 +263,21 @@ exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,

                                      pExaScr->info->pixmapPitchAlign);

 }

+

+static void

+ExaDamageReport(DamagePtr pDamage, RegionPtr pReg, void *pClosure)

+{

+    PixmapPtr pPixmap = pClosure;

+    ExaPixmapPriv(pPixmap);

+    RegionPtr pDamageReg = DamageRegion(pDamage);

+

+    if (pExaPixmap->pendingDamage) {

+	REGION_UNION(pScreen, pDamageReg, pDamageReg, pReg);

+	pExaPixmap->pendingDamage = FALSE;

+    }

+}

+

+

 /**

  * exaCreatePixmap() creates a new pixmap.

  *

@@ -325,6 +338,7 @@ exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth,

                                        paddedWidth, NULL);

         pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;

         pExaPixmap->fb_ptr = NULL;

+        pExaPixmap->pDamage = NULL;

     } else {

         pExaPixmap->driverPriv = NULL;

         /* Scratch pixmaps may have w/h equal to zero, and may not be

@@ -349,21 +363,22 @@ exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth,

 	     fbDestroyPixmap(pPixmap);

 	     return NULL;

         }

-    }

- 

-    pExaPixmap->area = NULL;

-    /* Set up damage tracking */

-    pExaPixmap->pDamage = DamageCreate (NULL, NULL, DamageReportNone, TRUE,

-					pScreen, pPixmap);

+	/* Set up damage tracking */

+	pExaPixmap->pDamage = DamageCreate (ExaDamageReport, NULL,

+					    DamageReportRawRegion, TRUE,

+					    pScreen, pPixmap);

-    if (pExaPixmap->pDamage == NULL) {

-	fbDestroyPixmap (pPixmap);

-	return NULL;

-    }

+	if (pExaPixmap->pDamage == NULL) {

+	    fbDestroyPixmap (pPixmap);

+	    return NULL;

+	}

-    DamageRegister (&pPixmap->drawable, pExaPixmap->pDamage);

-    DamageSetReportAfterOp (pExaPixmap->pDamage, TRUE);

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

+	DamageSetReportAfterOp (pExaPixmap->pDamage, TRUE);

+    }

+ 

+    pExaPixmap->area = NULL;

     /* None of the pixmap bits are valid initially */

     REGION_NULL(pScreen, &pExaPixmap->validSys);

@@ -660,34 +675,25 @@ exaCreateGC (GCPtr pGC)

     return TRUE;

 }

-void

-exaPrepareAccessWindow(WindowPtr pWin)

+static Bool

+exaChangeWindowAttributes(WindowPtr pWin, unsigned long mask)

 {

-    if (pWin->backgroundState == BackgroundPixmap) 

+    Bool ret;

+

+    if ((mask & CWBackPixmap) && pWin->backgroundState == BackgroundPixmap) 

         exaPrepareAccess(&pWin->background.pixmap->drawable, EXA_PREPARE_SRC);

-    if (pWin->borderIsPixel == FALSE)

-        exaPrepareAccess(&pWin->border.pixmap->drawable, EXA_PREPARE_SRC);

-}

+    if ((mask & CWBorderPixmap) && pWin->borderIsPixel == FALSE)

+        exaPrepareAccess(&pWin->border.pixmap->drawable, EXA_PREPARE_MASK);

-void

-exaFinishAccessWindow(WindowPtr pWin)

-{

-    if (pWin->backgroundState == BackgroundPixmap) 

-        exaFinishAccess(&pWin->background.pixmap->drawable, EXA_PREPARE_SRC);

+    ret = fbChangeWindowAttributes(pWin, mask);

-    if (pWin->borderIsPixel == FALSE)

-        exaFinishAccess(&pWin->border.pixmap->drawable, EXA_PREPARE_SRC);

-}

+    if ((mask & CWBorderPixmap) && pWin->borderIsPixel == FALSE)

+        exaFinishAccess(&pWin->border.pixmap->drawable, EXA_PREPARE_MASK);

-static Bool

-exaChangeWindowAttributes(WindowPtr pWin, unsigned long mask)

-{

-    Bool ret;

+    if ((mask & CWBackPixmap) && pWin->backgroundState == BackgroundPixmap) 

+        exaFinishAccess(&pWin->background.pixmap->drawable, EXA_PREPARE_SRC);

-    exaPrepareAccessWindow(pWin);

-    ret = fbChangeWindowAttributes(pWin, mask);

-    exaFinishAccessWindow(pWin);

     return ret;

 }

@@ -741,6 +747,9 @@ exaCloseScreen(int i, ScreenPtr pScreen)

     PictureScreenPtr	ps = GetPictureScreenIfSet(pScreen);

 #endif

+    if (ps->Glyphs == exaGlyphs)

+	exaGlyphsFini(pScreen);

+

     pScreen->CreateGC = pExaScr->SavedCreateGC;

     pScreen->CloseScreen = pExaScr->SavedCloseScreen;

     pScreen->GetImage = pExaScr->SavedGetImage;

@@ -754,8 +763,9 @@ exaCloseScreen(int i, ScreenPtr pScreen)

 #ifdef RENDER

     if (ps) {

 	ps->Composite = pExaScr->SavedComposite;

+	ps->Glyphs = pExaScr->SavedGlyphs;

 	ps->Trapezoids = pExaScr->SavedTrapezoids;

-	ps->AddTraps = pExaScr->SavedAddTraps;

+	ps->Triangles = pExaScr->SavedTriangles;

     }

 #endif

@@ -917,14 +927,16 @@ exaDriverInit (ScreenPtr		pScreen,

         pExaScr->SavedComposite = ps->Composite;

 	ps->Composite = exaComposite;

+	if (pScreenInfo->PrepareComposite) {

+	    pExaScr->SavedGlyphs = ps->Glyphs;

+	    ps->Glyphs = exaGlyphs;

+	}

+	

 	pExaScr->SavedTriangles = ps->Triangles;

 	ps->Triangles = exaTriangles;

 	pExaScr->SavedTrapezoids = ps->Trapezoids;

 	ps->Trapezoids = exaTrapezoids;

-

-	pExaScr->SavedAddTraps = ps->AddTraps;

-	ps->AddTraps = ExaCheckAddTraps;

     }

 #endif

@@ -978,6 +990,9 @@ exaDriverInit (ScreenPtr		pScreen,

 	}

     }

+    if (ps->Glyphs == exaGlyphs)

+	exaGlyphsInit(pScreen);

+

     LogMessage(X_INFO, "EXA(%d): Driver registered support for the following"

 	       " operations:\n", pScreen->myNum);

     assert(pScreenInfo->PrepareSolid != NULL);

diff --git a/exa/exa.h b/exa/exa.h

index a3dad69..6486bd3 100644

--- a/exa/exa.h

+++ b/exa/exa.h

@@ -744,21 +744,36 @@ typedef struct _ExaDriver {

 /** @} */

+/* in exa.c */

 ExaDriverPtr

 exaDriverAlloc(void);

 Bool

-exaDriverInit(ScreenPtr                pScreen,

+exaDriverInit(ScreenPtr      pScreen,

               ExaDriverPtr   pScreenInfo);

 void

-exaDriverFini(ScreenPtr                pScreen);

+exaDriverFini(ScreenPtr      pScreen);

 void

 exaMarkSync(ScreenPtr pScreen);

 void

 exaWaitSync(ScreenPtr pScreen);

+unsigned long

+exaGetPixmapOffset(PixmapPtr pPix);

+

+unsigned long

+exaGetPixmapPitch(PixmapPtr pPix);

+

+unsigned long

+exaGetPixmapSize(PixmapPtr pPix);

+

+void *

+exaGetPixmapDriverPrivate(PixmapPtr p);

+

+

+/* in exa_offscreen.c */

 ExaOffscreenArea *

 exaOffscreenAlloc(ScreenPtr pScreen, int size, int align,

                   Bool locked,

diff --git a/exa/exa_accel.c b/exa/exa_accel.c

index 3ec9625..1c07a0b 100644

--- a/exa/exa_accel.c

+++ b/exa/exa_accel.c

@@ -144,7 +144,6 @@ exaDoPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,

     ExaScreenPriv (pDrawable->pScreen);

     PixmapPtr pPix = exaGetDrawablePixmap (pDrawable);

     ExaPixmapPriv(pPix);

-    ExaMigrationRec pixmaps[1];

     RegionPtr pClip;

     BoxPtr pbox;

     int nbox;

@@ -166,11 +165,16 @@ exaDoPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,

     if (pExaScr->swappedOut)

 	return FALSE;

-    pixmaps[0].as_dst = TRUE;

-    pixmaps[0].as_src = FALSE;

-    pixmaps[0].pPix = pPix;

-    pixmaps[0].pReg = DamagePendingRegion(pExaPixmap->pDamage);

-    exaDoMigration (pixmaps, 1, TRUE);

+    if (pExaPixmap->pDamage) {

+	ExaMigrationRec pixmaps[1];

+

+ 	pixmaps[0].as_dst = TRUE;

+	pixmaps[0].as_src = FALSE;

+	pixmaps[0].pPix = pPix;

+	pixmaps[0].pReg = DamagePendingRegion(pExaPixmap->pDamage);

+

+	exaDoMigration (pixmaps, 1, TRUE);

+    }

     pPix = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff);

@@ -441,16 +445,36 @@ exaCopyNtoN (DrawablePtr    pSrcDrawable,

     pDstExaPixmap = ExaGetPixmapPriv (pDstPixmap);

     /* Check whether the accelerator can use this pixmap.

-     * FIXME: If it cannot, use temporary pixmaps so that the drawing

-     * happens within limits.

+     * If the pitch of the pixmaps is out of range, there's nothing

+     * we can do but fall back to software rendering.

      */

-    if (pSrcExaPixmap->accel_blocked || pDstExaPixmap->accel_blocked)

-    {

+    if (pSrcExaPixmap->accel_blocked & EXA_RANGE_PITCH ||

+        pDstExaPixmap->accel_blocked & EXA_RANGE_PITCH)

 	goto fallback;

-    } else {

-	exaDoMigration (pixmaps, 2, TRUE);

+

+    /* If the width or the height of either of the pixmaps

+     * is out of range, check whether the boxes are actually out of the

+     * addressable range as well. If they aren't, we can still do

+     * the copying in hardware.

+     */

+    if (pSrcExaPixmap->accel_blocked || pDstExaPixmap->accel_blocked) {

+        int i;

+

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

+            /* src */

+            if ((pbox[i].x2 + dx + src_off_x) >= pExaScr->info->maxX ||

+                (pbox[i].y2 + dy + src_off_y) >= pExaScr->info->maxY)

+                goto fallback;

+

+            /* dst */

+            if ((pbox[i].x2 + dst_off_x) >= pExaScr->info->maxX ||

+                (pbox[i].y2 + dst_off_y) >= pExaScr->info->maxY)

+                goto fallback;

+        }

     }

+    exaDoMigration (pixmaps, 2, TRUE);

+

     /* Mixed directions must be handled specially if the card is lame */

     if ((pExaScr->info->flags & EXA_TWO_BITBLT_DIRECTIONS) &&

 	reverse != upsidedown) {

@@ -860,16 +884,23 @@ exaImageGlyphBlt (DrawablePtr	pDrawable,

     FbBits	    depthMask;

     PixmapPtr	    pPixmap = exaGetDrawablePixmap(pDrawable);

     ExaPixmapPriv(pPixmap);

-    RegionPtr	    pending_damage = DamagePendingRegion(pExaPixmap->pDamage);

-    BoxRec	    extents = *REGION_EXTENTS(pScreen, pending_damage);

+    RegionPtr	    pending_damage = NULL;

+    BoxRec	    extents;

     int		    xoff, yoff;

-    if (extents.x1 >= extents.x2 || extents.y1 >= extents.y2)

-	return;

+    if (pExaPixmap->pDamage)

+	pending_damage = DamagePendingRegion(pExaPixmap->pDamage);

+

+    if (pending_damage) {

+	extents = *REGION_EXTENTS(pScreen, pending_damage);

+

+	if (extents.x1 >= extents.x2 || extents.y1 >= extents.y2)

+	    return;

-    depthMask = FbFullMask(pDrawable->depth);

+	depthMask = FbFullMask(pDrawable->depth);

+    }

-    if ((pGC->planemask & depthMask) != depthMask)

+    if (!pending_damage || (pGC->planemask & depthMask) != depthMask)

     {

 	ExaCheckImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppciInit, pglyphBase);

 	return;

@@ -1103,6 +1134,7 @@ exaFillRegionTiled (DrawablePtr	pDrawable,

     int nbox = REGION_NUM_RECTS (pRegion);

     BoxPtr pBox = REGION_RECTS (pRegion);

     Bool ret = FALSE;

+    int i;

     tileWidth = pTile->drawable.width;

     tileHeight = pTile->drawable.height;

@@ -1125,14 +1157,11 @@ exaFillRegionTiled (DrawablePtr	pDrawable,

     pixmaps[1].pPix = pTile;

     pixmaps[1].pReg = NULL;

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

-    REGION_TRANSLATE(pScreen, pRegion, xoff, yoff);

-

     pExaPixmap = ExaGetPixmapPriv (pPixmap);

     if (pExaPixmap->accel_blocked || pTileExaPixmap->accel_blocked)

     {

-	goto out;

+	return FALSE;

     } else {

 	exaDoMigration (pixmaps, 2, TRUE);

     }

@@ -1140,24 +1169,33 @@ exaFillRegionTiled (DrawablePtr	pDrawable,

     pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff);

     if (!pPixmap || !exaPixmapIsOffscreen(pTile))

-	goto out;

+	return FALSE;

     if ((*pExaScr->info->PrepareCopy) (pTile, pPixmap, 1, 1, alu, planemask))

     {

-	while (nbox--)

+	if (xoff || yoff)

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

+

+	for (i = 0; i < nbox; i++)

 	{

-	    int height = pBox->y2 - pBox->y1;

-	    int dstY = pBox->y1;

+	    int height = pBox[i].y2 - pBox[i].y1;

+	    int dstY = pBox[i].y1;

 	    int tileY;

+	    if (alu == GXcopy)

+		height = min(height, tileHeight);

+

 	    modulus(dstY - yoff - pDrawable->y - pPatOrg->y, tileHeight, tileY);

 	    while (height > 0) {

-		int width = pBox->x2 - pBox->x1;

-		int dstX = pBox->x1;

+		int width = pBox[i].x2 - pBox[i].x1;

+		int dstX = pBox[i].x1;

 		int tileX;

 		int h = tileHeight - tileY;

+		if (alu == GXcopy)

+		    width = min(width, tileWidth);

+

 		if (h > height)

 		    h = height;

 		height -= h;

@@ -1179,17 +1217,57 @@ exaFillRegionTiled (DrawablePtr	pDrawable,

 		dstY += h;

 		tileY = 0;

 	    }

-	    pBox++;

 	}

 	(*pExaScr->info->DoneCopy) (pPixmap);

+

+	/* With GXcopy, we only need to do the basic algorithm up to the tile

+	 * size; then, we can just keep doubling the destination in each

+	 * direction until it fills the box. This way, the number of copy

+	 * operations is O(log(rx)) + O(log(ry)) instead of O(rx * ry), where

+	 * rx/ry is the ratio between box and tile width/height. This can make

+	 * a big difference if each driver copy incurs a significant constant

+	 * overhead.

+	 */

+	if (alu != GXcopy)

+	    ret = TRUE;

+	else if ((*pExaScr->info->PrepareCopy) (pPixmap, pPixmap, 1, 1, alu,

+						planemask)) {

+	    for (i = 0; i < nbox; i++)

+	    {

+		int dstX = pBox[i].x1 + tileWidth;

+		int dstY = pBox[i].y1 + tileHeight;

+		int width = min(pBox[i].x2 - dstX, tileWidth);

+		int height = min(pBox[i].y2 - pBox[i].y1, tileHeight);

+

+		while (dstX < pBox[i].x2) {

+		    (*pExaScr->info->Copy) (pPixmap, pBox[i].x1, pBox[i].y1,

+					    dstX, pBox[i].y1, width, height);

+		    dstX += width;

+		    width = min(pBox[i].x2 - dstX, width * 2);

+		}

+

+		width = pBox[i].x2 - pBox[i].x1;

+		height = min(pBox[i].y2 - dstY, tileHeight);

+

+		while (dstY < pBox[i].y2) {

+		    (*pExaScr->info->Copy) (pPixmap, pBox[i].x1, pBox[i].y1,

+					    pBox[i].x1, dstY, width, height);

+		    dstY += height;

+		    height = min(pBox[i].y2 - dstY, height * 2);

+		}

+	    }

+

+	    (*pExaScr->info->DoneCopy) (pPixmap);

+

+	    ret = TRUE;

+	}

+

 	exaMarkSync(pDrawable->pScreen);

-	ret = TRUE;

+	if (xoff || yoff)

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

     }

-out:

-    REGION_TRANSLATE(pScreen, pRegion, -xoff, -yoff);

-

     return ret;

 }

diff --git a/exa/exa_glyphs.c b/exa/exa_glyphs.c

new file mode 100644

index 0000000..b23e7f6

--- /dev/null

+++ b/exa/exa_glyphs.c

@@ -0,0 +1,897 @@

+/*

+ * Copyright © 2008 Red Hat, Inc.

+ * Partly based on code Copyright © 2000 SuSE, Inc.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Red Hat not be used in advertising or

+ * publicity pertaining to distribution of the software without specific,

+ * written prior permission.  Red Hat makes no representations about the

+ * suitability of this software for any purpose.  It is provided "as is"

+ * without express or implied warranty.

+ *

+ * Red Hat DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL

+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL Red Hat

+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 

+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of SuSE not be used in advertising or

+ * publicity pertaining to distribution of the software without specific,

+ * written prior permission.  SuSE makes no representations about the

+ * suitability of this software for any purpose.  It is provided "as is"

+ * without express or implied warranty.

+ *

+ * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL

+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE

+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 

+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Author: Owen Taylor <otaylor@fishsoup.net>

+ * Based on code by: Keith Packard

+ */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include <stdlib.h>

+

+#include "exa_priv.h"

+

+#include "mipict.h"

+

+#if DEBUG_GLYPH_CACHE

+#define DBG_GLYPH_CACHE(a) ErrorF a

+#else

+#define DBG_GLYPH_CACHE(a)

+#endif

+

+/* Width of the pixmaps we use for the caches; this should be less than

+ * max texture size of the driver; this may need to actually come from

+ * the driver.

+ */

+#define CACHE_PICTURE_WIDTH 1024

+

+/* Maximum number of glyphs we buffer on the stack before flushing

+ * rendering to the mask or destination surface.

+ */

+#define GLYPH_BUFFER_SIZE 256

+

+typedef struct {

+    PicturePtr source;

+    ExaCompositeRectRec rects[GLYPH_BUFFER_SIZE];

+    int count;

+} ExaGlyphBuffer, *ExaGlyphBufferPtr;

+

+typedef enum {

+    ExaGlyphSuccess,    /* Glyph added to render buffer */

+    ExaGlyphFail,       /* out of memory, etc */

+    ExaGlyphNeedFlush,  /* would evict a glyph already in the buffer */

+} ExaGlyphCacheResult;

+

+void

+exaGlyphsInit(ScreenPtr pScreen)

+{

+    ExaScreenPriv(pScreen);

+    int i = 0;

+

+    memset(pExaScr->glyphCaches, 0, sizeof(pExaScr->glyphCaches));

+

+    pExaScr->glyphCaches[i].format = PICT_a8;

+    pExaScr->glyphCaches[i].glyphWidth = pExaScr->glyphCaches[i].glyphHeight = 16;

+    i++;

+    pExaScr->glyphCaches[i].format = PICT_a8;

+    pExaScr->glyphCaches[i].glyphWidth = pExaScr->glyphCaches[i].glyphHeight = 32;

+    i++;

+    pExaScr->glyphCaches[i].format = PICT_a8r8g8b8;

+    pExaScr->glyphCaches[i].glyphWidth = pExaScr->glyphCaches[i].glyphHeight = 16;

+    i++;

+    pExaScr->glyphCaches[i].format = PICT_a8r8g8b8;

+    pExaScr->glyphCaches[i].glyphWidth = pExaScr->glyphCaches[i].glyphHeight = 32;

+    i++;

+

+    assert(i == EXA_NUM_GLYPH_CACHES);

+    

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

+	pExaScr->glyphCaches[i].columns = CACHE_PICTURE_WIDTH / pExaScr->glyphCaches[i].glyphWidth;

+	pExaScr->glyphCaches[i].size = 256;

+	pExaScr->glyphCaches[i].hashSize = 557;

+    }

+}

+

+static void

+exaUnrealizeGlyphCaches(ScreenPtr    pScreen,

+			unsigned int format)

+{

+    ExaScreenPriv(pScreen);

+    int i;

+

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

+	ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];

+	

+	if (cache->format != format)

+	    continue;

+

+	if (cache->picture) {

+	    FreePicture ((pointer) cache->picture, (XID) 0);

+	    cache->picture = NULL;

+	}

+

+	if (cache->hashEntries) {

+	    xfree(cache->hashEntries);

+	    cache->hashEntries = NULL;

+	}

+	

+	if (cache->glyphs) {

+	    xfree(cache->glyphs);

+	    cache->glyphs = NULL;

+	}

+	cache->glyphCount = 0;

+    }

+}

+

+/* All caches for a single format share a single pixmap for glyph storage,

+ * allowing mixing glyphs of different sizes without paying a penalty

+ * for switching between source pixmaps. (Note that for a size of font

+ * right at the border between two sizes, we might be switching for almost

+ * every glyph.)

+ *

+ * This function allocates the storage pixmap, and then fills in the

+ * rest of the allocated structures for all caches with the given format.

+ */

+static Bool

+exaRealizeGlyphCaches(ScreenPtr    pScreen,

+		      unsigned int format)

+{

+    ExaScreenPriv(pScreen);

+

+    int depth = PIXMAN_FORMAT_DEPTH(format);

+    PictFormatPtr pPictFormat;

+    PixmapPtr pPixmap;

+    PicturePtr pPicture;

+    int height;

+    int i;

+    int	error;

+

+    pPictFormat = PictureMatchFormat(pScreen, depth, format);

+    if (!pPictFormat)

+	return FALSE;

+    

+    /* Compute the total vertical size needed for the format */

+

+    height = 0;

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

+	ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];

+	int rows;

+

+	if (cache->format != format)

+	    continue;

+

+	cache->yOffset = height;

+

+	rows = (cache->size + cache->columns - 1) / cache->columns;

+	height += rows * cache->glyphHeight;

+    }

+

+    /* Now allocate the pixmap and picture */

+       

+    pPixmap = (*pScreen->CreatePixmap) (pScreen,

+					CACHE_PICTURE_WIDTH,

+					height, depth, 0);

+    if (!pPixmap)

+	return FALSE;

+

+    pPicture = CreatePicture(0, &pPixmap->drawable, pPictFormat,

+			     0, 0, serverClient, &error);

+

+    (*pScreen->DestroyPixmap) (pPixmap); /* picture holds a refcount */

+

+    if (!pPicture)

+	return FALSE;

+

+    /* And store the picture in all the caches for the format */

+    

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

+	ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];

+	int j;

+

+	if (cache->format != format)

+	    continue;

+

+	cache->picture = pPicture;

+	cache->picture->refcnt++;

+	cache->hashEntries = xalloc(sizeof(int) * cache->hashSize);

+	cache->glyphs = xalloc(sizeof(ExaCachedGlyphRec) * cache->size);

+	cache->glyphCount = 0;

+

+	if (!cache->hashEntries || !cache->glyphs)