Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 2527 insertions, 2374 deletions

diff --git a/xorg-server/hw/xfree86/xaa/xaaPCache.c b/xorg-server/hw/xfree86/xaa/xaaPCache.c
index ff3f9ef56..02c0cd498 100644
--- a/xorg-server/hw/xfree86/xaa/xaaPCache.c
+++ b/xorg-server/hw/xfree86/xaa/xaaPCache.c
@@ -1,2374 +1,2527 @@
-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include <string.h>

-

-#include "misc.h"

-#include "xf86.h"

-#include "xf86_OSproc.h"

-

-#include <X11/X.h>

-#include "scrnintstr.h"

-#include "gc.h"

-#include "mi.h"

-#include "pixmapstr.h"

-#include "windowstr.h"

-#include "regionstr.h"

-#include "servermd.h"

-#include "xf86str.h"

-#include "xaa.h"

-#include "xaacexp.h"

-#include "xaalocal.h"

-#include "xaawrap.h"

-

-#define MAX_COLOR	32

-#define MAX_MONO	32

-#define MAX_8		32

-#define MAX_128		32

-#define MAX_256		32

-#define MAX_512		16

-

-static int CacheInitIndex = -1;

-#define CACHEINIT(p) ((p)->privates[CacheInitIndex].val)

-	

-

-typedef struct _CacheLink {

-   int x;

-   int y;

-   int w;

-   int h;

-   struct _CacheLink *next;

-} CacheLink, *CacheLinkPtr;

-

-

-static void

-TransferList(CacheLinkPtr list, XAACacheInfoPtr array, int num)

-{

-   while(num--) {

-	array->x = list->x;

-	array->y = list->y;

- 	array->w = list->w;

-	array->h = list->h;

-	array->serialNumber = 0;

-	array->fg = array->bg = -1;

-	list = list->next;

-	array++;

-  }

-}

-

-

-

-static CacheLinkPtr 

-Enlist(CacheLinkPtr link, int x, int y, int w, int h)

-{

-    CacheLinkPtr newLink;

-

-    newLink = malloc(sizeof(CacheLink));

-    newLink->next = link;

-    newLink->x = x; newLink->y = y;

-    newLink->w = w; newLink->h = h;	

-    return newLink;

-}

-

-

-

-static CacheLinkPtr

-Delist(CacheLinkPtr link) {

-    CacheLinkPtr ret = NULL;

-

-    if(link) {

-	ret = link->next;

-	free(link);

-    }    

-    return ret;

-}

-

-

-

-static void

-FreeList(CacheLinkPtr link) {

-    CacheLinkPtr tmp;

-

-    while(link) {

-	tmp = link;

-	link = link->next;

-	free(tmp);

-    }

-}

-

-

-

-static CacheLinkPtr

-QuadLinks(CacheLinkPtr big, CacheLinkPtr little) 

-{

-    /* CAUTION: This doesn't free big */

-    int w1, w2, h1, h2;

-

-    while(big) {

-	w1 = big->w >> 1;	

-	w2 = big->w - w1;

-	h1 = big->h >> 1;	

-	h2 = big->h - h1;

-

-	little = Enlist(little, big->x, big->y, w1, h1);

-	little = Enlist(little, big->x + w1, big->y, w2, h1);

-	little = Enlist(little, big->x, big->y + h1, w1, h2);

-	little = Enlist(little, big->x + w1, big->y + h1, w2, h2);

-

-	big = big->next;

-    }     

-    return little;

-}

-

-

-static void

-SubdivideList(CacheLinkPtr *large, CacheLinkPtr *small)

-{

-   CacheLinkPtr big = *large;

-   CacheLinkPtr little = *small;

-   int size = big->w >> 1;

-

-   little = Enlist(little, big->x, big->y, size, size);

-   little = Enlist(little, big->x + size, big->y, size, size);

-   little = Enlist(little, big->x, big->y + size, size, size);

-   little = Enlist(little, big->x + size, big->y + size, size, size);

-   *small = little;

-   big = Delist(big);

-   *large = big;

-}

-

-static void

-FreePixmapCachePrivate(XAAPixmapCachePrivatePtr pPriv)

-{

-    if(!pPriv) return;

-

-    free(pPriv->Info512);

-    free(pPriv->Info256);

-    free(pPriv->Info128);

-    free(pPriv->InfoColor);

-    free(pPriv->InfoMono);

-    free(pPriv->InfoPartial);

-     

-    free(pPriv);

-}

-

-void

-XAAClosePixmapCache(ScreenPtr pScreen)

-{

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

-  

-   if(infoRec->PixmapCachePrivate)

-	FreePixmapCachePrivate(

-		(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate);

-

-   infoRec->PixmapCachePrivate = NULL;

-}

-

-

-

-static CacheLinkPtr

-ThinOutPartials(

-   CacheLinkPtr ListPartial, 

-   int *num, int *maxw, int *maxh

-) { 

-/* This guy's job is to get at least 4 big slots out of a list of fragments */

-

-   CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers;

-   int Num64, Num32, Num16, Num8, NumKeepers;

-   int w, h;

-

-   List64 = List32 = List16 = List8 = ListKeepers = NULL;

-   Num64 = Num32 = Num16 = Num8 = NumKeepers = 0;

-   w = h = 0;

-

-   /* We sort partials by how large a square tile they can cache.

-	If a partial can't store a 64x64, 32x32, 16x16 or 8x8 tile,

-	we free it.  */

-

-   pCur = ListPartial;

-   while(pCur) {

-	next = pCur->next;

-	if((pCur->w >= 64) && (pCur->h >= 64)) {

-	    pCur->next = List64; List64 = pCur;

-	    Num64++;

-	} else

-	if((pCur->w >= 32) && (pCur->h >= 32)) {

-	    pCur->next = List32; List32 = pCur;

-	    Num32++;

-	} else

-	if((pCur->w >= 16) && (pCur->h >= 16)) {

-	    pCur->next = List16; List16 = pCur;

-	    Num16++;

-	} else

-	if((pCur->w >= 8) && (pCur->h >= 8)) {

-	    pCur->next = List8; List8 = pCur;

-	    Num8++;

-	} else {

-	   free(pCur);

-	}

-

-	pCur = next;

-   }

-

-   /* We save all the tiles from the largest bin that we can get

-	at least 4 of.  If there are too few of a bigger slot, we

-	cut it in fourths to make smaller slots. */

-

-   if(Num64 >= 4) {

-	ListKeepers = List64; List64 = NULL;

-	NumKeepers = Num64;

-	goto GOT_EM;

-   } else if(Num64) {

-	List32 = QuadLinks(List64, List32);

-	Num32 += Num64 * 4;

-	Num64 = 0;

-   }

- 

-   if(Num32 >= 4) {

-	ListKeepers = List32; List32 = NULL;

-	NumKeepers = Num32;

-	goto GOT_EM;

-   } else if(Num32) {

-	List16 = QuadLinks(List32, List16);

-	Num16 += Num32 * 4;

-	Num32 = 0;

-   }

-

-   if(Num16 >= 4) {

-	ListKeepers = List16; List16 = NULL;

-	NumKeepers = Num16;

-	goto GOT_EM;

-   } else if(Num16) {

-	List8 = QuadLinks(List16, List8);

-	Num8 += Num16 * 4;

-	Num16 = 0;

-   }

-

-   if(Num8 >= 4) {

-	ListKeepers = List8; List8 = NULL;

-	NumKeepers = Num8;

-	goto GOT_EM;

-   } 

-

-GOT_EM:

-

-   /* Free the ones we aren't using */

-	

-   if(List64) FreeList(List64);

-   if(List32) FreeList(List32);

-   if(List16) FreeList(List16);

-   if(List8) FreeList(List8);

-

-  

-   /* Enlarge the slots if we can */

-

-   if(ListKeepers) {

-	CacheLinkPtr pLink = ListKeepers;

-	w = h = 128;

-	

-	while(pLink) {

-	   if(pLink->w < w) w = pLink->w;

-	   if(pLink->h < h) h = pLink->h;

-	   pLink = pLink->next;

-	}

-   } 

-

-   *maxw = w;

-   *maxh = h;

-   *num = NumKeepers;

-   return ListKeepers;

-}

-

-static void

-ConvertColorToMono(

-   CacheLinkPtr *ColorList, 

-   int ColorW, int ColorH,

-   CacheLinkPtr *MonoList, 

-   int MonoW, int MonoH

-){

-   int x, y, w;

-

-   x = (*ColorList)->x; y = (*ColorList)->y;

-   *ColorList = Delist(*ColorList);

-  

-   while(ColorH) {

-	ColorH -= MonoH;

-	for(w = 0; w <= (ColorW - MonoW); w += MonoW)

-	     *MonoList = Enlist(*MonoList, x + w, y + ColorH, MonoW, MonoH);

-   }   

-}

-

-static void

-ConvertAllPartialsTo8x8(

-   int *NumMono, int *NumColor,

-   CacheLinkPtr ListPartial,

-   CacheLinkPtr *ListMono,

-   CacheLinkPtr *ListColor,

-   XAAInfoRecPtr infoRec 

-){

-/* This guy extracts as many 8x8 slots as it can out of fragments */

-

-   int ColorH = infoRec->CacheHeightColor8x8Pattern;

-   int ColorW = infoRec->CacheWidthColor8x8Pattern;

-   int MonoH = infoRec->CacheHeightMono8x8Pattern;

-   int MonoW = infoRec->CacheWidthMono8x8Pattern;

-   int x, y, w, Height, Width;

-   Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8);

-   Bool DoMono  = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8);

-   CacheLinkPtr pLink = ListPartial;

-   CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor;

-

-   if(DoColor && DoMono) { 

-	/* we assume color patterns take more space than color ones */

-	if(MonoH > ColorH) ColorH = MonoH;

-	if(MonoW > ColorW) ColorW = MonoW;

-   }

-

-   /* Break up the area into as many Color and Mono slots as we can */

-

-   while(pLink) {

-	Height = pLink->h;

-	Width = pLink->w;

-	x = pLink->x;

-	y = pLink->y;

-

-	if(DoColor) {

-	   while(Height >= ColorH) {		

-		Height -= ColorH;

-		for(w = 0; w <= (Width - ColorW); w += ColorW) {

-		    ColorList = Enlist(

-			ColorList, x + w, y + Height, ColorW, ColorH);

-		    (*NumColor)++;

-		}

-	   }

-	}

- 

-        if(DoMono && (Height >= MonoH)) {

-	   while(Height >= MonoH) {		

-		Height -= MonoH;

-		for(w = 0; w <= (Width - MonoW); w += MonoW) {

-		    MonoList = Enlist(

-			MonoList, x + w, y + Height, MonoW, MonoH);

-		    (*NumMono)++;

-		}

-	   }

-	}

-

-	pLink = pLink->next;

-   }

-

-

-   *ListMono = MonoList;

-   *ListColor = ColorList;

-   FreeList(ListPartial);

-}

-

-

-static CacheLinkPtr

-ExtractOneThatFits(CacheLinkPtr *initList, int w, int h)

-{

-     CacheLinkPtr list = *initList;

-     CacheLinkPtr prev = NULL;

-

-     while(list) { 

-	if((list->w >= w) && (list->h >= h)) 

-	    break;

-	prev = list;

-	list = list->next;

-     }

-

-     if(list) {

-	if(prev) 

-	   prev->next = list->next;

-	else

-	   *initList = list->next;

-

-	list->next = NULL;

-     }

-

-     return list;     

-}

-

-

-static CacheLinkPtr

-ConvertSomePartialsTo8x8(

-   int *NumMono, int *NumColor, int *NumPartial,

-   CacheLinkPtr ListPartial,

-   CacheLinkPtr *ListMono,

-   CacheLinkPtr *ListColor,

-   int *maxw, int *maxh,

-   XAAInfoRecPtr infoRec 

-){

-/* This guy tries to get 4 of each type of 8x8 slot requested out of

-   a list of fragments all while trying to retain some big fragments

-   for the cache blits */

-

-   int ColorH = infoRec->CacheHeightColor8x8Pattern;

-   int ColorW = infoRec->CacheWidthColor8x8Pattern;

-   int MonoH = infoRec->CacheHeightMono8x8Pattern;

-   int MonoW = infoRec->CacheWidthMono8x8Pattern;

-   Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8);

-   Bool DoMono  = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8);

-   CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers;

-   CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor;

-   int Num64, Num32, Num16, Num8, NumKeepers;

-   int w, h, Width, Height;

-   int MonosPerColor = 1;

-

-   if(DoColor && DoMono) { 

-	/* we assume color patterns take more space than color ones */

-	if(MonoH > ColorH) ColorH = MonoH;

-	if(MonoW > ColorW) ColorW = MonoW;

-	MonosPerColor = (ColorH/MonoH) * (ColorW/MonoW);

-   }

-

-   List64 = List32 = List16 = List8 = ListKeepers = MonoList = ColorList = NULL;

-   Num64 = Num32 = Num16 = Num8 = NumKeepers = 0;

-   Width = Height = 0;

-

-   /* We sort partials by how large a square tile they can cache.

-      We make 8x8 patterns from the leftovers if we can. */

-

-   pCur = ListPartial;

-   while(pCur) {

-	next = pCur->next;

-	if((pCur->w >= 64) && (pCur->h >= 64)) {

-	    pCur->next = List64; List64 = pCur;

-	    Num64++;

-	} else

-	if((pCur->w >= 32) && (pCur->h >= 32)) {

-	    pCur->next = List32; List32 = pCur;

-	    Num32++;

-	} else

-	if((pCur->w >= 16) && (pCur->h >= 16)) {

-	    pCur->next = List16; List16 = pCur;

-	    Num16++;

-	} else

-	if((pCur->w >= 8) && (pCur->h >= 8)) {

-	    pCur->next = List8; List8 = pCur;

-	    Num8++;

-	} else {

-	   h = pCur->h;

-	   if(DoColor && (pCur->w >= ColorW) && (h >= ColorH)) {

-		while(h >= ColorH) {

-		    h -= ColorH;

-		    for(w = 0; w <= (pCur->w - ColorW); w += ColorW) {

-			ColorList = Enlist( ColorList,

-			    pCur->x + w, pCur->y + h, ColorW, ColorH);

-			(*NumColor)++;

-		    }	

-		}

-	   }	

-	   if(DoMono && (pCur->w >= MonoW) && (h >= MonoH)) {

-		while(h >= MonoH) {

-		    h -= MonoH;

-		    for(w = 0; w <= (pCur->w - MonoW); w += MonoW) {

-			MonoList = Enlist( MonoList,

-			    pCur->x + w, pCur->y + h, MonoW, MonoH);

-			(*NumMono)++;

-		    }	

-		}

-	   }	

-	   free(pCur);

-	}

-

-	pCur = next;

-   }

-

-   /* Try to extract at least 4 of each type of 8x8 slot that we need */

-

-   if(DoColor) {

-	CacheLinkPtr theOne;

-	while(*NumColor < 4) {

-	    theOne = NULL;

-	    if(Num8) {

-		if((theOne = ExtractOneThatFits(&List8, ColorW, ColorH))) 

-			Num8--;

-	    }

-	    if(Num16 && !theOne) { 

-		if((theOne = ExtractOneThatFits(&List16, ColorW, ColorH))) 

-			Num16--;

-	    }

-	    if(Num32 && !theOne) {

-		if((theOne = ExtractOneThatFits(&List32, ColorW, ColorH)))

-			Num32--;

-	    }

-	    if(Num64 && !theOne) {

-		if((theOne = ExtractOneThatFits(&List64, ColorW, ColorH)))

-			Num64--;

-	    }

-

-	    if(!theOne) break;

-

-		

-	    ConvertAllPartialsTo8x8(NumMono, NumColor, theOne, 

-			&MonoList, &ColorList, infoRec);

-

-	    if(DoMono) {

-		while(*NumColor && (*NumMono < 4)) {

-	    	     ConvertColorToMono(&ColorList, ColorW, ColorH,

-				&MonoList, MonoW, MonoH);

-		      (*NumColor)--; *NumMono += MonosPerColor;

-		}

-	    }

-	}

-   }

-

-   if(DoMono) {

-	CacheLinkPtr theOne;

-	while(*NumMono < 4) {

-	    theOne = NULL;

-	    if(Num8) {

-		if((theOne = ExtractOneThatFits(&List8, MonoW, MonoH))) 

-			Num8--;

-	    }

-	    if(Num16 && !theOne) { 

-		if((theOne = ExtractOneThatFits(&List16, MonoW, MonoH))) 

-			Num16--;

-	    }

-	    if(Num32 && !theOne) {

-		if((theOne = ExtractOneThatFits(&List32, MonoW, MonoH)))

-			Num32--;

-	    }

-	    if(Num64 && !theOne) {

-		if((theOne = ExtractOneThatFits(&List64, MonoW, MonoH)))

-			Num64--;

-	    }

-

-	    if(!theOne) break;

-		

-	    ConvertAllPartialsTo8x8(NumMono, NumColor, theOne, 

-			&MonoList, &ColorList, infoRec);

-	}

-   }

-

-   /* We save all the tiles from the largest bin that we can get

-	at least 4 of.  If there are too few of a bigger slot, we

-	cut it in fourths to make smaller slots. */

-

-   if(Num64 >= 4) {

-	ListKeepers = List64; List64 = NULL;

-	NumKeepers = Num64;

-	goto GOT_EM;

-   } else if(Num64) {

-	List32 = QuadLinks(List64, List32);

-	Num32 += Num64 * 4;

-	Num64 = 0;

-   }

- 

-   if(Num32 >= 4) {

-	ListKeepers = List32; List32 = NULL;

-	NumKeepers = Num32;

-	goto GOT_EM;

-   } else if(Num32) {

-	List16 = QuadLinks(List32, List16);

-	Num16 += Num32 * 4;

-	Num32 = 0;

-   }

-

-   if(Num16 >= 4) {

-	ListKeepers = List16; List16 = NULL;

-	NumKeepers = Num16;

-	goto GOT_EM;

-   } else if(Num16) {

-	List8 = QuadLinks(List16, List8);

-	Num8 += Num16 * 4;

-	Num16 = 0;

-   }

-

-   if(Num8 >= 4) {

-	ListKeepers = List8; List8 = NULL;

-	NumKeepers = Num8;

-	goto GOT_EM;

-   } 

-

-GOT_EM:

-

-   /* Free the ones we aren't using */

-	

-   if(List64) 

-	ConvertAllPartialsTo8x8(NumMono, NumColor, List64, 

-			&MonoList, &ColorList, infoRec);

-   if(List32) 

-	ConvertAllPartialsTo8x8(NumMono, NumColor, List32, 

-			&MonoList, &ColorList, infoRec);

-   if(List16) 

-	ConvertAllPartialsTo8x8(NumMono, NumColor, List16, 

-			&MonoList, &ColorList, infoRec);

-   if(List8) 

-	ConvertAllPartialsTo8x8(NumMono, NumColor, List8, 

-			&MonoList, &ColorList, infoRec);

-

- 

-   /* Enlarge the slots if we can */

-

-   if(ListKeepers) {

-	CacheLinkPtr pLink = ListKeepers;

-	Width = Height = 128;

-	

-	while(pLink) {

-	   if(pLink->w < Width) Width = pLink->w;

-	   if(pLink->h < Height) Height = pLink->h;

-	   pLink = pLink->next;

-	}

-   } 

-

-   *ListMono = MonoList;

-   *ListColor = ColorList;

-   *maxw = Width;

-   *maxh = Height;

-   *NumPartial = NumKeepers;

-   return ListKeepers;

-}

-

-

-void

-XAAInitPixmapCache(	

-    ScreenPtr pScreen, 

-    RegionPtr areas,

-    pointer data

-) {

-   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];

-   XAAInfoRecPtr infoRec = (XAAInfoRecPtr)data;

-   XAAPixmapCachePrivatePtr pCachePriv;

-   BoxPtr pBox = RegionRects(areas);

-   int nBox = RegionNumRects(areas);

-   int Num512, Num256, Num128, NumPartial, NumColor, NumMono;

-   int Target512, Target256;

-   CacheLinkPtr List512, List256, List128, ListPartial, ListColor, ListMono;

-   int x, y, w, h, ntotal, granularity, width, height, i;

-   int MaxPartialWidth, MaxPartialHeight;

-

-   infoRec->MaxCacheableTileWidth = 0;

-   infoRec->MaxCacheableTileHeight = 0;

-   infoRec->MaxCacheableStippleHeight = 0;

-   infoRec->MaxCacheableStippleWidth = 0;

-   infoRec->UsingPixmapCache = FALSE;

-

-

-   if(!nBox || !pBox || !(infoRec->Flags & PIXMAP_CACHE))

-	return;

-

-   /* Allocate a persistent per-screen init flag to control messages */

-   if (CacheInitIndex < 0)

-	CacheInitIndex = xf86AllocateScrnInfoPrivateIndex();

-

-   /* free the old private data if it exists */

-   if(infoRec->PixmapCachePrivate) {

-	FreePixmapCachePrivate(

-		(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate);

-	infoRec->PixmapCachePrivate = NULL;

-   }

-

-   Num512 = Num256 = Num128 = NumPartial = NumMono = NumColor = 0;

-   List512 = List256 = List128 = ListPartial = ListMono = ListColor = NULL;

-   granularity = infoRec->CachePixelGranularity;

-   if(granularity <= 1) granularity = 0;

-

-   /* go through the boxes and break it into as many pieces as we can fit */

-

-   while(nBox--) {

-	x = pBox->x1;

-	if(granularity) {

-	    int tmp = x % granularity;

-	    if(tmp) x += (granularity - tmp);

-	}

-	width = pBox->x2 - x;

-        if(width <= 0) {pBox++; continue;}

-

-	y = pBox->y1;

-        height = pBox->y2 - y;

-

-        for(h = 0; h <= (height - 512); h += 512) {

-	    for(w = 0; w <= (width - 512); w += 512) {

-		List512 = Enlist(List512, x + w, y + h, 512, 512);

-		Num512++;	

-	    }

-	    for(; w <= (width - 256); w += 256) {

-		List256 = Enlist(List256, x + w, y + h, 256, 256);

-		List256 = Enlist(List256, x + w, y + h + 256, 256, 256);

-		Num256 += 2;

-	    }

-	    for(; w <= (width - 128); w += 128) {

-		List128 = Enlist(List128, x + w, y + h, 128, 128);

-		List128 = Enlist(List128, x + w, y + h + 128, 128, 128);

-		List128 = Enlist(List128, x + w, y + h + 256, 128, 128);

-		List128 = Enlist(List128, x + w, y + h + 384, 128, 128);

-		Num128 += 4;

-	    }

-	    if(w < width) {

-		int d = width - w;

-		ListPartial = Enlist(ListPartial, x + w, y + h, d, 128);

-		ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128);

-		ListPartial = Enlist(ListPartial, x + w, y + h + 256, d, 128);

-		ListPartial = Enlist(ListPartial, x + w, y + h + 384, d, 128);

-		NumPartial += 4;

-            }

-	}

-        for(; h <= (height - 256); h += 256) {

-	    for(w = 0; w <= (width - 256); w += 256) {

-		List256 = Enlist(List256, x + w, y + h, 256, 256);

-		Num256++;

-	    }

-	    for(; w <= (width - 128); w += 128) {

-		List128 = Enlist(List128, x + w, y + h, 128, 128);

-		List128 = Enlist(List128, x + w, y + h + 128, 128, 128);

-		Num128 += 2;

-	    }

-	    if(w < width) {

-		int d = width - w;

-		ListPartial = Enlist(ListPartial, x + w, y + h, d, 128);

-		ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128);

-		NumPartial += 2;

-            }

-        }

-        for(; h <= (height - 128); h += 128) {

-	    for(w = 0; w <= (width - 128); w += 128) {

-		List128 = Enlist(List128, x + w, y + h, 128, 128);

-		Num128++;

-	    }

-	    if(w < width) {

-		ListPartial = Enlist(

-			ListPartial, x + w, y + h, width - w, 128);

-		NumPartial++;

-            }

-        }

-        if(h < height) {

-	    int d = height - h;

-	    for(w = 0; w <= (width - 128); w += 128) {

-		ListPartial = Enlist(ListPartial, x + w, y + h, 128, d);

-		NumPartial++;

-	    }

-	    if(w < width) {

-		ListPartial = Enlist(ListPartial, x + w, y + h, width - w, d);

-		NumPartial++;

-            }

-        }

-	pBox++;

-   }

-

-

-/* 

-   by this point we've carved the space into as many 512x512, 256x256

-	and 128x128 blocks as we could fit.  We will then break larger

-	blocks into smaller ones if we need to.  The rules are as follows:

-

-     512x512 -

-	1) Don't take up more than half the memory.

-	2) Don't bother if you can't get at least four.

-	3) Don't make more than MAX_512.

-	4) Don't have any of there are no 256x256s.

-

-     256x256 -

-	1) Don't take up more than a quarter of the memory enless there

-		aren't any 512x512s.  Then we can take up to half.

-	2) Don't bother if you can't get at least four.

-	3) Don't make more than MAX_256.

-

-     128x128 -

-	1) Don't make more than MAX_128.

-

-     We don't bother with the partial blocks unless we can use them

-     for 8x8 pattern fills or we are short on larger blocks.

-

-*/

-

-    ntotal = Num128 + (Num256<<2) + (Num512<<4);   

-	

-    Target512 = ntotal >> 5;

-    if(Target512 < 4) Target512 = 0;

-    if(!Target512) Target256 = ntotal >> 3;

-    else Target256 = ntotal >> 4;

-    if(Target256 < 4) Target256 = 0;

-

-    if(Num512 && Num256 < 4) {

-	while(Num512 && Num256 < Target256) {

-	   SubdivideList(&List512, &List256);

-	   Num256 += 4; Num512--;

-	}

-    }

-

-    if(!Num512) { /* no room */

-    } else if((Num512 < 4) || (!Target512)) {

-	while(Num512) {

-	   SubdivideList(&List512, &List256);

-	   Num256 += 4; Num512--;

-	}

-    } else if((Num512 > MAX_512) || (Num512 > Target512)){

-	while(Num512 > MAX_512) {

-	   SubdivideList(&List512, &List256);

-	   Num256 += 4; Num512--;

-	}

-	while(Num512 > Target512) {

-	    if(Num256 < MAX_256) {

-		SubdivideList(&List512, &List256);

-		Num256 += 4; Num512--;

-	    } else break;

-	}

-    }

-

-    if(!Num256) { /* no room */

-    } else if((Num256 < 4) || (!Target256)) {

-	while(Num256) {

-	   SubdivideList(&List256, &List128);

-	   Num128 += 4; Num256--;

-	}

-    } else if((Num256 > MAX_256) || (Num256 > Target256)) {

-	while(Num256 > MAX_256) {

-	   SubdivideList(&List256, &List128);

-	   Num128 += 4; Num256--;

-	}

-	while(Num256 > Target256) {

-	    if(Num128 < MAX_128) {

-		SubdivideList(&List256, &List128);

-		Num128 += 4; Num256--;

-	    } else break;

-	}

-    } 

-

-    if(Num128 && ((Num128 < 4) || (Num128 > MAX_128))) {

-	CacheLinkPtr next;

-	int max = (Num128 > MAX_128) ? MAX_128 : 0;

-

-	/*

-	 * Note: next is set in this way to work around a code generation

-	 * bug in gcc 2.7.2.3.

-	 */

-	next = List128->next;

-	while(Num128 > max) {

-	   List128->next = ListPartial;	

-	   ListPartial = List128;

-	   if((List128 = next))

-		next = List128->next;

-	   NumPartial++; Num128--;

-	}

-    }

-

-    MaxPartialHeight = MaxPartialWidth = 0;

-

-    /* at this point we have as many 512x512 and 256x256 slots as we

-	want but may have an excess of 128x128 slots.  We still need

-	to find out if we need 8x8 slots.  We take these from the

-	partials if we have them.  Otherwise, we break some 128x128's */

-

-    if(!(infoRec->PixmapCacheFlags & (CACHE_MONO_8x8 | CACHE_COLOR_8x8))) {

-	if(NumPartial) {

-	    if(Num128) { /* don't bother with partials */

-		FreeList(ListPartial);	

-		NumPartial = 0; ListPartial = NULL;

-	    } else {

-	   /* We have no big slots.  Weed out the unusable partials */

-		ListPartial = ThinOutPartials(ListPartial, &NumPartial,

-			&MaxPartialWidth, &MaxPartialHeight);

-	    }

-	}

-    } else {

-	int MonosPerColor = 1;

-	int ColorH = infoRec->CacheHeightColor8x8Pattern;

-	int ColorW = infoRec->CacheWidthColor8x8Pattern;

-	int MonoH = infoRec->CacheHeightMono8x8Pattern;

-	int MonoW = infoRec->CacheWidthMono8x8Pattern;

-	Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8);

-	Bool DoMono  = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8);

-

-	if(DoColor) infoRec->CanDoColor8x8 = FALSE;

-	if(DoMono) infoRec->CanDoMono8x8 = FALSE;

-	

-	if(DoColor && DoMono) { 

-	    /* we assume color patterns take more space than color ones */

-	    if(MonoH > ColorH) ColorH = MonoH;

-	    if(MonoW > ColorW) ColorW = MonoW;

-	    MonosPerColor = (ColorH/MonoH) * (ColorW/MonoW);

-	}

-

-	if(Num128) {

-	    if(NumPartial) { /* use all for 8x8 slots */

-		ConvertAllPartialsTo8x8(&NumMono, &NumColor, 

-			ListPartial, &ListMono, &ListColor, infoRec);

-		NumPartial = 0; ListPartial = NULL;

-	    } 

-

-		/* Get some 8x8 slots from the 128 slots */

-	    while((Num128 > 4) && 

-		      ((NumMono < MAX_MONO) && (NumColor < MAX_COLOR))) {

-		CacheLinkPtr tmp = NULL;

-

-		tmp = Enlist(tmp, List128->x, List128->y, 

-					List128->w, List128->h);

-		List128 = Delist(List128);

-		Num128--;

-

-		ConvertAllPartialsTo8x8(&NumMono, &NumColor, 

-				tmp, &ListMono, &ListColor, infoRec);

-	    }

-	} else if(NumPartial) {

-	/* We have share partials between 8x8 slots and tiles. */

-	    ListPartial = ConvertSomePartialsTo8x8(&NumMono, &NumColor, 	

-			&NumPartial, ListPartial, &ListMono, &ListColor, 

-			&MaxPartialWidth, &MaxPartialHeight, infoRec);

-        }

-

-	

-	if(DoMono && DoColor) {

-	    if(NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) {

-		int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0;

-

-		while(NumColor > max) {

-		    ConvertColorToMono(&ListColor, ColorW, ColorH,

-					&ListMono, MonoW, MonoH);

-		    NumColor--; NumMono += MonosPerColor;

-		}

-	    }

-

-	    /* favor Mono slots over Color ones */

-	    while((NumColor > 4) && (NumMono < MAX_MONO)) {

-	        ConvertColorToMono(&ListColor, ColorW, ColorH,

-				&ListMono, MonoW, MonoH);

-	        NumColor--; NumMono += MonosPerColor;

-	    }

-	}

-

-	if(NumMono && ((NumMono > MAX_MONO) || (NumMono < 4))) {

-	    int max = (NumMono > MAX_MONO) ? MAX_MONO : 0;

-

-	    while(NumMono > max) {

-		ListMono = Delist(ListMono);

-		NumMono--;

-	    }

-	}

-	if(NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) {

-	    int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0;

-

-	    while(NumColor > max) {

-		ListColor = Delist(ListColor);

-		NumColor--;

-	    }

-	}

-    }

-

-

-    pCachePriv = calloc(1,sizeof(XAAPixmapCachePrivate));

-    if(!pCachePriv) {

-	if(Num512) FreeList(List512);

-	if(Num256) FreeList(List256);

-	if(Num128) FreeList(List128);

-	if(NumPartial) FreeList(ListPartial);

-	if(NumColor) FreeList(ListColor);

-	if(NumMono) FreeList(ListMono);

-	return;

-    }

-

-    infoRec->PixmapCachePrivate = (char*)pCachePriv;

-

-    if(Num512) {

-	pCachePriv->Info512 = calloc(Num512,sizeof(XAACacheInfoRec));

-	if(!pCachePriv->Info512) Num512 = 0;

-	if(Num512) TransferList(List512, pCachePriv->Info512, Num512);

-	FreeList(List512);

-    	pCachePriv->Num512x512 = Num512;

-    }

-    if(Num256) {

-	pCachePriv->Info256 = calloc(Num256, sizeof(XAACacheInfoRec));

-	if(!pCachePriv->Info256) Num256 = 0;

-	if(Num256) TransferList(List256, pCachePriv->Info256, Num256);

-	FreeList(List256);

-    	pCachePriv->Num256x256 = Num256;

-    }

-    if(Num128) {

-	pCachePriv->Info128 = calloc(Num128, sizeof(XAACacheInfoRec));

-	if(!pCachePriv->Info128) Num128 = 0;

-	if(Num128) TransferList(List128, pCachePriv->Info128, Num128);

-	FreeList(List128);

-    	pCachePriv->Num128x128 = Num128;

-    }

-

-    if(NumPartial) {

-	pCachePriv->InfoPartial = calloc(NumPartial, sizeof(XAACacheInfoRec));

-	if(!pCachePriv->InfoPartial) NumPartial = 0;

-	if(NumPartial) 

-	    TransferList(ListPartial, pCachePriv->InfoPartial, NumPartial);

-	FreeList(ListPartial);

-    	pCachePriv->NumPartial = NumPartial;

-    }

-

-    if(NumColor) {

-	pCachePriv->InfoColor = calloc(NumColor, sizeof(XAACacheInfoRec));

-	if(!pCachePriv->InfoColor) NumColor = 0;

-	if(NumColor) TransferList(ListColor, pCachePriv->InfoColor, NumColor);

-	FreeList(ListColor);

-    	pCachePriv->NumColor = NumColor;

-    }

-

-    if(NumMono) {

-	pCachePriv->InfoMono = calloc(NumMono, sizeof(XAACacheInfoRec));

-	if(!pCachePriv->InfoMono) NumMono = 0;

-	if(NumMono) TransferList(ListMono, pCachePriv->InfoMono, NumMono);

-	FreeList(ListMono);

-    	pCachePriv->NumMono = NumMono;

-    }

-

-

-    if(NumPartial) {

-	infoRec->MaxCacheableTileWidth = MaxPartialWidth;

-	infoRec->MaxCacheableTileHeight = MaxPartialHeight;

-    }

-    if(Num128) 

-	infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 128;

-    if(Num256) 

-	infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 256;

-    if(Num512) 

-	infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 512;

-

-     

-    infoRec->MaxCacheableStippleHeight = infoRec->MaxCacheableTileHeight;

-    infoRec->MaxCacheableStippleWidth = 

-		infoRec->MaxCacheableTileWidth * pScrn->bitsPerPixel;

-    if(infoRec->ScreenToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP) 

-	infoRec->MaxCacheableStippleWidth /= 3;

-

-    if(NumMono)  {

-        if(!(infoRec->Mono8x8PatternFillFlags & 

-		(HARDWARE_PATTERN_PROGRAMMED_ORIGIN | 

-		 HARDWARE_PATTERN_PROGRAMMED_BITS))) {

-	    int numPerLine = 

-		  infoRec->CacheWidthMono8x8Pattern/infoRec->MonoPatternPitch;

-

-	    for(i = 0; i < 64; i++) { 

-		pCachePriv->MonoOffsets[i].y = i/numPerLine;

-		pCachePriv->MonoOffsets[i].x = (i % numPerLine) *

-					infoRec->MonoPatternPitch;

-	    }

-	}

-	infoRec->CanDoMono8x8 = TRUE;

-    }

-    if(NumColor) {

-	if(!(infoRec->Color8x8PatternFillFlags & 

-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {

-

-	   for(i = 0; i < 64; i++) { 

-		pCachePriv->ColorOffsets[i].y = i & 0x07;

-		pCachePriv->ColorOffsets[i].x = i & ~0x07;

-	   }

-	}

-	infoRec->CanDoColor8x8 = TRUE;

-    }

-

-    if(!CACHEINIT(pScrn)) {

-	xf86ErrorF("\tSetting up tile and stipple cache:\n");

-	if(NumPartial) 

-	   xf86ErrorF("\t\t%i %ix%i slots\n", 

-		NumPartial, MaxPartialWidth, MaxPartialHeight);

-	if(Num128) xf86ErrorF("\t\t%i 128x128 slots\n", Num128);

-	if(Num256) xf86ErrorF("\t\t%i 256x256 slots\n", Num256);

-	if(Num512) xf86ErrorF("\t\t%i 512x512 slots\n", Num512);

-	if(NumColor) xf86ErrorF("\t\t%i 8x8 color pattern slots\n", NumColor);

-	if(NumMono) xf86ErrorF("\t\t%i 8x8 color expansion slots\n", NumMono);

-    } 

-

-    if(!(NumPartial | Num128 | Num256 | Num512 | NumColor | NumMono)) {

-	if(!CACHEINIT(pScrn))

-	   xf86ErrorF("\t\tNot enough video memory for pixmap cache\n");

-    } else infoRec->UsingPixmapCache = TRUE;

-

-    CACHEINIT(pScrn) = 1;

-}

-

-#if X_BYTE_ORDER == X_BIG_ENDIAN

-static CARD32 StippleMasks[4] = {

-   0x80808080,

-   0xC0C0C0C0,

-   0x00000000,

-   0xF0F0F0F0

-};

-#else

-static CARD32 StippleMasks[4] = {

-   0x01010101,

-   0x03030303,

-   0x00000000,

-   0x0F0F0F0F

-};

-#endif

-

-Bool

-XAACheckStippleReducibility(PixmapPtr pPixmap)

-{

-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);

-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_DRAWABLE(&pPixmap->drawable);

-    CARD32 *IntPtr = (CARD32*)pPixmap->devPrivate.ptr;

-    int w = pPixmap->drawable.width;

-    int h = pPixmap->drawable.height;

-    int i;

-    CARD32 bits[8];

-    CARD32 mask = SHIFT_R(0xFFFFFFFF,24);

-

-    pPriv->flags |= REDUCIBILITY_CHECKED | REDUCIBLE_TO_2_COLOR;

-    pPriv->flags &= ~REDUCIBLE_TO_8x8;

-

-    if((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1))) 

-	return FALSE;

-

-    i = (h > 8) ? 8 : h;

-

-    switch(w) {

-    case 32:

- 	while(i--) {

-	   bits[i] = IntPtr[i] & mask;

-	    if(	(bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 8)), 8)) ||

-		(bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask,16)),16)) ||

-		(bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask,24)),24)))

-	    	return FALSE; 

-	}

-	break;

-    case 16:

-	while(i--) {

-	   bits[i] = IntPtr[i] & mask;

-	    if(bits[i] != ((IntPtr[i] & SHIFT_R(SHIFT_L(mask,8),8))))

-	    	return FALSE; 

-	}

-	break;

-    default: 

-	while(i--)

-	   bits[i] = IntPtr[i] & mask;

-	break;

-    }    

-

-    switch(h) {

-	case 32: 

-	    if(	(IntPtr[8]  != IntPtr[16]) || (IntPtr[9]  != IntPtr[17]) ||

-	    	(IntPtr[10] != IntPtr[18]) || (IntPtr[11] != IntPtr[19]) ||

-	    	(IntPtr[12] != IntPtr[20]) || (IntPtr[13] != IntPtr[21]) ||

-	    	(IntPtr[14] != IntPtr[22]) || (IntPtr[15] != IntPtr[23]) ||

-		(IntPtr[16] != IntPtr[24]) || (IntPtr[17] != IntPtr[25]) ||

-	    	(IntPtr[18] != IntPtr[26]) || (IntPtr[19] != IntPtr[27]) ||

-	    	(IntPtr[20] != IntPtr[28]) || (IntPtr[21] != IntPtr[29]) ||

-	    	(IntPtr[22] != IntPtr[30]) || (IntPtr[23] != IntPtr[31]))

-		return FALSE;

-	    /* fall through */

-	case 16:

-	    if(	(IntPtr[0] != IntPtr[8])  || (IntPtr[1] != IntPtr[9])  ||

-	    	(IntPtr[2] != IntPtr[10]) || (IntPtr[3] != IntPtr[11]) ||

-	    	(IntPtr[4] != IntPtr[12]) || (IntPtr[5] != IntPtr[13]) ||

-	    	(IntPtr[6] != IntPtr[14]) || (IntPtr[7] != IntPtr[15]))

-		return FALSE;

-	case 8: break;

-	case 1:	bits[1] = bits[0];

-	case 2: bits[2] = bits[0];	bits[3] = bits[1];

-	case 4: bits[4] = bits[0];	bits[5] = bits[1];

-		bits[6] = bits[2];	bits[7] = bits[3];

-	     	break;

-    }

-	

-    pPriv->flags |= REDUCIBLE_TO_8x8;

-

-    pPriv->pattern0 = bits[0] | SHIFT_L(bits[1],8) | SHIFT_L(bits[2],16) | SHIFT_L(bits[3],24);

-    pPriv->pattern1 = bits[4] | SHIFT_L(bits[5],8) | SHIFT_L(bits[6],16) | SHIFT_L(bits[7],24);

- 

-    if(w < 8) {

-	pPriv->pattern0 &= StippleMasks[w - 1];

-	pPriv->pattern1 &= StippleMasks[w - 1];

-

-	switch(w) {

-	case 1: pPriv->pattern0 |= SHIFT_L(pPriv->pattern0,1);

-		pPriv->pattern1 |= SHIFT_L(pPriv->pattern1,1);

-	case 2:	pPriv->pattern0 |= SHIFT_L(pPriv->pattern0,2);

-		pPriv->pattern1 |= SHIFT_L(pPriv->pattern1,2);

-	case 4:	pPriv->pattern0 |= SHIFT_L(pPriv->pattern0,4);

-		pPriv->pattern1 |= SHIFT_L(pPriv->pattern1,4);

-	}

-    }

-

-    if(infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {

-	pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0);

-	pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1);

-    }

-

-

-    return TRUE;

-}

-

-

-Bool

-XAACheckTileReducibility(PixmapPtr pPixmap, Bool checkMono)

-{

-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);

-    CARD32 *IntPtr;

-    int w = pPixmap->drawable.width;

-    int h = pPixmap->drawable.height;

-    int pitch = pPixmap->devKind >> 2;

-    int dwords, i, j;

-

-    pPriv->flags |= REDUCIBILITY_CHECKED;

-    pPriv->flags &= ~(REDUCIBILITY_CHECKED | REDUCIBLE_TO_2_COLOR);

-

-    if((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1))) 

-	return FALSE;

-

-    dwords = ((w * pPixmap->drawable.bitsPerPixel) + 31) >> 5;

-    i = (h > 8) ? 8 : h;

-

-

-    if(w > 8) {

-	IntPtr = (CARD32*)pPixmap->devPrivate.ptr;

-	switch(pPixmap->drawable.bitsPerPixel) {

-	case 8:

-	    while(i--) {

-		for(j = 2; j < dwords; j++)

-		    if(IntPtr[j] != IntPtr[j & 0x01])

-			return FALSE;

-		IntPtr += pitch;

-	     }

-	     break;

-	case 16:

-	    while(i--) {

-		for(j = 4; j < dwords; j++)

-		    if(IntPtr[j] != IntPtr[j & 0x03])

-			return FALSE;

-		IntPtr += pitch;

-	     }

-	     break;

-	case 24:

-	    while(i--) {

-		for(j = 6; j < dwords; j++)

-		    if(IntPtr[j] != IntPtr[j % 6])

-			return FALSE;

-		IntPtr += pitch;

-	     }

-	     break;

-	case 32:

-	    while(i--) {

-		for(j = 8; j < dwords; j++)

-		    if(IntPtr[j] != IntPtr[j & 0x07])

-			return FALSE;

-		IntPtr += pitch;

-	     }

-	     break;

-	default:  return FALSE;

-	}

-

-    }

-

-

-    if(h == 32) {

-	CARD32 *IntPtr2, *IntPtr3, *IntPtr4;

- 	i = 8;

-	IntPtr = (CARD32*)pPixmap->devPrivate.ptr;

-    	IntPtr2 = IntPtr + (pitch << 3);

-  	IntPtr3 = IntPtr2 + (pitch << 3);

-  	IntPtr4 = IntPtr3 + (pitch << 3);

-	while(i--) {

-	    for(j = 0; j < dwords; j++)

-		if((IntPtr[j] != IntPtr2[j]) || (IntPtr[j] != IntPtr3[j]) ||

-		    (IntPtr[j] != IntPtr4[j]))

-			return FALSE;

-	    IntPtr += pitch;

-	    IntPtr2 += pitch;

-	    IntPtr3 += pitch;

-	    IntPtr4 += pitch;

-	}

-    } else if (h == 16) {

-        CARD32 *IntPtr2;

-	i = 8;

-	IntPtr = (CARD32*)pPixmap->devPrivate.ptr;

-   	IntPtr2 = IntPtr + (pitch << 3);

-	while(i--) {

-	    for(j = 0; j < dwords; j++)

-		if(IntPtr[j] != IntPtr2[j])

-			return FALSE;

-	    IntPtr += pitch;

-	    IntPtr2 += pitch;

-	}

-    }

-	

-    pPriv->flags |= REDUCIBLE_TO_8x8;

-

-    if(checkMono) {

-   	XAAInfoRecPtr infoRec = 

-		GET_XAAINFORECPTR_FROM_DRAWABLE(&pPixmap->drawable);

-	unsigned char bits[8];

-	int fg, bg = -1, x, y;

- 

-	i = (h > 8) ? 8 : h;

-	j = (w > 8) ? 8 : w;

-

-	if(pPixmap->drawable.bitsPerPixel == 8) {

-	    unsigned char *srcp = pPixmap->devPrivate.ptr;

-	    fg = srcp[0];

-	    pitch = pPixmap->devKind;

-	    for(y = 0; y < i; y++) {

-		bits[y] = 0;

-		for(x = 0; x < j; x++) {

-		   if(srcp[x] != fg) {

-			if(bg == -1) bg = srcp[x];

-			else if(bg != srcp[x]) return TRUE;

-		   } else bits[y] |= 1 << x;

-		}

-		srcp += pitch;

-	    }

-	} else if(pPixmap->drawable.bitsPerPixel == 16) {

-	    unsigned short *srcp = (unsigned short*)pPixmap->devPrivate.ptr;

-	    fg = srcp[0];

-	    pitch = pPixmap->devKind >> 1;

-	    for(y = 0; y < i; y++) {

-		bits[y] = 0;

-		for(x = 0; x < j; x++) {

-		   if(srcp[x] != fg) {

-			if(bg == -1) bg = srcp[x];

-			else if(bg != srcp[x]) return TRUE;

-		   } else bits[y] |= 1 << x;

-		}

-		srcp += pitch;

-	    }

-	} else if(pPixmap->drawable.bitsPerPixel == 24) {

-	    CARD32 val;

-	    unsigned char *srcp = pPixmap->devPrivate.ptr;

-	    fg = *((CARD32*)srcp) & 0x00FFFFFF;

-	    pitch = pPixmap->devKind;

-	    j *= 3;

-	    for(y = 0; y < i; y++) {

-		bits[y] = 0;

-		for(x = 0; x < j; x+=3) {

-		   val = *((CARD32*)(srcp+x)) & 0x00FFFFFF;

-		   if(val != fg) {

-			if(bg == -1) bg = val;

-			else if(bg != val) 

-				return TRUE;

-		   } else bits[y] |= 1 << (x/3);

-		}

-		srcp += pitch;

-	    }

-	} else if(pPixmap->drawable.bitsPerPixel == 32) {

-	    IntPtr = (CARD32*)pPixmap->devPrivate.ptr;

-	    fg = IntPtr[0];

-	    for(y = 0; y < i; y++) {

-		bits[y] = 0;

-		for(x = 0; x < j; x++) {

-		   if(IntPtr[x] != fg) {

-			if(bg == -1) bg = IntPtr[x];

-			else if(bg != IntPtr[x]) return TRUE;

-		   } else bits[y] |= 1 << x;

-		}

-		IntPtr += pitch;

-	    }

-	} else return TRUE;

-

-        pPriv->fg = fg;

-	if(bg == -1) pPriv->bg = fg;

-        else pPriv->bg = bg;

-   

-   	if(h < 8) {

-	   switch(h) {

-		case 1:	bits[1] = bits[0];

-		case 2: bits[2] = bits[0];	bits[3] = bits[1];

-		case 4: bits[4] = bits[0];	bits[5] = bits[1];

-			bits[6] = bits[2];	bits[7] = bits[3];

-			break;

-	   }

-    	}

-

-	pPriv->pattern0 = 

-		bits[0] | (bits[1]<<8) | (bits[2]<<16) | (bits[3]<<24);

-	pPriv->pattern1 = 

-		bits[4] | (bits[5]<<8) | (bits[6]<<16) | (bits[7]<<24);

- 

-	if(w < 8) {

-	   switch(w) {

-	   case 1: 	pPriv->pattern0 |= (pPriv->pattern0 << 1);

-			pPriv->pattern1 |= (pPriv->pattern1 << 1);

-	   case 2:	pPriv->pattern0 |= (pPriv->pattern0 << 2);

-			pPriv->pattern1 |= (pPriv->pattern1 << 2);

-	   case 4:	pPriv->pattern0 |= (pPriv->pattern0 << 4);

-			pPriv->pattern1 |= (pPriv->pattern1 << 4);

-	   }

-	}

-	pPriv->flags |= REDUCIBLE_TO_2_COLOR;

-

-	if(infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {

-	    pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0);

-	    pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1);

-	}

-

-    }

-

-    return TRUE;

-}

-

-

-void XAATileCache(

-   ScrnInfoPtr pScrn, 

-   XAACacheInfoPtr pCache,

-   int w, int h

-) {

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-

-   (*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, GXcopy, ~0, -1);

-

-   while((w << 1) <= pCache->w) {

-	(*infoRec->SubsequentScreenToScreenCopy)(pScrn, pCache->x, pCache->y,

-		pCache->x + w, pCache->y, w, h);

-	w <<= 1;

-   }

-   if(w != pCache->w) {

-	(*infoRec->SubsequentScreenToScreenCopy)(pScrn, pCache->x, pCache->y,

-		pCache->x + w, pCache->y, pCache->w - w, h);

-	w = pCache->w;

-   }

-

-   while((h << 1) <= pCache->h) {

-	(*infoRec->SubsequentScreenToScreenCopy)(pScrn, pCache->x, pCache->y,

-		pCache->x, pCache->y + h, w, h);

-	h <<= 1;

-   }

-   if(h != pCache->h) {

-	(*infoRec->SubsequentScreenToScreenCopy)(pScrn, pCache->x, pCache->y,

-		pCache->x, pCache->y + h, w, pCache->h - h);

-   }

-   SET_SYNC_FLAG(infoRec);

-}

-

-XAACacheInfoPtr

-XAACacheTile(ScrnInfoPtr pScrn, PixmapPtr pPix)

-{

-   int w = pPix->drawable.width;

-   int h = pPix->drawable.height;

-   int size = max(w, h);

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-   XAAPixmapCachePrivatePtr pCachePriv = 

-	(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate;

-   XAACacheInfoPtr pCache, cacheRoot = NULL;

-   int i, max = 0;

-   int *current;

-

-   if(size <= 128) {

-	if(pCachePriv->Info128) {

-	    cacheRoot = pCachePriv->Info128; 

-	    max = pCachePriv->Num128x128;

-	    current = &pCachePriv->Current128;

-	} else {     

-	    cacheRoot = pCachePriv->InfoPartial;

-	    max = pCachePriv->NumPartial;

-	    current = &pCachePriv->CurrentPartial;

-	}

-   } else if(size <= 256) {

-	cacheRoot = pCachePriv->Info256;      

-	max = pCachePriv->Num256x256;

-	current = &pCachePriv->Current256;

-   } else if(size <= 512) {

-	cacheRoot = pCachePriv->Info512;      

-	max = pCachePriv->Num512x512;

-	current = &pCachePriv->Current512;

-   } else { /* something's wrong */ 

-	ErrorF("Something's wrong in XAACacheTile()\n");

-	return pCachePriv->Info128; 

-   }

-

-   pCache = cacheRoot;

-

-   /* lets look for it */

-   for(i = 0; i < max; i++, pCache++) {

-	if(pCache->serialNumber == pPix->drawable.serialNumber) {

-	    pCache->trans_color = -1;

-	    return pCache;

-	}

-   }

-

-   pCache = &cacheRoot[(*current)++];

-   if(*current >= max) *current = 0;

-

-   pCache->serialNumber = pPix->drawable.serialNumber;

-   pCache->trans_color = pCache->bg = pCache->fg = -1;

-   pCache->orig_w = w;  pCache->orig_h = h;

-   (*infoRec->WritePixmapToCache)(

-	pScrn, pCache->x, pCache->y, w, h, pPix->devPrivate.ptr,

-	pPix->devKind, pPix->drawable.bitsPerPixel, pPix->drawable.depth);

-   if(!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) && 

-	((w != pCache->w) || (h != pCache->h)))

-	XAATileCache(pScrn, pCache, w, h);

-

-   return pCache;

-}

-

-XAACacheInfoPtr

-XAACacheMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix)

-{

-   int w = pPix->drawable.width;

-   int h = pPix->drawable.height;

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-   XAAPixmapCachePrivatePtr pCachePriv = 

-	(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate;

-   XAACacheInfoPtr pCache, cacheRoot = NULL;

-   int i, max = 0, funcNo, pad, dwords, bpp = pScrn->bitsPerPixel;

-   int *current;

-   StippleScanlineProcPtr StippleFunc;

-   unsigned char *data, *srcPtr, *dstPtr;

-

-   if((h <= 128) && (w <= 128 * bpp)) {

-	if(pCachePriv->Info128) {

-	    cacheRoot = pCachePriv->Info128; 

-	    max = pCachePriv->Num128x128;

-	    current = &pCachePriv->Current128;

-	} else {     

-	    cacheRoot = pCachePriv->InfoPartial;

-	    max = pCachePriv->NumPartial;

-	    current = &pCachePriv->CurrentPartial;

-	}

-   } else if((h <= 256) && (w <= 256 * bpp)){

-	cacheRoot = pCachePriv->Info256;      

-	max = pCachePriv->Num256x256;

-	current = &pCachePriv->Current256;

-   } else if((h <= 512) && (w <= 526 * bpp)){

-	cacheRoot = pCachePriv->Info512;      

-	max = pCachePriv->Num512x512;

-	current = &pCachePriv->Current512;

-   } else { /* something's wrong */ 

-	ErrorF("Something's wrong in XAACacheMonoStipple()\n");

-	return pCachePriv->Info128; 

-   }

-

-   pCache = cacheRoot;

-

-   /* lets look for it */

-   for(i = 0; i < max; i++, pCache++) {

-	if((pCache->serialNumber == pPix->drawable.serialNumber) &&

-	    (pCache->fg == -1) && (pCache->bg == -1)) {

-	    pCache->trans_color = -1;

-	    return pCache;

-	}

-   }

-

-   pCache = &cacheRoot[(*current)++];

-   if(*current >= max) *current = 0;

-

-   pCache->serialNumber = pPix->drawable.serialNumber;

-   pCache->trans_color = pCache->bg = pCache->fg = -1;

-   pCache->orig_w = w;  pCache->orig_h = h;

-

-   if(w <= 32) {

-        if(w & (w - 1))	funcNo = 1;

-        else    	funcNo = 0;

-   } else 		funcNo = 2;

-

-   pad = BitmapBytePad(pCache->w * bpp);

-   dwords = bytes_to_int32(pad);

-   dstPtr = data = (unsigned char*)malloc(pad * pCache->h);

-   srcPtr = (unsigned char*)pPix->devPrivate.ptr;

-

-   if(infoRec->ScreenToScreenColorExpandFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST)

-	StippleFunc = XAAStippleScanlineFuncMSBFirst[funcNo];

-   else

-	StippleFunc = XAAStippleScanlineFuncLSBFirst[funcNo];

-

-   /* don't bother generating more than we'll ever use */

-   max = ((pScrn->displayWidth + w - 1) + 31) >> 5;

-   if(dwords > max)

-	dwords = max;

-

-   for(i = 0; i < h; i++) {

-	(*StippleFunc)((CARD32*)dstPtr, (CARD32*)srcPtr, 0, w, dwords);

-	srcPtr += pPix->devKind;

-	dstPtr += pad;

-   }

-

-   while((h<<1) <= pCache->h) {

-	memcpy(data + (pad * h), data, pad * h);

-	h <<= 1;

-   }

- 

-   if(h < pCache->h)   

-	memcpy(data + (pad * h), data, pad * (pCache->h - h));

-

-   (*infoRec->WritePixmapToCache)(

-	pScrn, pCache->x, pCache->y, pCache->w, pCache->h, data,

-	pad, bpp, pScrn->depth);

-

-   free(data);

-

-   return pCache;

-}

-

-XAACacheInfoPtr

-XAACachePlanarMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix)

-{

-   int w = pPix->drawable.width;

-   int h = pPix->drawable.height;

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-   XAAPixmapCachePrivatePtr pCachePriv = 

-	(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate;

-   XAACacheInfoPtr pCache, cacheRoot = NULL;

-   int i, max = 0;

-   int *current;

-

-   if((h <= 128) && (w <= 128)) {

-	if(pCachePriv->Info128) {

-	    cacheRoot = pCachePriv->Info128; 

-	    max = pCachePriv->Num128x128;

-	    current = &pCachePriv->Current128;

-	} else {     

-	    cacheRoot = pCachePriv->InfoPartial;

-	    max = pCachePriv->NumPartial;

-	    current = &pCachePriv->CurrentPartial;

-	}

-   } else if((h <= 256) && (w <= 256)){

-	cacheRoot = pCachePriv->Info256;      

-	max = pCachePriv->Num256x256;

-	current = &pCachePriv->Current256;

-   } else if((h <= 512) && (w <= 526)){

-	cacheRoot = pCachePriv->Info512;      

-	max = pCachePriv->Num512x512;

-	current = &pCachePriv->Current512;

-   } else { /* something's wrong */ 

-	ErrorF("Something's wrong in XAACachePlanarMonoStipple()\n");

-	return pCachePriv->Info128; 

-   }

-

-   pCache = cacheRoot;

-

-   /* lets look for it */

-   for(i = 0; i < max; i++, pCache++) {

-	if((pCache->serialNumber == pPix->drawable.serialNumber) &&

-	    (pCache->fg == -1) && (pCache->bg == -1)) {

-	    pCache->trans_color = -1;

-	    return pCache;

-	}

-   }

-

-   pCache = &cacheRoot[(*current)++];

-   if(*current >= max) *current = 0;

-

-   pCache->serialNumber = pPix->drawable.serialNumber;

-   pCache->trans_color = pCache->bg = pCache->fg = -1;

-   pCache->orig_w = w;  pCache->orig_h = h;

-

-   /* Plane 0 holds the stipple. Plane 1 holds the inverted stipple */

-   (*infoRec->WriteBitmapToCache)(pScrn, pCache->x, pCache->y, 

-	pPix->drawable.width, pPix->drawable.height, pPix->devPrivate.ptr,

-	pPix->devKind, 1, 2);

-   if(!(infoRec->PixmapCacheFlags & DO_NOT_TILE_MONO_DATA) && 

-	((w != pCache->w) || (h != pCache->h)))

-	XAATileCache(pScrn, pCache, w, h);

-

-   return pCache;

-}

-

-XAACachePlanarMonoStippleProc

-XAAGetCachePlanarMonoStipple(void)

-{

-    return XAACachePlanarMonoStipple;

-}

-

-XAACacheInfoPtr

-XAACacheStipple(ScrnInfoPtr pScrn, PixmapPtr pPix, int fg, int bg)

-{

-   int w = pPix->drawable.width;

-   int h = pPix->drawable.height;

-   int size = max(w, h);

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-   XAAPixmapCachePrivatePtr pCachePriv = 

-	(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate;

-   XAACacheInfoPtr pCache, cacheRoot = NULL;

-   int i, max = 0;

-   int *current;

-

-   if(size <= 128) {

-	if(pCachePriv->Info128) {

-	    cacheRoot = pCachePriv->Info128; 

-	    max = pCachePriv->Num128x128;

-	    current = &pCachePriv->Current128;

-	} else {     

-	    cacheRoot = pCachePriv->InfoPartial;

-	    max = pCachePriv->NumPartial;

-	    current = &pCachePriv->CurrentPartial;

-	}

-   } else if(size <= 256) {

-	cacheRoot = pCachePriv->Info256;      

-	max = pCachePriv->Num256x256;

-	current = &pCachePriv->Current256;

-   } else if(size <= 512) {

-	cacheRoot = pCachePriv->Info512;      

-	max = pCachePriv->Num512x512;

-	current = &pCachePriv->Current512;

-   } else { /* something's wrong */

-	ErrorF("Something's wrong in XAACacheStipple()\n");

-	return pCachePriv->Info128; 

-   }

-

-   pCache = cacheRoot;

-   /* lets look for it */

-   if(bg == -1)

-	for(i = 0; i < max; i++, pCache++) {

-	    if((pCache->serialNumber == pPix->drawable.serialNumber) &&

-		(fg == pCache->fg) && (pCache->fg != pCache->bg)) {

-		pCache->trans_color = pCache->bg;

-		return pCache;

-	     }

-	}

-   else

-	for(i = 0; i < max; i++, pCache++) {

-	    if((pCache->serialNumber == pPix->drawable.serialNumber) &&

-		(fg == pCache->fg) && (bg == pCache->bg)) {

-		pCache->trans_color = -1;

-		return pCache;

-	     }

-	}

-

-   pCache = &cacheRoot[(*current)++];

-   if(*current >= max) *current = 0;

-

-   pCache->serialNumber = pPix->drawable.serialNumber;

-   pCache->fg = fg;

-   if(bg == -1)

-	pCache->trans_color = bg = fg ^ 1;

-   else

-	pCache->trans_color = -1;

-   pCache->bg = bg;

-

-   pCache->orig_w = w;  pCache->orig_h = h;

-   (*infoRec->WriteBitmapToCache)(pScrn, pCache->x, pCache->y, 

-	pPix->drawable.width, pPix->drawable.height, pPix->devPrivate.ptr,

-	pPix->devKind, fg, bg);

-   if(!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) && 

-	((w != pCache->w) || (h != pCache->h)))

-	XAATileCache(pScrn, pCache, w, h);

-

-   return pCache;

-}

-

-

-

-XAACacheInfoPtr

-XAACacheMono8x8Pattern(ScrnInfoPtr pScrn, int pat0, int pat1)

-{

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-   XAAPixmapCachePrivatePtr pCachePriv = 

-	(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate;

-   XAACacheInfoPtr pCache = pCachePriv->InfoMono;

-   int i;

-

-   for(i = 0; i < pCachePriv->NumMono; i++, pCache++) {

-    	if(pCache->serialNumber && 

-	   (pCache->pat0 == pat0) && (pCache->pat1 == pat1))

-		return pCache;

-   }

-

-   /* OK, let's cache it */

-   pCache = &pCachePriv->InfoMono[pCachePriv->CurrentMono++]; 

-   if(pCachePriv->CurrentMono >= pCachePriv->NumMono) 

-	pCachePriv->CurrentMono = 0;

-

-   pCache->serialNumber = 1; /* we don't care since we do lookups by pattern */

-   pCache->pat0 = pat0;

-   pCache->pat1 = pat1;

-

-   (*infoRec->WriteMono8x8PatternToCache)(pScrn, pCache);

-

-   return pCache;

-}

-

-

-

-XAACacheInfoPtr

-XAACacheColor8x8Pattern(ScrnInfoPtr pScrn, PixmapPtr pPix, int fg, int bg)

-{

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-   XAAPixmapCachePrivatePtr pCachePriv = 

-	(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate;

-   XAACacheInfoPtr pCache = pCachePriv->InfoColor;

-   XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix);

-   int i;

-

-   if(!(pixPriv->flags & REDUCIBLE_TO_2_COLOR)) {

-	for(i = 0; i < pCachePriv->NumColor; i++, pCache++) {

-	     if(pCache->serialNumber == pPix->drawable.serialNumber) {

-		pCache->trans_color = -1;

-		return pCache;	

-	     }

-	}

-	pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++]; 

-	if(pCachePriv->CurrentColor >= pCachePriv->NumColor) 

-		pCachePriv->CurrentColor = 0;

-

-	pCache->serialNumber = pPix->drawable.serialNumber;

-	pCache->trans_color = pCache->fg = pCache->bg = -1;

-   } else {

-	int pat0 = pixPriv->pattern0;

-	int pat1 = pixPriv->pattern1;

-

-	if(fg == -1) { /* it's a tile */

-	   fg = pixPriv->fg; bg = pixPriv->bg;

-	}

-

-	if(bg == -1) { /* stipple */

-	    for(i = 0; i < pCachePriv->NumColor; i++, pCache++) {

-		if(pCache->serialNumber &&

-		   (pCache->pat0 == pat0) && (pCache->pat1 == pat1) &&

-		   (pCache->fg == fg) && (pCache->bg != fg)) {

-		   pCache->trans_color = pCache->bg;

-		   return pCache;	

-		}

-	    }

-	} else {  /* opaque stipple */

-	    for(i = 0; i < pCachePriv->NumColor; i++, pCache++) {

-		if(pCache->serialNumber &&

-		   (pCache->pat0 == pat0) && (pCache->pat1 == pat1) &&

-		   (pCache->fg == fg) && (pCache->bg == bg)) {

-		   pCache->trans_color = -1;

-		   return pCache;	

-		}

-	    }

-	}

-	pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++]; 

-	if(pCachePriv->CurrentColor >= pCachePriv->NumColor) 

-		pCachePriv->CurrentColor = 0;

-

-        if(bg == -1)

-	    pCache->trans_color = bg = fg ^ 1;

-	else

-	    pCache->trans_color = -1;

-

-	pCache->pat0 = pat0; pCache->pat1 = pat1;

-	pCache->fg = fg; pCache->bg = bg;

-	pCache->serialNumber = 1;

-   }

-

-   (*infoRec->WriteColor8x8PatternToCache)(pScrn, pPix, pCache);

-

-   return pCache;

-}

-

-

-void

-XAAWriteBitmapToCache(

-   ScrnInfoPtr pScrn,

-   int x, int y, int w, int h,

-   unsigned char *src,

-   int srcwidth,

-   int fg, int bg

-) {

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-

-   (*infoRec->WriteBitmap)(pScrn, x, y, w, h, src, srcwidth, 

-					0, fg, bg, GXcopy, ~0);

-}

-

-void

-XAAWriteBitmapToCacheLinear(

-   ScrnInfoPtr pScrn,

-   int x, int y, int w, int h,

-   unsigned char *src,

-   int srcwidth,

-   int fg, int bg

-){

-   ScreenPtr pScreen = pScrn->pScreen;

-   PixmapPtr pScreenPix, pDstPix;

-   ChangeGCVal gcvals[2];

-   GCPtr pGC;

-

-   pScreenPix = (*pScreen->GetScreenPixmap)(pScreen);

-

-   pDstPix = GetScratchPixmapHeader(pScreen, pScreenPix->drawable.width, 

-					y + h, pScreenPix->drawable.depth, 

-					pScreenPix->drawable.bitsPerPixel, 

-					pScreenPix->devKind,

-					pScreenPix->devPrivate.ptr);

-   

-   pGC = GetScratchGC(pScreenPix->drawable.depth, pScreen);

-   gcvals[0].val = fg;

-   gcvals[1].val = bg;

-   ChangeGC(NullClient, pGC, GCForeground | GCBackground, gcvals);

-   ValidateGC((DrawablePtr)pDstPix, pGC);

-

-   /* We've unwrapped already so these ops miss a sync */

-   SYNC_CHECK(pScrn);

-

-   (*pGC->ops->PutImage)((DrawablePtr)pDstPix, pGC, 1, x, y, w, h, 0,

-						XYBitmap, (pointer)src);

-

-   FreeScratchGC(pGC);

-   FreeScratchPixmapHeader(pDstPix);

-}

-

-

-void

-XAAWritePixmapToCache(

-   ScrnInfoPtr pScrn,

-   int x, int y, int w, int h,

-   unsigned char *src,

-   int srcwidth,

-   int bpp, int depth

-) {

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-

-   (*infoRec->WritePixmap)(pScrn, x, y, w, h, src, srcwidth,

-				GXcopy, ~0, -1, bpp, depth);

-}

-

-

-

-void

-XAAWritePixmapToCacheLinear(

-   ScrnInfoPtr pScrn,

-   int x, int y, int w, int h,

-   unsigned char *src,

-   int srcwidth,

-   int bpp, int depth

-){

-   ScreenPtr pScreen = pScrn->pScreen;

-   PixmapPtr pScreenPix, pDstPix;

-   GCPtr pGC;

-

-   pScreenPix = (*pScreen->GetScreenPixmap)(pScreen);

-

-   pDstPix = GetScratchPixmapHeader(pScreen, x + w, y + h, 

-					depth, bpp, pScreenPix->devKind,

-					pScreenPix->devPrivate.ptr);

-   

-   pGC = GetScratchGC(depth, pScreen);

-   ValidateGC((DrawablePtr)pDstPix, pGC);

-

-   /* We've unwrapped already so these ops miss a sync */

-   SYNC_CHECK(pScrn);

-

-   if(bpp == BitsPerPixel(depth))

-	(*pGC->ops->PutImage)((DrawablePtr)pDstPix, pGC, depth, x, y, w, 

-					h, 0, ZPixmap, (pointer)src);

-   else {

-	PixmapPtr pSrcPix;

-

-	pSrcPix = GetScratchPixmapHeader(pScreen, w, h, depth, bpp,

-					srcwidth, (pointer)src);

-	

-	(*pGC->ops->CopyArea)((DrawablePtr)pSrcPix, (DrawablePtr)pDstPix,

-					pGC, 0, 0, w, h, x, y);

-		

-	FreeScratchPixmapHeader(pSrcPix);

-   }

-

-   FreeScratchGC(pGC);

-   FreeScratchPixmapHeader(pDstPix);

-}

-

-

-void

-XAAWriteMono8x8PatternToCache(

-   ScrnInfoPtr pScrn, 

-   XAACacheInfoPtr pCache

-){

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-   XAAPixmapCachePrivatePtr pCachePriv = 

-	(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate;

-   unsigned char *data;

-   int pad, Bpp = (pScrn->bitsPerPixel >> 3);

-   

-   pCache->offsets = pCachePriv->MonoOffsets;

-

-   pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel);

-

-   data = (unsigned char*)malloc(pad * pCache->h);

-   if(!data) return;

-

-   if(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {

-	CARD32* ptr = (CARD32*)data;

-	ptr[0] = pCache->pat0;  ptr[1] = pCache->pat1;

-   } else {

-	CARD32 *ptr;

-	DDXPointPtr pPoint = pCache->offsets;

-	int patx, paty, i;

-

-	for(i = 0; i < 64; i++, pPoint++) {

-	     patx = pCache->pat0; paty = pCache->pat1;

-	     XAARotateMonoPattern(&patx, &paty, i & 0x07, i >> 3,

-				(infoRec->Mono8x8PatternFillFlags & 		

-				BIT_ORDER_IN_BYTE_MSBFIRST));

-	     ptr = (CARD32*)(data + (pad * pPoint->y) + (Bpp * pPoint->x));

-	     ptr[0] = patx;  ptr[1] = paty;

-	}

-   }

-

-   (*infoRec->WritePixmapToCache)(pScrn, pCache->x, pCache->y, 

-	pCache->w, pCache->h, data, pad, pScrn->bitsPerPixel, pScrn->depth);

-

-   free(data);

-}

-

-void

-XAAWriteColor8x8PatternToCache(

-   ScrnInfoPtr pScrn, 

-   PixmapPtr pPix, 

-   XAACacheInfoPtr pCache

-){

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-   XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix);

-   XAAPixmapCachePrivatePtr pCachePriv = 

-	(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate;

-   int pad, i, w, h, nw, nh, Bpp;

-   unsigned char *data, *srcPtr, *dstPtr;

-

-   pCache->offsets = pCachePriv->ColorOffsets;

-

-   if(pixPriv->flags & REDUCIBLE_TO_2_COLOR) {

-	CARD32* ptr;

-	pad = BitmapBytePad(pCache->w);

-	data = (unsigned char*)malloc(pad * pCache->h);

-	if(!data) return;

-

-	if(infoRec->Color8x8PatternFillFlags & 

-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {

-	     ptr = (CARD32*)data;

-	     ptr[0] = pCache->pat0; ptr[1] = pCache->pat1;

-	} else {

-	   int patx, paty;

-	

-	   ptr = (CARD32*)data;

-	   ptr[0] = ptr[2] = pCache->pat0;  ptr[1] = ptr[3] = pCache->pat1;

-	   for(i = 1; i < 8; i++) {

-		patx = pCache->pat0; paty = pCache->pat1;

-		XAARotateMonoPattern(&patx, &paty, i, 0,

-				(infoRec->Mono8x8PatternFillFlags & 		

-				BIT_ORDER_IN_BYTE_MSBFIRST));

-		ptr = (CARD32*)(data + (pad * i));

-		ptr[0] = ptr[2] = patx;  ptr[1] = ptr[3] = paty;

-	   }

-	}

-

-	(*infoRec->WriteBitmapToCache)(pScrn, pCache->x, pCache->y, 

-		pCache->w, pCache->h, data, pad, pCache->fg, pCache->bg);

-

-        free(data);

-	return;

-   } 

-

-   Bpp = pScrn->bitsPerPixel >> 3;

-   h = min(8,pPix->drawable.height);

-   w = min(8,pPix->drawable.width);

-   pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel);

-

-   data = (unsigned char*)malloc(pad * pCache->h);

-   if(!data) return;

-

-   /* Write and expand horizontally. */

-   for (i = h, dstPtr = data, srcPtr = pPix->devPrivate.ptr; i--; 

-	srcPtr += pPix->devKind, dstPtr += pScrn->bitsPerPixel) {

-         nw = w;

-         memcpy(dstPtr, srcPtr, w * Bpp);

-         while (nw != 8) {

-            memcpy(dstPtr + (nw * Bpp), dstPtr, nw * Bpp);

-            nw <<= 1;

-         }

-   }

-   nh = h;

-   /* Expand vertically. */

-   while (nh != 8) {

-        memcpy(data + (nh*pScrn->bitsPerPixel), data, nh*pScrn->bitsPerPixel);

-        nh <<= 1;

-   }

-

-   if(!(infoRec->Color8x8PatternFillFlags & 

-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){

-	int j;

-        unsigned char *ptr = data + (128 * Bpp);

-

-	memcpy(data + (64 * Bpp), data, 64 * Bpp);

-	for(i = 1; i < 8; i++, ptr += (128 * Bpp)) {

-	   for(j = 0; j < 8; j++) {

-		memcpy(ptr + (j * 8) * Bpp, data + (j * 8 + i) * Bpp,

-			(8 - i) * Bpp);

-		memcpy(ptr + (j * 8 + 8 - i) * Bpp, data + j * 8 * Bpp, i*Bpp);

-	   }

-	   memcpy(ptr + (64 * Bpp), ptr, 64 * Bpp);

-	}

-   }

-

-   (*infoRec->WritePixmapToCache)(pScrn, pCache->x, pCache->y, 

-	pCache->w, pCache->h, data, pad, pScrn->bitsPerPixel, pScrn->depth);

-

-   free(data);

-}

-

-

-

-int

-XAAStippledFillChooser(GCPtr pGC)

-{

-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

-    PixmapPtr pPixmap = pGC->stipple;

-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);

-

-    if(!(pPriv->flags & REDUCIBILITY_CHECKED) &&

-	(infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {

-	XAACheckStippleReducibility(pPixmap);

-    }

-

-

-    if(pPriv->flags & REDUCIBLE_TO_8x8) {

-	if(infoRec->CanDoMono8x8 && 

-	   !(infoRec->FillMono8x8PatternSpansFlags & NO_TRANSPARENCY) && 

-	   ((pGC->alu == GXcopy) || !(infoRec->FillMono8x8PatternSpansFlags & 

-		TRANSPARENCY_GXCOPY_ONLY)) &&

-	   CHECK_ROP(pGC,infoRec->FillMono8x8PatternSpansFlags) &&

-	   CHECK_ROPSRC(pGC,infoRec->FillMono8x8PatternSpansFlags) &&

-	   CHECK_FG(pGC,infoRec->FillMono8x8PatternSpansFlags) &&

-	   CHECK_PLANEMASK(pGC,infoRec->FillMono8x8PatternSpansFlags)) {

-

-	      return DO_MONO_8x8;

-	}

-

-	if(infoRec->CanDoColor8x8 && 

-	   !(infoRec->FillColor8x8PatternSpansFlags & NO_TRANSPARENCY) && 

-	   ((pGC->alu == GXcopy) || !(infoRec->FillColor8x8PatternSpansFlags &

-		TRANSPARENCY_GXCOPY_ONLY)) &&

-	   CHECK_ROP(pGC,infoRec->FillColor8x8PatternSpansFlags) &&

-	   CHECK_ROPSRC(pGC,infoRec->FillColor8x8PatternSpansFlags) &&

-	   CHECK_PLANEMASK(pGC,infoRec->FillColor8x8PatternSpansFlags)) {

-

-	      return DO_COLOR_8x8;

-	}

-    }

-

-    if(infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans && 

-	(pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) &&

-	(pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth /

-	 infoRec->CacheColorExpandDensity) &&

-	!(infoRec->FillCacheExpandSpansFlags & NO_TRANSPARENCY) && 

-	((pGC->alu == GXcopy) || !(infoRec->FillCacheExpandSpansFlags & 

-		TRANSPARENCY_GXCOPY_ONLY)) &&

-	CHECK_ROP(pGC,infoRec->FillCacheExpandSpansFlags) &&

-	CHECK_ROPSRC(pGC,infoRec->FillCacheExpandSpansFlags) &&

-	CHECK_FG(pGC,infoRec->FillCacheExpandSpansFlags) &&

-	CHECK_PLANEMASK(pGC,infoRec->FillCacheExpandSpansFlags)) {

-

-	      return DO_CACHE_EXPAND;

-    }

-

-

-    if(infoRec->UsingPixmapCache && 

-	!(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) && 

-	infoRec->FillCacheBltSpans && 

-	(pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) &&

-	(pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) &&

-	!(infoRec->FillCacheBltSpansFlags & NO_TRANSPARENCY) && 

-	((pGC->alu == GXcopy) || !(infoRec->FillCacheBltSpansFlags & 

-		TRANSPARENCY_GXCOPY_ONLY)) &&

-	CHECK_ROP(pGC,infoRec->FillCacheBltSpansFlags) &&

-	CHECK_ROPSRC(pGC,infoRec->FillCacheBltSpansFlags) &&

-	CHECK_PLANEMASK(pGC,infoRec->FillCacheBltSpansFlags)) {

-

-	      return DO_CACHE_BLT;

-    }

-

-    if(infoRec->FillColorExpandSpans && 

-	!(infoRec->FillColorExpandSpansFlags & NO_TRANSPARENCY) && 

-	((pGC->alu == GXcopy) || !(infoRec->FillColorExpandSpansFlags & 

-		TRANSPARENCY_GXCOPY_ONLY)) &&

-	CHECK_ROP(pGC,infoRec->FillColorExpandSpansFlags) &&

-	CHECK_ROPSRC(pGC,infoRec->FillColorExpandSpansFlags) &&

-	CHECK_FG(pGC,infoRec->FillColorExpandSpansFlags) &&

-	CHECK_PLANEMASK(pGC,infoRec->FillColorExpandSpansFlags)) {

-

-	      return DO_COLOR_EXPAND;

-    }

-

-    return 0;

-}

-

-

-int

-XAAOpaqueStippledFillChooser(GCPtr pGC)

-{

-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

-    PixmapPtr pPixmap = pGC->stipple;

-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);

-

-    if(XAA_DEPTH_BUG(pGC))

-	 return 0;

-

-    if(!(pPriv->flags & REDUCIBILITY_CHECKED) &&

-	(infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {

-	XAACheckStippleReducibility(pPixmap);

-    }

-

-    if(pPriv->flags & REDUCIBLE_TO_8x8) {

-	if(infoRec->CanDoMono8x8 && 

-	   !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) && 

-	   CHECK_ROP(pGC,infoRec->FillMono8x8PatternSpansFlags) &&

-	   CHECK_ROPSRC(pGC,infoRec->FillMono8x8PatternSpansFlags) &&

-	   CHECK_COLORS(pGC,infoRec->FillMono8x8PatternSpansFlags) &&

-	   CHECK_PLANEMASK(pGC,infoRec->FillMono8x8PatternSpansFlags)) {

-

-	      return DO_MONO_8x8;

-	}

-

-	if(infoRec->CanDoColor8x8 && 

-	   CHECK_ROP(pGC,infoRec->FillColor8x8PatternSpansFlags) &&

-	   CHECK_ROPSRC(pGC,infoRec->FillColor8x8PatternSpansFlags) &&

-	   CHECK_PLANEMASK(pGC,infoRec->FillColor8x8PatternSpansFlags)) {

-

-	      return DO_COLOR_8x8;

-	}

-    }

-

-    if(infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans && 

-	(pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) &&

-	(pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth /

-	 infoRec->CacheColorExpandDensity) &&

-	!(infoRec->FillCacheExpandSpansFlags & TRANSPARENCY_ONLY) && 

-	CHECK_ROP(pGC,infoRec->FillCacheExpandSpansFlags) &&

-	CHECK_ROPSRC(pGC,infoRec->FillCacheExpandSpansFlags) &&

-	CHECK_COLORS(pGC,infoRec->FillCacheExpandSpansFlags) &&

-	CHECK_PLANEMASK(pGC,infoRec->FillCacheExpandSpansFlags)) {

-

-	      return DO_CACHE_EXPAND;

-    } 

-

-    if(infoRec->UsingPixmapCache &&

-	!(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) && 

-	infoRec->FillCacheBltSpans && 

-	(pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) &&

-	(pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) &&

-	CHECK_ROP(pGC,infoRec->FillCacheBltSpansFlags) &&

-	CHECK_ROPSRC(pGC,infoRec->FillCacheBltSpansFlags) &&

-	CHECK_PLANEMASK(pGC,infoRec->FillCacheBltSpansFlags)) {

-

-	      return DO_CACHE_BLT;

-    } 

-

-    if(infoRec->FillColorExpandSpans && 

-	!(infoRec->FillColorExpandSpansFlags & TRANSPARENCY_ONLY) && 

-	CHECK_ROP(pGC,infoRec->FillColorExpandSpansFlags) &&

-	CHECK_ROPSRC(pGC,infoRec->FillColorExpandSpansFlags) &&

-	CHECK_COLORS(pGC,infoRec->FillColorExpandSpansFlags) &&

-	CHECK_PLANEMASK(pGC,infoRec->FillColorExpandSpansFlags)) {

-

-	      return DO_COLOR_EXPAND;

-    }

-

-    return 0;

-}

-

-

-

-int

-XAATiledFillChooser(GCPtr pGC)

-{

-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

-    PixmapPtr pPixmap = pGC->tile.pixmap;

-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);

-

-    if(IS_OFFSCREEN_PIXMAP(pPixmap) && infoRec->FillCacheBltSpans &&

-	CHECK_ROP(pGC,infoRec->FillCacheBltSpansFlags) &&

-	CHECK_ROPSRC(pGC,infoRec->FillCacheBltSpansFlags) &&

-	CHECK_PLANEMASK(pGC,infoRec->FillCacheBltSpansFlags)) {

-

-	return DO_PIXMAP_COPY;

-    }

-

-    if(!(pPriv->flags & REDUCIBILITY_CHECKED) &&

-	(infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {

-	XAACheckTileReducibility(pPixmap,infoRec->CanDoMono8x8);

-    }

-

-    if(pPriv->flags & REDUCIBLE_TO_8x8) {

-	if((pPriv->flags & REDUCIBLE_TO_2_COLOR) && infoRec->CanDoMono8x8 && 

-	   !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) && 

-	   CHECK_ROP(pGC,infoRec->FillMono8x8PatternSpansFlags) &&

-	   CHECK_ROPSRC(pGC,infoRec->FillMono8x8PatternSpansFlags) &&

-	   (!(infoRec->FillMono8x8PatternSpansFlags & RGB_EQUAL) || 

-		(CHECK_RGB_EQUAL(pPriv->fg) && CHECK_RGB_EQUAL(pPriv->bg))) &&

-	   CHECK_PLANEMASK(pGC,infoRec->FillMono8x8PatternSpansFlags)) {

-

-	      return DO_MONO_8x8;

-	}

-

-	if(infoRec->CanDoColor8x8 && 

-	   CHECK_ROP(pGC,infoRec->FillColor8x8PatternSpansFlags) &&

-	   CHECK_ROPSRC(pGC,infoRec->FillColor8x8PatternSpansFlags) &&

-	   CHECK_PLANEMASK(pGC,infoRec->FillColor8x8PatternSpansFlags)) {

-

-	      return DO_COLOR_8x8;

-	}

-    }

-

-    if(infoRec->UsingPixmapCache && infoRec->FillCacheBltSpans && 

-	(pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) &&

-	(pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) &&

-	CHECK_ROP(pGC,infoRec->FillCacheBltSpansFlags) &&

-	CHECK_ROPSRC(pGC,infoRec->FillCacheBltSpansFlags) &&

-	CHECK_PLANEMASK(pGC,infoRec->FillCacheBltSpansFlags)) {

-

-	      return DO_CACHE_BLT;

-    }

-

-    if(infoRec->FillImageWriteRects && 

-	CHECK_NO_GXCOPY(pGC,infoRec->FillImageWriteRectsFlags) &&

-	CHECK_ROP(pGC,infoRec->FillImageWriteRectsFlags) &&

-	CHECK_ROPSRC(pGC,infoRec->FillImageWriteRectsFlags) &&

-	CHECK_PLANEMASK(pGC,infoRec->FillImageWriteRectsFlags)) {

-

-	      return DO_IMAGE_WRITE;

-    }

-

-    return 0;

-}

-

-

-static int RotateMasksX[8] = {

-   0xFFFFFFFF, 0x7F7F7F7F, 0x3F3F3F3F, 0x1F1F1F1F,

-   0x0F0F0F0F, 0x07070707, 0x03030303, 0x01010101

-};

-

-static int RotateMasksY[4] = {

-   0xFFFFFFFF, 0x00FFFFFF, 0x0000FFFF, 0x000000FF

-};

-

-void

-XAARotateMonoPattern(

-    int *pat0, int *pat1,

-    int xorg, int yorg,

-    Bool msbfirst

-){

-    int tmp, mask;    

-

-    if(xorg) {

-	if(msbfirst) xorg = 8 - xorg;

-	mask = RotateMasksX[xorg];

-	*pat0 = ((*pat0 >> xorg) & mask) | ((*pat0 << (8 - xorg)) & ~mask);

-	*pat1 = ((*pat1 >> xorg) & mask) | ((*pat1 << (8 - xorg)) & ~mask);

-    } 

-    if(yorg >= 4) {

-	tmp = *pat0; *pat0 = *pat1; *pat1 = tmp;

-	yorg -= 4;

-    }

-    if(yorg) {

-	mask = RotateMasksY[yorg];

-	yorg <<= 3;

-	tmp = *pat0;

-	*pat0 = ((*pat0 >> yorg) & mask) | ((*pat1 << (32 - yorg)) & ~mask);  

-	*pat1 = ((*pat1 >> yorg) & mask) | ((tmp << (32 - yorg)) & ~mask);

-    }

-}

-

-

-

-void

-XAAInvalidatePixmapCache(ScreenPtr pScreen)

-{

-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

-   XAAPixmapCachePrivatePtr pCachePriv = 

-	(XAAPixmapCachePrivatePtr)infoRec->PixmapCachePrivate;

-   int i;

-

-   if(!pCachePriv) return;

-

-   for(i = 0; i < pCachePriv->Num512x512; i++) 

-	(pCachePriv->Info512)[i].serialNumber = 0;

-   for(i = 0; i < pCachePriv->Num256x256; i++) 

-	(pCachePriv->Info256)[i].serialNumber = 0;

-   for(i = 0; i < pCachePriv->Num128x128; i++) 

-	(pCachePriv->Info128)[i].serialNumber = 0;

-   for(i = 0; i < pCachePriv->NumPartial; i++) 

-	(pCachePriv->InfoPartial)[i].serialNumber = 0;

-   for(i = 0; i < pCachePriv->NumMono; i++) 

-	(pCachePriv->InfoMono)[i].serialNumber = 0;

-   for(i = 0; i < pCachePriv->NumColor; i++) 

-	(pCachePriv->InfoColor)[i].serialNumber = 0;

-}

+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <string.h>
+
+#include "misc.h"
+#include "xf86.h"
+#include "xf86_OSproc.h"
+
+#include <X11/X.h>
+#include "scrnintstr.h"
+#include "gc.h"
+#include "mi.h"
+#include "pixmapstr.h"
+#include "windowstr.h"
+#include "regionstr.h"
+#include "servermd.h"
+#include "xf86str.h"
+#include "xaa.h"
+#include "xaacexp.h"
+#include "xaalocal.h"
+#include "xaawrap.h"
+
+#define MAX_COLOR	32
+#define MAX_MONO	32
+#define MAX_8		32
+#define MAX_128		32
+#define MAX_256		32
+#define MAX_512		16
+
+static int CacheInitIndex = -1;
+
+#define CACHEINIT(p) ((p)->privates[CacheInitIndex].val)
+
+typedef struct _CacheLink {
+    int x;
+    int y;
+    int w;
+    int h;
+    struct _CacheLink *next;
+} CacheLink, *CacheLinkPtr;
+
+static void
+TransferList(CacheLinkPtr list, XAACacheInfoPtr array, int num)
+{
+    while (num--) {
+        array->x = list->x;
+        array->y = list->y;
+        array->w = list->w;
+        array->h = list->h;
+        array->serialNumber = 0;
+        array->fg = array->bg = -1;
+        list = list->next;
+        array++;
+    }
+}
+
+static CacheLinkPtr
+Enlist(CacheLinkPtr link, int x, int y, int w, int h)
+{
+    CacheLinkPtr newLink;
+
+    newLink = malloc(sizeof(CacheLink));
+    newLink->next = link;
+    newLink->x = x;
+    newLink->y = y;
+    newLink->w = w;
+    newLink->h = h;
+    return newLink;
+}
+
+static CacheLinkPtr
+Delist(CacheLinkPtr link)
+{
+    CacheLinkPtr ret = NULL;
+
+    if (link) {
+        ret = link->next;
+        free(link);
+    }
+    return ret;
+}
+
+static void
+FreeList(CacheLinkPtr link)
+{
+    CacheLinkPtr tmp;
+
+    while (link) {
+        tmp = link;
+        link = link->next;
+        free(tmp);
+    }
+}
+
+static CacheLinkPtr
+QuadLinks(CacheLinkPtr big, CacheLinkPtr little)
+{
+    /* CAUTION: This doesn't free big */
+    int w1, w2, h1, h2;
+
+    while (big) {
+        w1 = big->w >> 1;
+        w2 = big->w - w1;
+        h1 = big->h >> 1;
+        h2 = big->h - h1;
+
+        little = Enlist(little, big->x, big->y, w1, h1);
+        little = Enlist(little, big->x + w1, big->y, w2, h1);
+        little = Enlist(little, big->x, big->y + h1, w1, h2);
+        little = Enlist(little, big->x + w1, big->y + h1, w2, h2);
+
+        big = big->next;
+    }
+    return little;
+}
+
+static void
+SubdivideList(CacheLinkPtr * large, CacheLinkPtr * small)
+{
+    CacheLinkPtr big = *large;
+    CacheLinkPtr little = *small;
+    int size = big->w >> 1;
+
+    little = Enlist(little, big->x, big->y, size, size);
+    little = Enlist(little, big->x + size, big->y, size, size);
+    little = Enlist(little, big->x, big->y + size, size, size);
+    little = Enlist(little, big->x + size, big->y + size, size, size);
+    *small = little;
+    big = Delist(big);
+    *large = big;
+}
+
+static void
+FreePixmapCachePrivate(XAAPixmapCachePrivatePtr pPriv)
+{
+    if (!pPriv)
+        return;
+
+    free(pPriv->Info512);
+    free(pPriv->Info256);
+    free(pPriv->Info128);
+    free(pPriv->InfoColor);
+    free(pPriv->InfoMono);
+    free(pPriv->InfoPartial);
+
+    free(pPriv);
+}
+
+void
+XAAClosePixmapCache(ScreenPtr pScreen)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
+
+    if (infoRec->PixmapCachePrivate)
+        FreePixmapCachePrivate((XAAPixmapCachePrivatePtr) infoRec->
+                               PixmapCachePrivate);
+
+    infoRec->PixmapCachePrivate = NULL;
+}
+
+static CacheLinkPtr
+ThinOutPartials(CacheLinkPtr ListPartial, int *num, int *maxw, int *maxh)
+{
+/* This guy's job is to get at least 4 big slots out of a list of fragments */
+
+    CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers;
+    int Num64, Num32, Num16, Num8, NumKeepers;
+    int w, h;
+
+    List64 = List32 = List16 = List8 = ListKeepers = NULL;
+    Num64 = Num32 = Num16 = Num8 = NumKeepers = 0;
+    w = h = 0;
+
+    /* We sort partials by how large a square tile they can cache.
+       If a partial can't store a 64x64, 32x32, 16x16 or 8x8 tile,
+       we free it.  */
+
+    pCur = ListPartial;
+    while (pCur) {
+        next = pCur->next;
+        if ((pCur->w >= 64) && (pCur->h >= 64)) {
+            pCur->next = List64;
+            List64 = pCur;
+            Num64++;
+        }
+        else if ((pCur->w >= 32) && (pCur->h >= 32)) {
+            pCur->next = List32;
+            List32 = pCur;
+            Num32++;
+        }
+        else if ((pCur->w >= 16) && (pCur->h >= 16)) {
+            pCur->next = List16;
+            List16 = pCur;
+            Num16++;
+        }
+        else if ((pCur->w >= 8) && (pCur->h >= 8)) {
+            pCur->next = List8;
+            List8 = pCur;
+            Num8++;
+        }
+        else {
+            free(pCur);
+        }
+
+        pCur = next;
+    }
+
+    /* We save all the tiles from the largest bin that we can get
+       at least 4 of.  If there are too few of a bigger slot, we
+       cut it in fourths to make smaller slots. */
+
+    if (Num64 >= 4) {
+        ListKeepers = List64;
+        List64 = NULL;
+        NumKeepers = Num64;
+        goto GOT_EM;
+    }
+    else if (Num64) {
+        List32 = QuadLinks(List64, List32);
+        Num32 += Num64 * 4;
+        Num64 = 0;
+    }
+
+    if (Num32 >= 4) {
+        ListKeepers = List32;
+        List32 = NULL;
+        NumKeepers = Num32;
+        goto GOT_EM;
+    }
+    else if (Num32) {
+        List16 = QuadLinks(List32, List16);
+        Num16 += Num32 * 4;
+        Num32 = 0;
+    }
+
+    if (Num16 >= 4) {
+        ListKeepers = List16;
+        List16 = NULL;
+        NumKeepers = Num16;
+        goto GOT_EM;
+    }
+    else if (Num16) {
+        List8 = QuadLinks(List16, List8);
+        Num8 += Num16 * 4;
+        Num16 = 0;
+    }
+
+    if (Num8 >= 4) {
+        ListKeepers = List8;
+        List8 = NULL;
+        NumKeepers = Num8;
+        goto GOT_EM;
+    }
+
+ GOT_EM:
+
+    /* Free the ones we aren't using */
+
+    if (List64)
+        FreeList(List64);
+    if (List32)
+        FreeList(List32);
+    if (List16)
+        FreeList(List16);
+    if (List8)
+        FreeList(List8);
+
+    /* Enlarge the slots if we can */
+
+    if (ListKeepers) {
+        CacheLinkPtr pLink = ListKeepers;
+
+        w = h = 128;
+
+        while (pLink) {
+            if (pLink->w < w)
+                w = pLink->w;
+            if (pLink->h < h)
+                h = pLink->h;
+            pLink = pLink->next;
+        }
+    }
+
+    *maxw = w;
+    *maxh = h;
+    *num = NumKeepers;
+    return ListKeepers;
+}
+
+static void
+ConvertColorToMono(CacheLinkPtr * ColorList,
+                   int ColorW, int ColorH,
+                   CacheLinkPtr * MonoList, int MonoW, int MonoH)
+{
+    int x, y, w;
+
+    x = (*ColorList)->x;
+    y = (*ColorList)->y;
+    *ColorList = Delist(*ColorList);
+
+    while (ColorH) {
+        ColorH -= MonoH;
+        for (w = 0; w <= (ColorW - MonoW); w += MonoW)
+            *MonoList = Enlist(*MonoList, x + w, y + ColorH, MonoW, MonoH);
+    }
+}
+
+static void
+ConvertAllPartialsTo8x8(int *NumMono, int *NumColor,
+                        CacheLinkPtr ListPartial,
+                        CacheLinkPtr * ListMono,
+                        CacheLinkPtr * ListColor, XAAInfoRecPtr infoRec)
+{
+/* This guy extracts as many 8x8 slots as it can out of fragments */
+
+    int ColorH = infoRec->CacheHeightColor8x8Pattern;
+    int ColorW = infoRec->CacheWidthColor8x8Pattern;
+    int MonoH = infoRec->CacheHeightMono8x8Pattern;
+    int MonoW = infoRec->CacheWidthMono8x8Pattern;
+    int x, y, w, Height, Width;
+    Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8);
+    Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8);
+    CacheLinkPtr pLink = ListPartial;
+    CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor;
+
+    if (DoColor && DoMono) {
+        /* we assume color patterns take more space than color ones */
+        if (MonoH > ColorH)
+            ColorH = MonoH;
+        if (MonoW > ColorW)
+            ColorW = MonoW;
+    }
+
+    /* Break up the area into as many Color and Mono slots as we can */
+
+    while (pLink) {
+        Height = pLink->h;
+        Width = pLink->w;
+        x = pLink->x;
+        y = pLink->y;
+
+        if (DoColor) {
+            while (Height >= ColorH) {
+                Height -= ColorH;
+                for (w = 0; w <= (Width - ColorW); w += ColorW) {
+                    ColorList =
+                        Enlist(ColorList, x + w, y + Height, ColorW, ColorH);
+                    (*NumColor)++;
+                }
+            }
+        }
+
+        if (DoMono && (Height >= MonoH)) {
+            while (Height >= MonoH) {
+                Height -= MonoH;
+                for (w = 0; w <= (Width - MonoW); w += MonoW) {
+                    MonoList =
+                        Enlist(MonoList, x + w, y + Height, MonoW, MonoH);
+                    (*NumMono)++;
+                }
+            }
+        }
+
+        pLink = pLink->next;
+    }
+
+    *ListMono = MonoList;
+    *ListColor = ColorList;
+    FreeList(ListPartial);
+}
+
+static CacheLinkPtr
+ExtractOneThatFits(CacheLinkPtr * initList, int w, int h)
+{
+    CacheLinkPtr list = *initList;
+    CacheLinkPtr prev = NULL;
+
+    while (list) {
+        if ((list->w >= w) && (list->h >= h))
+            break;
+        prev = list;
+        list = list->next;
+    }
+
+    if (list) {
+        if (prev)
+            prev->next = list->next;
+        else
+            *initList = list->next;
+
+        list->next = NULL;
+    }
+
+    return list;
+}
+
+static CacheLinkPtr
+ConvertSomePartialsTo8x8(int *NumMono, int *NumColor, int *NumPartial,
+                         CacheLinkPtr ListPartial,
+                         CacheLinkPtr * ListMono,
+                         CacheLinkPtr * ListColor,
+                         int *maxw, int *maxh, XAAInfoRecPtr infoRec)
+{
+/* This guy tries to get 4 of each type of 8x8 slot requested out of
+   a list of fragments all while trying to retain some big fragments
+   for the cache blits */
+
+    int ColorH = infoRec->CacheHeightColor8x8Pattern;
+    int ColorW = infoRec->CacheWidthColor8x8Pattern;
+    int MonoH = infoRec->CacheHeightMono8x8Pattern;
+    int MonoW = infoRec->CacheWidthMono8x8Pattern;
+    Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8);
+    Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8);
+    CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers;
+    CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor;
+    int Num64, Num32, Num16, Num8, NumKeepers;
+    int w, h, Width, Height;
+    int MonosPerColor = 1;
+
+    if (DoColor && DoMono) {
+        /* we assume color patterns take more space than color ones */
+        if (MonoH > ColorH)
+            ColorH = MonoH;
+        if (MonoW > ColorW)
+            ColorW = MonoW;
+        MonosPerColor = (ColorH / MonoH) * (ColorW / MonoW);
+    }
+
+    List64 = List32 = List16 = List8 = ListKeepers = MonoList = ColorList =
+        NULL;
+    Num64 = Num32 = Num16 = Num8 = NumKeepers = 0;
+    Width = Height = 0;
+
+    /* We sort partials by how large a square tile they can cache.
+       We make 8x8 patterns from the leftovers if we can. */
+
+    pCur = ListPartial;
+    while (pCur) {
+        next = pCur->next;
+        if ((pCur->w >= 64) && (pCur->h >= 64)) {
+            pCur->next = List64;
+            List64 = pCur;
+            Num64++;
+        }
+        else if ((pCur->w >= 32) && (pCur->h >= 32)) {
+            pCur->next = List32;
+            List32 = pCur;
+            Num32++;
+        }
+        else if ((pCur->w >= 16) && (pCur->h >= 16)) {
+            pCur->next = List16;
+            List16 = pCur;
+            Num16++;
+        }
+        else if ((pCur->w >= 8) && (pCur->h >= 8)) {
+            pCur->next = List8;
+            List8 = pCur;
+            Num8++;
+        }
+        else {
+            h = pCur->h;
+            if (DoColor && (pCur->w >= ColorW) && (h >= ColorH)) {
+                while (h >= ColorH) {
+                    h -= ColorH;
+                    for (w = 0; w <= (pCur->w - ColorW); w += ColorW) {
+                        ColorList = Enlist(ColorList,
+                                           pCur->x + w, pCur->y + h, ColorW,
+                                           ColorH);
+                        (*NumColor)++;
+                    }
+                }
+            }
+            if (DoMono && (pCur->w >= MonoW) && (h >= MonoH)) {
+                while (h >= MonoH) {
+                    h -= MonoH;
+                    for (w = 0; w <= (pCur->w - MonoW); w += MonoW) {
+                        MonoList = Enlist(MonoList,
+                                          pCur->x + w, pCur->y + h, MonoW,
+                                          MonoH);
+                        (*NumMono)++;
+                    }
+                }
+            }
+            free(pCur);
+        }
+
+        pCur = next;
+    }
+
+    /* Try to extract at least 4 of each type of 8x8 slot that we need */
+
+    if (DoColor) {
+        CacheLinkPtr theOne;
+
+        while (*NumColor < 4) {
+            theOne = NULL;
+            if (Num8) {
+                if ((theOne = ExtractOneThatFits(&List8, ColorW, ColorH)))
+                    Num8--;
+            }
+            if (Num16 && !theOne) {
+                if ((theOne = ExtractOneThatFits(&List16, ColorW, ColorH)))
+                    Num16--;
+            }
+            if (Num32 && !theOne) {
+                if ((theOne = ExtractOneThatFits(&List32, ColorW, ColorH)))
+                    Num32--;
+            }
+            if (Num64 && !theOne) {
+                if ((theOne = ExtractOneThatFits(&List64, ColorW, ColorH)))
+                    Num64--;
+            }
+
+            if (!theOne)
+                break;
+
+            ConvertAllPartialsTo8x8(NumMono, NumColor, theOne,
+                                    &MonoList, &ColorList, infoRec);
+
+            if (DoMono) {
+                while (*NumColor && (*NumMono < 4)) {
+                    ConvertColorToMono(&ColorList, ColorW, ColorH,
+                                       &MonoList, MonoW, MonoH);
+                    (*NumColor)--;
+                    *NumMono += MonosPerColor;
+                }
+            }
+        }
+    }
+
+    if (DoMono) {
+        CacheLinkPtr theOne;
+
+        while (*NumMono < 4) {
+            theOne = NULL;
+            if (Num8) {
+                if ((theOne = ExtractOneThatFits(&List8, MonoW, MonoH)))
+                    Num8--;
+            }
+            if (Num16 && !theOne) {
+                if ((theOne = ExtractOneThatFits(&List16, MonoW, MonoH)))
+                    Num16--;
+            }
+            if (Num32 && !theOne) {
+                if ((theOne = ExtractOneThatFits(&List32, MonoW, MonoH)))
+                    Num32--;
+            }
+            if (Num64 && !theOne) {
+                if ((theOne = ExtractOneThatFits(&List64, MonoW, MonoH)))
+                    Num64--;
+            }
+
+            if (!theOne)
+                break;
+
+            ConvertAllPartialsTo8x8(NumMono, NumColor, theOne,
+                                    &MonoList, &ColorList, infoRec);
+        }
+    }
+
+    /* We save all the tiles from the largest bin that we can get
+       at least 4 of.  If there are too few of a bigger slot, we
+       cut it in fourths to make smaller slots. */
+
+    if (Num64 >= 4) {
+        ListKeepers = List64;
+        List64 = NULL;
+        NumKeepers = Num64;
+        goto GOT_EM;
+    }
+    else if (Num64) {
+        List32 = QuadLinks(List64, List32);
+        Num32 += Num64 * 4;
+        Num64 = 0;
+    }
+
+    if (Num32 >= 4) {
+        ListKeepers = List32;
+        List32 = NULL;
+        NumKeepers = Num32;
+        goto GOT_EM;
+    }
+    else if (Num32) {
+        List16 = QuadLinks(List32, List16);
+        Num16 += Num32 * 4;
+        Num32 = 0;
+    }
+
+    if (Num16 >= 4) {
+        ListKeepers = List16;
+        List16 = NULL;
+        NumKeepers = Num16;
+        goto GOT_EM;
+    }
+    else if (Num16) {
+        List8 = QuadLinks(List16, List8);
+        Num8 += Num16 * 4;
+        Num16 = 0;
+    }
+
+    if (Num8 >= 4) {
+        ListKeepers = List8;
+        List8 = NULL;
+        NumKeepers = Num8;
+        goto GOT_EM;
+    }
+
+ GOT_EM:
+
+    /* Free the ones we aren't using */
+
+    if (List64)
+        ConvertAllPartialsTo8x8(NumMono, NumColor, List64,
+                                &MonoList, &ColorList, infoRec);
+    if (List32)
+        ConvertAllPartialsTo8x8(NumMono, NumColor, List32,
+                                &MonoList, &ColorList, infoRec);
+    if (List16)
+        ConvertAllPartialsTo8x8(NumMono, NumColor, List16,
+                                &MonoList, &ColorList, infoRec);
+    if (List8)
+        ConvertAllPartialsTo8x8(NumMono, NumColor, List8,
+                                &MonoList, &ColorList, infoRec);
+
+    /* Enlarge the slots if we can */
+
+    if (ListKeepers) {
+        CacheLinkPtr pLink = ListKeepers;
+
+        Width = Height = 128;
+
+        while (pLink) {
+            if (pLink->w < Width)
+                Width = pLink->w;
+            if (pLink->h < Height)
+                Height = pLink->h;
+            pLink = pLink->next;
+        }
+    }
+
+    *ListMono = MonoList;
+    *ListColor = ColorList;
+    *maxw = Width;
+    *maxh = Height;
+    *NumPartial = NumKeepers;
+    return ListKeepers;
+}
+
+void
+XAAInitPixmapCache(ScreenPtr pScreen, RegionPtr areas, pointer data)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    XAAInfoRecPtr infoRec = (XAAInfoRecPtr) data;
+    XAAPixmapCachePrivatePtr pCachePriv;
+    BoxPtr pBox = RegionRects(areas);
+    int nBox = RegionNumRects(areas);
+    int Num512, Num256, Num128, NumPartial, NumColor, NumMono;
+    int Target512, Target256;
+    CacheLinkPtr List512, List256, List128, ListPartial, ListColor, ListMono;
+    int x, y, w, h, ntotal, granularity, width, height, i;
+    int MaxPartialWidth, MaxPartialHeight;
+
+    infoRec->MaxCacheableTileWidth = 0;
+    infoRec->MaxCacheableTileHeight = 0;
+    infoRec->MaxCacheableStippleHeight = 0;
+    infoRec->MaxCacheableStippleWidth = 0;
+    infoRec->UsingPixmapCache = FALSE;
+
+    if (!nBox || !pBox || !(infoRec->Flags & PIXMAP_CACHE))
+        return;
+
+    /* Allocate a persistent per-screen init flag to control messages */
+    if (CacheInitIndex < 0)
+        CacheInitIndex = xf86AllocateScrnInfoPrivateIndex();
+
+    /* free the old private data if it exists */
+    if (infoRec->PixmapCachePrivate) {
+        FreePixmapCachePrivate((XAAPixmapCachePrivatePtr) infoRec->
+                               PixmapCachePrivate);
+        infoRec->PixmapCachePrivate = NULL;
+    }
+
+    Num512 = Num256 = Num128 = NumPartial = NumMono = NumColor = 0;
+    List512 = List256 = List128 = ListPartial = ListMono = ListColor = NULL;
+    granularity = infoRec->CachePixelGranularity;
+    if (granularity <= 1)
+        granularity = 0;
+
+    /* go through the boxes and break it into as many pieces as we can fit */
+
+    while (nBox--) {
+        x = pBox->x1;
+        if (granularity) {
+            int tmp = x % granularity;
+
+            if (tmp)
+                x += (granularity - tmp);
+        }
+        width = pBox->x2 - x;
+        if (width <= 0) {
+            pBox++;
+            continue;
+        }
+
+        y = pBox->y1;
+        height = pBox->y2 - y;
+
+        for (h = 0; h <= (height - 512); h += 512) {
+            for (w = 0; w <= (width - 512); w += 512) {
+                List512 = Enlist(List512, x + w, y + h, 512, 512);
+                Num512++;
+            }
+            for (; w <= (width - 256); w += 256) {
+                List256 = Enlist(List256, x + w, y + h, 256, 256);
+                List256 = Enlist(List256, x + w, y + h + 256, 256, 256);
+                Num256 += 2;
+            }
+            for (; w <= (width - 128); w += 128) {
+                List128 = Enlist(List128, x + w, y + h, 128, 128);
+                List128 = Enlist(List128, x + w, y + h + 128, 128, 128);
+                List128 = Enlist(List128, x + w, y + h + 256, 128, 128);
+                List128 = Enlist(List128, x + w, y + h + 384, 128, 128);
+                Num128 += 4;
+            }
+            if (w < width) {
+                int d = width - w;
+
+                ListPartial = Enlist(ListPartial, x + w, y + h, d, 128);
+                ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128);
+                ListPartial = Enlist(ListPartial, x + w, y + h + 256, d, 128);
+                ListPartial = Enlist(ListPartial, x + w, y + h + 384, d, 128);
+                NumPartial += 4;
+            }
+        }
+        for (; h <= (height - 256); h += 256) {
+            for (w = 0; w <= (width - 256); w += 256) {
+                List256 = Enlist(List256, x + w, y + h, 256, 256);
+                Num256++;
+            }
+            for (; w <= (width - 128); w += 128) {
+                List128 = Enlist(List128, x + w, y + h, 128, 128);
+                List128 = Enlist(List128, x + w, y + h + 128, 128, 128);
+                Num128 += 2;
+            }
+            if (w < width) {
+                int d = width - w;
+
+                ListPartial = Enlist(ListPartial, x + w, y + h, d, 128);
+                ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128);
+                NumPartial += 2;
+            }
+        }
+        for (; h <= (height - 128); h += 128) {
+            for (w = 0; w <= (width - 128); w += 128) {
+                List128 = Enlist(List128, x + w, y + h, 128, 128);
+                Num128++;
+            }
+            if (w < width) {
+                ListPartial = Enlist(ListPartial, x + w, y + h, width - w, 128);
+                NumPartial++;
+            }
+        }
+        if (h < height) {
+            int d = height - h;
+
+            for (w = 0; w <= (width - 128); w += 128) {
+                ListPartial = Enlist(ListPartial, x + w, y + h, 128, d);
+                NumPartial++;
+            }
+            if (w < width) {
+                ListPartial = Enlist(ListPartial, x + w, y + h, width - w, d);
+                NumPartial++;
+            }
+        }
+        pBox++;
+    }
+
+/* 
+   by this point we've carved the space into as many 512x512, 256x256
+	and 128x128 blocks as we could fit.  We will then break larger
+	blocks into smaller ones if we need to.  The rules are as follows:
+
+     512x512 -
+	1) Don't take up more than half the memory.
+	2) Don't bother if you can't get at least four.
+	3) Don't make more than MAX_512.
+	4) Don't have any of there are no 256x256s.
+
+     256x256 -
+	1) Don't take up more than a quarter of the memory enless there
+		aren't any 512x512s.  Then we can take up to half.
+	2) Don't bother if you can't get at least four.
+	3) Don't make more than MAX_256.
+
+     128x128 -
+	1) Don't make more than MAX_128.
+
+     We don't bother with the partial blocks unless we can use them
+     for 8x8 pattern fills or we are short on larger blocks.
+
+*/
+
+    ntotal = Num128 + (Num256 << 2) + (Num512 << 4);
+
+    Target512 = ntotal >> 5;
+    if (Target512 < 4)
+        Target512 = 0;
+    if (!Target512)
+        Target256 = ntotal >> 3;
+    else
+        Target256 = ntotal >> 4;
+    if (Target256 < 4)
+        Target256 = 0;
+
+    if (Num512 && Num256 < 4) {
+        while (Num512 && Num256 < Target256) {
+            SubdivideList(&List512, &List256);
+            Num256 += 4;
+            Num512--;
+        }
+    }
+
+    if (!Num512) {              /* no room */
+    }
+    else if ((Num512 < 4) || (!Target512)) {
+        while (Num512) {
+            SubdivideList(&List512, &List256);
+            Num256 += 4;
+            Num512--;
+        }
+    }
+    else if ((Num512 > MAX_512) || (Num512 > Target512)) {
+        while (Num512 > MAX_512) {
+            SubdivideList(&List512, &List256);
+            Num256 += 4;
+            Num512--;
+        }
+        while (Num512 > Target512) {
+            if (Num256 < MAX_256) {
+                SubdivideList(&List512, &List256);
+                Num256 += 4;
+                Num512--;
+            }
+            else
+                break;
+        }
+    }
+
+    if (!Num256) {              /* no room */
+    }
+    else if ((Num256 < 4) || (!Target256)) {
+        while (Num256) {
+            SubdivideList(&List256, &List128);
+            Num128 += 4;
+            Num256--;
+        }
+    }
+    else if ((Num256 > MAX_256) || (Num256 > Target256)) {
+        while (Num256 > MAX_256) {
+            SubdivideList(&List256, &List128);
+            Num128 += 4;
+            Num256--;
+        }
+        while (Num256 > Target256) {
+            if (Num128 < MAX_128) {
+                SubdivideList(&List256, &List128);
+                Num128 += 4;
+                Num256--;
+            }
+            else
+                break;
+        }
+    }
+
+    if (Num128 && ((Num128 < 4) || (Num128 > MAX_128))) {
+        CacheLinkPtr next;
+        int max = (Num128 > MAX_128) ? MAX_128 : 0;
+
+        /*
+         * Note: next is set in this way to work around a code generation
+         * bug in gcc 2.7.2.3.
+         */
+        next = List128->next;
+        while (Num128 > max) {
+            List128->next = ListPartial;
+            ListPartial = List128;
+            if ((List128 = next))
+                next = List128->next;
+            NumPartial++;
+            Num128--;
+        }
+    }
+
+    MaxPartialHeight = MaxPartialWidth = 0;
+
+    /* at this point we have as many 512x512 and 256x256 slots as we
+       want but may have an excess of 128x128 slots.  We still need
+       to find out if we need 8x8 slots.  We take these from the
+       partials if we have them.  Otherwise, we break some 128x128's */
+
+    if (!(infoRec->PixmapCacheFlags & (CACHE_MONO_8x8 | CACHE_COLOR_8x8))) {
+        if (NumPartial) {
+            if (Num128) {       /* don't bother with partials */
+                FreeList(ListPartial);
+                NumPartial = 0;
+                ListPartial = NULL;
+            }
+            else {
+                /* We have no big slots.  Weed out the unusable partials */
+                ListPartial = ThinOutPartials(ListPartial, &NumPartial,
+                                              &MaxPartialWidth,
+                                              &MaxPartialHeight);
+            }
+        }
+    }
+    else {
+        int MonosPerColor = 1;
+        int ColorH = infoRec->CacheHeightColor8x8Pattern;
+        int ColorW = infoRec->CacheWidthColor8x8Pattern;
+        int MonoH = infoRec->CacheHeightMono8x8Pattern;
+        int MonoW = infoRec->CacheWidthMono8x8Pattern;
+        Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8);
+        Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8);
+
+        if (DoColor)
+            infoRec->CanDoColor8x8 = FALSE;
+        if (DoMono)
+            infoRec->CanDoMono8x8 = FALSE;
+
+        if (DoColor && DoMono) {
+            /* we assume color patterns take more space than color ones */
+            if (MonoH > ColorH)
+                ColorH = MonoH;
+            if (MonoW > ColorW)
+                ColorW = MonoW;
+            MonosPerColor = (ColorH / MonoH) * (ColorW / MonoW);
+        }
+
+        if (Num128) {
+            if (NumPartial) {   /* use all for 8x8 slots */
+                ConvertAllPartialsTo8x8(&NumMono, &NumColor,
+                                        ListPartial, &ListMono, &ListColor,
+                                        infoRec);
+                NumPartial = 0;
+                ListPartial = NULL;
+            }
+
+            /* Get some 8x8 slots from the 128 slots */
+            while ((Num128 > 4) &&
+                   ((NumMono < MAX_MONO) && (NumColor < MAX_COLOR))) {
+                CacheLinkPtr tmp = NULL;
+
+                tmp = Enlist(tmp, List128->x, List128->y,
+                             List128->w, List128->h);
+                List128 = Delist(List128);
+                Num128--;
+
+                ConvertAllPartialsTo8x8(&NumMono, &NumColor,
+                                        tmp, &ListMono, &ListColor, infoRec);
+            }
+        }
+        else if (NumPartial) {
+            /* We have share partials between 8x8 slots and tiles. */
+            ListPartial = ConvertSomePartialsTo8x8(&NumMono, &NumColor,
+                                                   &NumPartial, ListPartial,
+                                                   &ListMono, &ListColor,
+                                                   &MaxPartialWidth,
+                                                   &MaxPartialHeight, infoRec);
+        }
+
+        if (DoMono && DoColor) {
+            if (NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) {
+                int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0;
+
+                while (NumColor > max) {
+                    ConvertColorToMono(&ListColor, ColorW, ColorH,
+                                       &ListMono, MonoW, MonoH);
+                    NumColor--;
+                    NumMono += MonosPerColor;
+                }
+            }
+
+            /* favor Mono slots over Color ones */
+            while ((NumColor > 4) && (NumMono < MAX_MONO)) {
+                ConvertColorToMono(&ListColor, ColorW, ColorH,
+                                   &ListMono, MonoW, MonoH);
+                NumColor--;
+                NumMono += MonosPerColor;
+            }
+        }
+
+        if (NumMono && ((NumMono > MAX_MONO) || (NumMono < 4))) {
+            int max = (NumMono > MAX_MONO) ? MAX_MONO : 0;
+
+            while (NumMono > max) {
+                ListMono = Delist(ListMono);
+                NumMono--;
+            }
+        }
+        if (NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) {
+            int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0;
+
+            while (NumColor > max) {
+                ListColor = Delist(ListColor);
+                NumColor--;
+            }
+        }
+    }
+
+    pCachePriv = calloc(1, sizeof(XAAPixmapCachePrivate));
+    if (!pCachePriv) {
+        if (Num512)
+            FreeList(List512);
+        if (Num256)
+            FreeList(List256);
+        if (Num128)
+            FreeList(List128);
+        if (NumPartial)
+            FreeList(ListPartial);
+        if (NumColor)
+            FreeList(ListColor);
+        if (NumMono)
+            FreeList(ListMono);
+        return;
+    }
+
+    infoRec->PixmapCachePrivate = (char *) pCachePriv;
+
+    if (Num512) {
+        pCachePriv->Info512 = calloc(Num512, sizeof(XAACacheInfoRec));
+        if (!pCachePriv->Info512)
+            Num512 = 0;
+        if (Num512)
+            TransferList(List512, pCachePriv->Info512, Num512);
+        FreeList(List512);
+        pCachePriv->Num512x512 = Num512;
+    }
+    if (Num256) {
+        pCachePriv->Info256 = calloc(Num256, sizeof(XAACacheInfoRec));
+        if (!pCachePriv->Info256)
+            Num256 = 0;
+        if (Num256)
+            TransferList(List256, pCachePriv->Info256, Num256);
+        FreeList(List256);
+        pCachePriv->Num256x256 = Num256;
+    }
+    if (Num128) {
+        pCachePriv->Info128 = calloc(Num128, sizeof(XAACacheInfoRec));
+        if (!pCachePriv->Info128)
+            Num128 = 0;
+        if (Num128)
+            TransferList(List128, pCachePriv->Info128, Num128);
+        FreeList(List128);
+        pCachePriv->Num128x128 = Num128;
+    }
+
+    if (NumPartial) {
+        pCachePriv->InfoPartial = calloc(NumPartial, sizeof(XAACacheInfoRec));
+        if (!pCachePriv->InfoPartial)
+            NumPartial = 0;
+        if (NumPartial)
+            TransferList(ListPartial, pCachePriv->InfoPartial, NumPartial);
+        FreeList(ListPartial);
+        pCachePriv->NumPartial = NumPartial;
+    }
+
+    if (NumColor) {
+        pCachePriv->InfoColor = calloc(NumColor, sizeof(XAACacheInfoRec));
+        if (!pCachePriv->InfoColor)
+            NumColor = 0;
+        if (NumColor)
+            TransferList(ListColor, pCachePriv->InfoColor, NumColor);
+        FreeList(ListColor);
+        pCachePriv->NumColor = NumColor;
+    }
+
+    if (NumMono) {
+        pCachePriv->InfoMono = calloc(NumMono, sizeof(XAACacheInfoRec));
+        if (!pCachePriv->InfoMono)
+            NumMono = 0;
+        if (NumMono)
+            TransferList(ListMono, pCachePriv->InfoMono, NumMono);
+        FreeList(ListMono);
+        pCachePriv->NumMono = NumMono;
+    }
+
+    if (NumPartial) {
+        infoRec->MaxCacheableTileWidth = MaxPartialWidth;
+        infoRec->MaxCacheableTileHeight = MaxPartialHeight;
+    }
+    if (Num128)
+        infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 128;
+    if (Num256)
+        infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 256;
+    if (Num512)
+        infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 512;
+
+    infoRec->MaxCacheableStippleHeight = infoRec->MaxCacheableTileHeight;
+    infoRec->MaxCacheableStippleWidth =
+        infoRec->MaxCacheableTileWidth * pScrn->bitsPerPixel;
+    if (infoRec->ScreenToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP)
+        infoRec->MaxCacheableStippleWidth /= 3;
+
+    if (NumMono) {
+        if (!(infoRec->Mono8x8PatternFillFlags &
+              (HARDWARE_PATTERN_PROGRAMMED_ORIGIN |
+               HARDWARE_PATTERN_PROGRAMMED_BITS))) {
+            int numPerLine =
+                infoRec->CacheWidthMono8x8Pattern / infoRec->MonoPatternPitch;
+
+            for (i = 0; i < 64; i++) {
+                pCachePriv->MonoOffsets[i].y = i / numPerLine;
+                pCachePriv->MonoOffsets[i].x = (i % numPerLine) *
+                    infoRec->MonoPatternPitch;
+            }
+        }
+        infoRec->CanDoMono8x8 = TRUE;
+    }
+    if (NumColor) {
+        if (!(infoRec->Color8x8PatternFillFlags &
+              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
+
+            for (i = 0; i < 64; i++) {
+                pCachePriv->ColorOffsets[i].y = i & 0x07;
+                pCachePriv->ColorOffsets[i].x = i & ~0x07;
+            }
+        }
+        infoRec->CanDoColor8x8 = TRUE;
+    }
+
+    if (!CACHEINIT(pScrn)) {
+        xf86ErrorF("\tSetting up tile and stipple cache:\n");
+        if (NumPartial)
+            xf86ErrorF("\t\t%i %ix%i slots\n",
+                       NumPartial, MaxPartialWidth, MaxPartialHeight);
+        if (Num128)
+            xf86ErrorF("\t\t%i 128x128 slots\n", Num128);
+        if (Num256)
+            xf86ErrorF("\t\t%i 256x256 slots\n", Num256);
+        if (Num512)
+            xf86ErrorF("\t\t%i 512x512 slots\n", Num512);
+        if (NumColor)
+            xf86ErrorF("\t\t%i 8x8 color pattern slots\n", NumColor);
+        if (NumMono)
+            xf86ErrorF("\t\t%i 8x8 color expansion slots\n", NumMono);
+    }
+
+    if (!(NumPartial | Num128 | Num256 | Num512 | NumColor | NumMono)) {
+        if (!CACHEINIT(pScrn))
+            xf86ErrorF("\t\tNot enough video memory for pixmap cache\n");
+    }
+    else
+        infoRec->UsingPixmapCache = TRUE;
+
+    CACHEINIT(pScrn) = 1;
+}
+
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+static CARD32 StippleMasks[4] = {
+    0x80808080,
+    0xC0C0C0C0,
+    0x00000000,
+    0xF0F0F0F0
+};
+#else
+static CARD32 StippleMasks[4] = {
+    0x01010101,
+    0x03030303,
+    0x00000000,
+    0x0F0F0F0F
+};
+#endif
+
+Bool
+XAACheckStippleReducibility(PixmapPtr pPixmap)
+{
+    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_DRAWABLE(&pPixmap->drawable);
+    CARD32 *IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
+    int w = pPixmap->drawable.width;
+    int h = pPixmap->drawable.height;
+    int i;
+    CARD32 bits[8];
+    CARD32 mask = SHIFT_R(0xFFFFFFFF, 24);
+
+    pPriv->flags |= REDUCIBILITY_CHECKED | REDUCIBLE_TO_2_COLOR;
+    pPriv->flags &= ~REDUCIBLE_TO_8x8;
+
+    if ((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1)))
+        return FALSE;
+
+    i = (h > 8) ? 8 : h;
+
+    switch (w) {
+    case 32:
+        while (i--) {
+            bits[i] = IntPtr[i] & mask;
+            if ((bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 8)), 8)) ||
+                (bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 16)), 16)) ||
+                (bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 24)), 24)))
+                return FALSE;
+        }
+        break;
+    case 16:
+        while (i--) {
+            bits[i] = IntPtr[i] & mask;
+            if (bits[i] != ((IntPtr[i] & SHIFT_R(SHIFT_L(mask, 8), 8))))
+                return FALSE;
+        }
+        break;
+    default:
+        while (i--)
+            bits[i] = IntPtr[i] & mask;
+        break;
+    }
+
+    switch (h) {
+    case 32:
+        if ((IntPtr[8] != IntPtr[16]) || (IntPtr[9] != IntPtr[17]) ||
+            (IntPtr[10] != IntPtr[18]) || (IntPtr[11] != IntPtr[19]) ||
+            (IntPtr[12] != IntPtr[20]) || (IntPtr[13] != IntPtr[21]) ||
+            (IntPtr[14] != IntPtr[22]) || (IntPtr[15] != IntPtr[23]) ||
+            (IntPtr[16] != IntPtr[24]) || (IntPtr[17] != IntPtr[25]) ||
+            (IntPtr[18] != IntPtr[26]) || (IntPtr[19] != IntPtr[27]) ||
+            (IntPtr[20] != IntPtr[28]) || (IntPtr[21] != IntPtr[29]) ||
+            (IntPtr[22] != IntPtr[30]) || (IntPtr[23] != IntPtr[31]))
+            return FALSE;
+        /* fall through */
+    case 16:
+        if ((IntPtr[0] != IntPtr[8]) || (IntPtr[1] != IntPtr[9]) ||
+            (IntPtr[2] != IntPtr[10]) || (IntPtr[3] != IntPtr[11]) ||
+            (IntPtr[4] != IntPtr[12]) || (IntPtr[5] != IntPtr[13]) ||
+            (IntPtr[6] != IntPtr[14]) || (IntPtr[7] != IntPtr[15]))
+            return FALSE;
+    case 8:
+        break;
+    case 1:
+        bits[1] = bits[0];
+    case 2:
+        bits[2] = bits[0];
+        bits[3] = bits[1];
+    case 4:
+        bits[4] = bits[0];
+        bits[5] = bits[1];
+        bits[6] = bits[2];
+        bits[7] = bits[3];
+        break;
+    }
+
+    pPriv->flags |= REDUCIBLE_TO_8x8;
+
+    pPriv->pattern0 =
+        bits[0] | SHIFT_L(bits[1], 8) | SHIFT_L(bits[2], 16) | SHIFT_L(bits[3],
+                                                                       24);
+    pPriv->pattern1 =
+        bits[4] | SHIFT_L(bits[5], 8) | SHIFT_L(bits[6], 16) | SHIFT_L(bits[7],
+                                                                       24);
+
+    if (w < 8) {
+        pPriv->pattern0 &= StippleMasks[w - 1];
+        pPriv->pattern1 &= StippleMasks[w - 1];
+
+        switch (w) {
+        case 1:
+            pPriv->pattern0 |= SHIFT_L(pPriv->pattern0, 1);
+            pPriv->pattern1 |= SHIFT_L(pPriv->pattern1, 1);
+        case 2:
+            pPriv->pattern0 |= SHIFT_L(pPriv->pattern0, 2);
+            pPriv->pattern1 |= SHIFT_L(pPriv->pattern1, 2);
+        case 4:
+            pPriv->pattern0 |= SHIFT_L(pPriv->pattern0, 4);
+            pPriv->pattern1 |= SHIFT_L(pPriv->pattern1, 4);
+        }
+    }
+
+    if (infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {
+        pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0);
+        pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1);
+    }
+
+    return TRUE;
+}
+
+Bool
+XAACheckTileReducibility(PixmapPtr pPixmap, Bool checkMono)
+{
+    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
+    CARD32 *IntPtr;
+    int w = pPixmap->drawable.width;
+    int h = pPixmap->drawable.height;
+    int pitch = pPixmap->devKind >> 2;
+    int dwords, i, j;
+
+    pPriv->flags |= REDUCIBILITY_CHECKED;
+    pPriv->flags &= ~(REDUCIBILITY_CHECKED | REDUCIBLE_TO_2_COLOR);
+
+    if ((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1)))
+        return FALSE;
+
+    dwords = ((w * pPixmap->drawable.bitsPerPixel) + 31) >> 5;
+    i = (h > 8) ? 8 : h;
+
+    if (w > 8) {
+        IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
+        switch (pPixmap->drawable.bitsPerPixel) {
+        case 8:
+            while (i--) {
+                for (j = 2; j < dwords; j++)
+                    if (IntPtr[j] != IntPtr[j & 0x01])
+                        return FALSE;
+                IntPtr += pitch;
+            }
+            break;
+        case 16:
+            while (i--) {
+                for (j = 4; j < dwords; j++)
+                    if (IntPtr[j] != IntPtr[j & 0x03])
+                        return FALSE;
+                IntPtr += pitch;
+            }
+            break;
+        case 24:
+            while (i--) {
+                for (j = 6; j < dwords; j++)
+                    if (IntPtr[j] != IntPtr[j % 6])
+                        return FALSE;
+                IntPtr += pitch;
+            }
+            break;
+        case 32:
+            while (i--) {
+                for (j = 8; j < dwords; j++)
+                    if (IntPtr[j] != IntPtr[j & 0x07])
+                        return FALSE;
+                IntPtr += pitch;
+            }
+            break;
+        default:
+            return FALSE;
+        }
+
+    }
+
+    if (h == 32) {
+        CARD32 *IntPtr2, *IntPtr3, *IntPtr4;
+
+        i = 8;
+        IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
+        IntPtr2 = IntPtr + (pitch << 3);
+        IntPtr3 = IntPtr2 + (pitch << 3);
+        IntPtr4 = IntPtr3 + (pitch << 3);
+        while (i--) {
+            for (j = 0; j < dwords; j++)
+                if ((IntPtr[j] != IntPtr2[j]) || (IntPtr[j] != IntPtr3[j]) ||
+                    (IntPtr[j] != IntPtr4[j]))
+                    return FALSE;
+            IntPtr += pitch;
+            IntPtr2 += pitch;
+            IntPtr3 += pitch;
+            IntPtr4 += pitch;
+        }
+    }
+    else if (h == 16) {
+        CARD32 *IntPtr2;
+
+        i = 8;
+        IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
+        IntPtr2 = IntPtr + (pitch << 3);
+        while (i--) {
+            for (j = 0; j < dwords; j++)
+                if (IntPtr[j] != IntPtr2[j])
+                    return FALSE;
+            IntPtr += pitch;
+            IntPtr2 += pitch;
+        }
+    }
+
+    pPriv->flags |= REDUCIBLE_TO_8x8;
+
+    if (checkMono) {
+        XAAInfoRecPtr infoRec =
+            GET_XAAINFORECPTR_FROM_DRAWABLE(&pPixmap->drawable);
+        unsigned char bits[8];
+        int fg, bg = -1, x, y;
+
+        i = (h > 8) ? 8 : h;
+        j = (w > 8) ? 8 : w;
+
+        if (pPixmap->drawable.bitsPerPixel == 8) {
+            unsigned char *srcp = pPixmap->devPrivate.ptr;
+
+            fg = srcp[0];
+            pitch = pPixmap->devKind;
+            for (y = 0; y < i; y++) {
+                bits[y] = 0;
+                for (x = 0; x < j; x++) {
+                    if (srcp[x] != fg) {
+                        if (bg == -1)
+                            bg = srcp[x];
+                        else if (bg != srcp[x])
+                            return TRUE;
+                    }
+                    else
+                        bits[y] |= 1 << x;
+                }
+                srcp += pitch;
+            }
+        }
+        else if (pPixmap->drawable.bitsPerPixel == 16) {
+            unsigned short *srcp = (unsigned short *) pPixmap->devPrivate.ptr;
+
+            fg = srcp[0];
+            pitch = pPixmap->devKind >> 1;
+            for (y = 0; y < i; y++) {
+                bits[y] = 0;
+                for (x = 0; x < j; x++) {
+                    if (srcp[x] != fg) {
+                        if (bg == -1)
+                            bg = srcp[x];
+                        else if (bg != srcp[x])
+                            return TRUE;
+                    }
+                    else
+                        bits[y] |= 1 << x;
+                }
+                srcp += pitch;
+            }
+        }
+        else if (pPixmap->drawable.bitsPerPixel == 24) {
+            CARD32 val;
+            unsigned char *srcp = pPixmap->devPrivate.ptr;
+
+            fg = *((CARD32 *) srcp) & 0x00FFFFFF;
+            pitch = pPixmap->devKind;
+            j *= 3;
+            for (y = 0; y < i; y++) {
+                bits[y] = 0;
+                for (x = 0; x < j; x += 3) {
+                    val = *((CARD32 *) (srcp + x)) & 0x00FFFFFF;
+                    if (val != fg) {
+                        if (bg == -1)
+                            bg = val;
+                        else if (bg != val)
+                            return TRUE;
+                    }
+                    else
+                        bits[y] |= 1 << (x / 3);
+                }
+                srcp += pitch;
+            }
+        }
+        else if (pPixmap->drawable.bitsPerPixel == 32) {
+            IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
+            fg = IntPtr[0];
+            for (y = 0; y < i; y++) {
+                bits[y] = 0;
+                for (x = 0; x < j; x++) {
+                    if (IntPtr[x] != fg) {
+                        if (bg == -1)
+                            bg = IntPtr[x];
+                        else if (bg != IntPtr[x])
+                            return TRUE;
+                    }
+                    else
+                        bits[y] |= 1 << x;
+                }
+                IntPtr += pitch;
+            }
+        }
+        else
+            return TRUE;
+
+        pPriv->fg = fg;
+        if (bg == -1)
+            pPriv->bg = fg;
+        else
+            pPriv->bg = bg;
+
+        if (h < 8) {
+            switch (h) {
+            case 1:
+                bits[1] = bits[0];
+            case 2:
+                bits[2] = bits[0];
+                bits[3] = bits[1];
+            case 4:
+                bits[4] = bits[0];
+                bits[5] = bits[1];
+                bits[6] = bits[2];
+                bits[7] = bits[3];
+                break;
+            }
+        }
+
+        pPriv->pattern0 =
+            bits[0] | (bits[1] << 8) | (bits[2] << 16) | (bits[3] << 24);
+        pPriv->pattern1 =
+            bits[4] | (bits[5] << 8) | (bits[6] << 16) | (bits[7] << 24);
+
+        if (w < 8) {
+            switch (w) {
+            case 1:
+                pPriv->pattern0 |= (pPriv->pattern0 << 1);
+                pPriv->pattern1 |= (pPriv->pattern1 << 1);
+            case 2:
+                pPriv->pattern0 |= (pPriv->pattern0 << 2);
+                pPriv->pattern1 |= (pPriv->pattern1 << 2);
+            case 4:
+                pPriv->pattern0 |= (pPriv->pattern0 << 4);
+                pPriv->pattern1 |= (pPriv->pattern1 << 4);
+            }
+        }
+        pPriv->flags |= REDUCIBLE_TO_2_COLOR;
+
+        if (infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {
+            pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0);
+            pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1);
+        }
+
+    }
+
+    return TRUE;
+}
+
+void
+XAATileCache(ScrnInfoPtr pScrn, XAACacheInfoPtr pCache, int w, int h)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+
+    (*infoRec->SetupForScreenToScreenCopy) (pScrn, 1, 1, GXcopy, ~0, -1);
+
+    while ((w << 1) <= pCache->w) {
+        (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y,
+                                                  pCache->x + w, pCache->y, w,
+                                                  h);
+        w <<= 1;
+    }
+    if (w != pCache->w) {
+        (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y,
+                                                  pCache->x + w, pCache->y,
+                                                  pCache->w - w, h);
+        w = pCache->w;
+    }
+
+    while ((h << 1) <= pCache->h) {
+        (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y,
+                                                  pCache->x, pCache->y + h, w,
+                                                  h);
+        h <<= 1;
+    }
+    if (h != pCache->h) {
+        (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y,
+                                                  pCache->x, pCache->y + h, w,
+                                                  pCache->h - h);
+    }
+    SET_SYNC_FLAG(infoRec);
+}
+
+XAACacheInfoPtr
+XAACacheTile(ScrnInfoPtr pScrn, PixmapPtr pPix)
+{
+    int w = pPix->drawable.width;
+    int h = pPix->drawable.height;
+    int size = max(w, h);
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    XAAPixmapCachePrivatePtr pCachePriv =
+        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
+    XAACacheInfoPtr pCache, cacheRoot = NULL;
+    int i, max = 0;
+    int *current;
+
+    if (size <= 128) {
+        if (pCachePriv->Info128) {
+            cacheRoot = pCachePriv->Info128;
+            max = pCachePriv->Num128x128;
+            current = &pCachePriv->Current128;
+        }
+        else {
+            cacheRoot = pCachePriv->InfoPartial;
+            max = pCachePriv->NumPartial;
+            current = &pCachePriv->CurrentPartial;
+        }
+    }
+    else if (size <= 256) {
+        cacheRoot = pCachePriv->Info256;
+        max = pCachePriv->Num256x256;
+        current = &pCachePriv->Current256;
+    }
+    else if (size <= 512) {
+        cacheRoot = pCachePriv->Info512;
+        max = pCachePriv->Num512x512;
+        current = &pCachePriv->Current512;
+    }
+    else {                      /* something's wrong */
+        ErrorF("Something's wrong in XAACacheTile()\n");
+        return pCachePriv->Info128;
+    }
+
+    pCache = cacheRoot;
+
+    /* lets look for it */
+    for (i = 0; i < max; i++, pCache++) {
+        if (pCache->serialNumber == pPix->drawable.serialNumber) {
+            pCache->trans_color = -1;
+            return pCache;
+        }
+    }
+
+    pCache = &cacheRoot[(*current)++];
+    if (*current >= max)
+        *current = 0;
+
+    pCache->serialNumber = pPix->drawable.serialNumber;
+    pCache->trans_color = pCache->bg = pCache->fg = -1;
+    pCache->orig_w = w;
+    pCache->orig_h = h;
+    (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y, w, h,
+                                    pPix->devPrivate.ptr, pPix->devKind,
+                                    pPix->drawable.bitsPerPixel,
+                                    pPix->drawable.depth);
+    if (!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) &&
+        ((w != pCache->w) || (h != pCache->h)))
+        XAATileCache(pScrn, pCache, w, h);
+
+    return pCache;
+}
+
+XAACacheInfoPtr
+XAACacheMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix)
+{
+    int w = pPix->drawable.width;
+    int h = pPix->drawable.height;
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    XAAPixmapCachePrivatePtr pCachePriv =
+        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
+    XAACacheInfoPtr pCache, cacheRoot = NULL;
+    int i, max = 0, funcNo, pad, dwords, bpp = pScrn->bitsPerPixel;
+    int *current;
+    StippleScanlineProcPtr StippleFunc;
+    unsigned char *data, *srcPtr, *dstPtr;
+
+    if ((h <= 128) && (w <= 128 * bpp)) {
+        if (pCachePriv->Info128) {
+            cacheRoot = pCachePriv->Info128;
+            max = pCachePriv->Num128x128;
+            current = &pCachePriv->Current128;
+        }
+        else {
+            cacheRoot = pCachePriv->InfoPartial;
+            max = pCachePriv->NumPartial;
+            current = &pCachePriv->CurrentPartial;
+        }
+    }
+    else if ((h <= 256) && (w <= 256 * bpp)) {
+        cacheRoot = pCachePriv->Info256;
+        max = pCachePriv->Num256x256;
+        current = &pCachePriv->Current256;
+    }
+    else if ((h <= 512) && (w <= 526 * bpp)) {
+        cacheRoot = pCachePriv->Info512;
+        max = pCachePriv->Num512x512;
+        current = &pCachePriv->Current512;
+    }
+    else {                      /* something's wrong */
+        ErrorF("Something's wrong in XAACacheMonoStipple()\n");
+        return pCachePriv->Info128;
+    }
+
+    pCache = cacheRoot;
+
+    /* lets look for it */
+    for (i = 0; i < max; i++, pCache++) {
+        if ((pCache->serialNumber == pPix->drawable.serialNumber) &&
+            (pCache->fg == -1) && (pCache->bg == -1)) {
+            pCache->trans_color = -1;
+            return pCache;
+        }
+    }
+
+    pCache = &cacheRoot[(*current)++];
+    if (*current >= max)
+        *current = 0;
+
+    pCache->serialNumber = pPix->drawable.serialNumber;
+    pCache->trans_color = pCache->bg = pCache->fg = -1;
+    pCache->orig_w = w;
+    pCache->orig_h = h;
+
+    if (w <= 32) {
+        if (w & (w - 1))
+            funcNo = 1;
+        else
+            funcNo = 0;
+    }
+    else
+        funcNo = 2;
+
+    pad = BitmapBytePad(pCache->w * bpp);
+    dwords = bytes_to_int32(pad);
+    dstPtr = data = (unsigned char *) malloc(pad * pCache->h);
+    srcPtr = (unsigned char *) pPix->devPrivate.ptr;
+
+    if (infoRec->
+        ScreenToScreenColorExpandFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST)
+        StippleFunc = XAAStippleScanlineFuncMSBFirst[funcNo];
+    else
+        StippleFunc = XAAStippleScanlineFuncLSBFirst[funcNo];
+
+    /* don't bother generating more than we'll ever use */
+    max = ((pScrn->displayWidth + w - 1) + 31) >> 5;
+    if (dwords > max)
+        dwords = max;
+
+    for (i = 0; i < h; i++) {
+        (*StippleFunc) ((CARD32 *) dstPtr, (CARD32 *) srcPtr, 0, w, dwords);
+        srcPtr += pPix->devKind;
+        dstPtr += pad;
+    }
+
+    while ((h << 1) <= pCache->h) {
+        memcpy(data + (pad * h), data, pad * h);
+        h <<= 1;
+    }
+
+    if (h < pCache->h)
+        memcpy(data + (pad * h), data, pad * (pCache->h - h));
+
+    (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y, pCache->w,
+                                    pCache->h, data, pad, bpp, pScrn->depth);
+
+    free(data);
+
+    return pCache;
+}
+
+XAACacheInfoPtr
+XAACachePlanarMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix)
+{
+    int w = pPix->drawable.width;
+    int h = pPix->drawable.height;
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    XAAPixmapCachePrivatePtr pCachePriv =
+        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
+    XAACacheInfoPtr pCache, cacheRoot = NULL;
+    int i, max = 0;
+    int *current;
+
+    if ((h <= 128) && (w <= 128)) {
+        if (pCachePriv->Info128) {
+            cacheRoot = pCachePriv->Info128;
+            max = pCachePriv->Num128x128;
+            current = &pCachePriv->Current128;
+        }
+        else {
+            cacheRoot = pCachePriv->InfoPartial;
+            max = pCachePriv->NumPartial;
+            current = &pCachePriv->CurrentPartial;
+        }
+    }
+    else if ((h <= 256) && (w <= 256)) {
+        cacheRoot = pCachePriv->Info256;
+        max = pCachePriv->Num256x256;
+        current = &pCachePriv->Current256;
+    }
+    else if ((h <= 512) && (w <= 526)) {
+        cacheRoot = pCachePriv->Info512;
+        max = pCachePriv->Num512x512;
+        current = &pCachePriv->Current512;
+    }
+    else {                      /* something's wrong */
+        ErrorF("Something's wrong in XAACachePlanarMonoStipple()\n");
+        return pCachePriv->Info128;
+    }
+
+    pCache = cacheRoot;
+
+    /* lets look for it */
+    for (i = 0; i < max; i++, pCache++) {
+        if ((pCache->serialNumber == pPix->drawable.serialNumber) &&
+            (pCache->fg == -1) && (pCache->bg == -1)) {
+            pCache->trans_color = -1;
+            return pCache;
+        }
+    }
+
+    pCache = &cacheRoot[(*current)++];
+    if (*current >= max)
+        *current = 0;
+
+    pCache->serialNumber = pPix->drawable.serialNumber;
+    pCache->trans_color = pCache->bg = pCache->fg = -1;
+    pCache->orig_w = w;
+    pCache->orig_h = h;
+
+    /* Plane 0 holds the stipple. Plane 1 holds the inverted stipple */
+    (*infoRec->WriteBitmapToCache) (pScrn, pCache->x, pCache->y,
+                                    pPix->drawable.width, pPix->drawable.height,
+                                    pPix->devPrivate.ptr, pPix->devKind, 1, 2);
+    if (!(infoRec->PixmapCacheFlags & DO_NOT_TILE_MONO_DATA) &&
+        ((w != pCache->w) || (h != pCache->h)))
+        XAATileCache(pScrn, pCache, w, h);
+
+    return pCache;
+}
+
+XAACachePlanarMonoStippleProc
+XAAGetCachePlanarMonoStipple(void)
+{
+    return XAACachePlanarMonoStipple;
+}
+
+XAACacheInfoPtr
+XAACacheStipple(ScrnInfoPtr pScrn, PixmapPtr pPix, int fg, int bg)
+{
+    int w = pPix->drawable.width;
+    int h = pPix->drawable.height;
+    int size = max(w, h);
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    XAAPixmapCachePrivatePtr pCachePriv =
+        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
+    XAACacheInfoPtr pCache, cacheRoot = NULL;
+    int i, max = 0;
+    int *current;
+
+    if (size <= 128) {
+        if (pCachePriv->Info128) {
+            cacheRoot = pCachePriv->Info128;
+            max = pCachePriv->Num128x128;
+            current = &pCachePriv->Current128;
+        }
+        else {
+            cacheRoot = pCachePriv->InfoPartial;
+            max = pCachePriv->NumPartial;
+            current = &pCachePriv->CurrentPartial;
+        }
+    }
+    else if (size <= 256) {
+        cacheRoot = pCachePriv->Info256;
+        max = pCachePriv->Num256x256;
+        current = &pCachePriv->Current256;
+    }
+    else if (size <= 512) {
+        cacheRoot = pCachePriv->Info512;
+        max = pCachePriv->Num512x512;
+        current = &pCachePriv->Current512;
+    }
+    else {                      /* something's wrong */
+        ErrorF("Something's wrong in XAACacheStipple()\n");
+        return pCachePriv->Info128;
+    }
+
+    pCache = cacheRoot;
+    /* lets look for it */
+    if (bg == -1)
+        for (i = 0; i < max; i++, pCache++) {
+            if ((pCache->serialNumber == pPix->drawable.serialNumber) &&
+                (fg == pCache->fg) && (pCache->fg != pCache->bg)) {
+                pCache->trans_color = pCache->bg;
+                return pCache;
+            }
+        }
+    else
+        for (i = 0; i < max; i++, pCache++) {
+            if ((pCache->serialNumber == pPix->drawable.serialNumber) &&
+                (fg == pCache->fg) && (bg == pCache->bg)) {
+                pCache->trans_color = -1;
+                return pCache;
+            }
+        }
+
+    pCache = &cacheRoot[(*current)++];
+    if (*current >= max)
+        *current = 0;
+
+    pCache->serialNumber = pPix->drawable.serialNumber;
+    pCache->fg = fg;
+    if (bg == -1)
+        pCache->trans_color = bg = fg ^ 1;
+    else
+        pCache->trans_color = -1;
+    pCache->bg = bg;
+
+    pCache->orig_w = w;
+    pCache->orig_h = h;
+    (*infoRec->WriteBitmapToCache) (pScrn, pCache->x, pCache->y,
+                                    pPix->drawable.width, pPix->drawable.height,
+                                    pPix->devPrivate.ptr, pPix->devKind, fg,
+                                    bg);
+    if (!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) &&
+        ((w != pCache->w) || (h != pCache->h)))
+        XAATileCache(pScrn, pCache, w, h);
+
+    return pCache;
+}
+
+XAACacheInfoPtr
+XAACacheMono8x8Pattern(ScrnInfoPtr pScrn, int pat0, int pat1)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    XAAPixmapCachePrivatePtr pCachePriv =
+        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
+    XAACacheInfoPtr pCache = pCachePriv->InfoMono;
+    int i;
+
+    for (i = 0; i < pCachePriv->NumMono; i++, pCache++) {
+        if (pCache->serialNumber &&
+            (pCache->pat0 == pat0) && (pCache->pat1 == pat1))
+            return pCache;
+    }
+
+    /* OK, let's cache it */
+    pCache = &pCachePriv->InfoMono[pCachePriv->CurrentMono++];
+    if (pCachePriv->CurrentMono >= pCachePriv->NumMono)
+        pCachePriv->CurrentMono = 0;
+
+    pCache->serialNumber = 1;   /* we don't care since we do lookups by pattern */
+    pCache->pat0 = pat0;
+    pCache->pat1 = pat1;
+
+    (*infoRec->WriteMono8x8PatternToCache) (pScrn, pCache);
+
+    return pCache;
+}
+
+XAACacheInfoPtr
+XAACacheColor8x8Pattern(ScrnInfoPtr pScrn, PixmapPtr pPix, int fg, int bg)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    XAAPixmapCachePrivatePtr pCachePriv =
+        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
+    XAACacheInfoPtr pCache = pCachePriv->InfoColor;
+    XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
+    int i;
+
+    if (!(pixPriv->flags & REDUCIBLE_TO_2_COLOR)) {
+        for (i = 0; i < pCachePriv->NumColor; i++, pCache++) {
+            if (pCache->serialNumber == pPix->drawable.serialNumber) {
+                pCache->trans_color = -1;
+                return pCache;
+            }
+        }
+        pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++];
+        if (pCachePriv->CurrentColor >= pCachePriv->NumColor)
+            pCachePriv->CurrentColor = 0;
+
+        pCache->serialNumber = pPix->drawable.serialNumber;
+        pCache->trans_color = pCache->fg = pCache->bg = -1;
+    }
+    else {
+        int pat0 = pixPriv->pattern0;
+        int pat1 = pixPriv->pattern1;
+
+        if (fg == -1) {         /* it's a tile */
+            fg = pixPriv->fg;
+            bg = pixPriv->bg;
+        }
+
+        if (bg == -1) {         /* stipple */
+            for (i = 0; i < pCachePriv->NumColor; i++, pCache++) {
+                if (pCache->serialNumber &&
+                    (pCache->pat0 == pat0) && (pCache->pat1 == pat1) &&
+                    (pCache->fg == fg) && (pCache->bg != fg)) {
+                    pCache->trans_color = pCache->bg;
+                    return pCache;
+                }
+            }
+        }
+        else {                  /* opaque stipple */
+            for (i = 0; i < pCachePriv->NumColor; i++, pCache++) {
+                if (pCache->serialNumber &&
+                    (pCache->pat0 == pat0) && (pCache->pat1 == pat1) &&
+                    (pCache->fg == fg) && (pCache->bg == bg)) {
+                    pCache->trans_color = -1;
+                    return pCache;
+                }
+            }
+        }
+        pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++];
+        if (pCachePriv->CurrentColor >= pCachePriv->NumColor)
+            pCachePriv->CurrentColor = 0;
+
+        if (bg == -1)
+            pCache->trans_color = bg = fg ^ 1;
+        else
+            pCache->trans_color = -1;
+
+        pCache->pat0 = pat0;
+        pCache->pat1 = pat1;
+        pCache->fg = fg;
+        pCache->bg = bg;
+        pCache->serialNumber = 1;
+    }
+
+    (*infoRec->WriteColor8x8PatternToCache) (pScrn, pPix, pCache);
+
+    return pCache;
+}
+
+void
+XAAWriteBitmapToCache(ScrnInfoPtr pScrn,
+                      int x, int y, int w, int h,
+                      unsigned char *src, int srcwidth, int fg, int bg)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+
+    (*infoRec->WriteBitmap) (pScrn, x, y, w, h, src, srcwidth,
+                             0, fg, bg, GXcopy, ~0);
+}
+
+void
+XAAWriteBitmapToCacheLinear(ScrnInfoPtr pScrn,
+                            int x, int y, int w, int h,
+                            unsigned char *src, int srcwidth, int fg, int bg)
+{
+    ScreenPtr pScreen = pScrn->pScreen;
+    PixmapPtr pScreenPix, pDstPix;
+    ChangeGCVal gcvals[2];
+    GCPtr pGC;
+
+    pScreenPix = (*pScreen->GetScreenPixmap) (pScreen);
+
+    pDstPix = GetScratchPixmapHeader(pScreen, pScreenPix->drawable.width,
+                                     y + h, pScreenPix->drawable.depth,
+                                     pScreenPix->drawable.bitsPerPixel,
+                                     pScreenPix->devKind,
+                                     pScreenPix->devPrivate.ptr);
+
+    pGC = GetScratchGC(pScreenPix->drawable.depth, pScreen);
+    gcvals[0].val = fg;
+    gcvals[1].val = bg;
+    ChangeGC(NullClient, pGC, GCForeground | GCBackground, gcvals);
+    ValidateGC((DrawablePtr) pDstPix, pGC);
+
+    /* We've unwrapped already so these ops miss a sync */
+    SYNC_CHECK(pScrn);
+
+    (*pGC->ops->PutImage) ((DrawablePtr) pDstPix, pGC, 1, x, y, w, h, 0,
+                           XYBitmap, (pointer) src);
+
+    FreeScratchGC(pGC);
+    FreeScratchPixmapHeader(pDstPix);
+}
+
+void
+XAAWritePixmapToCache(ScrnInfoPtr pScrn,
+                      int x, int y, int w, int h,
+                      unsigned char *src, int srcwidth, int bpp, int depth)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+
+    (*infoRec->WritePixmap) (pScrn, x, y, w, h, src, srcwidth,
+                             GXcopy, ~0, -1, bpp, depth);
+}
+
+void
+XAAWritePixmapToCacheLinear(ScrnInfoPtr pScrn,
+                            int x, int y, int w, int h,
+                            unsigned char *src,
+                            int srcwidth, int bpp, int depth)
+{
+    ScreenPtr pScreen = pScrn->pScreen;
+    PixmapPtr pScreenPix, pDstPix;
+    GCPtr pGC;
+
+    pScreenPix = (*pScreen->GetScreenPixmap) (pScreen);
+
+    pDstPix = GetScratchPixmapHeader(pScreen, x + w, y + h,
+                                     depth, bpp, pScreenPix->devKind,
+                                     pScreenPix->devPrivate.ptr);
+
+    pGC = GetScratchGC(depth, pScreen);
+    ValidateGC((DrawablePtr) pDstPix, pGC);
+
+    /* We've unwrapped already so these ops miss a sync */
+    SYNC_CHECK(pScrn);
+
+    if (bpp == BitsPerPixel(depth))
+        (*pGC->ops->PutImage) ((DrawablePtr) pDstPix, pGC, depth, x, y, w,
+                               h, 0, ZPixmap, (pointer) src);
+    else {
+        PixmapPtr pSrcPix;
+
+        pSrcPix = GetScratchPixmapHeader(pScreen, w, h, depth, bpp,
+                                         srcwidth, (pointer) src);
+
+        (*pGC->ops->CopyArea) ((DrawablePtr) pSrcPix, (DrawablePtr) pDstPix,
+                               pGC, 0, 0, w, h, x, y);
+
+        FreeScratchPixmapHeader(pSrcPix);
+    }
+
+    FreeScratchGC(pGC);
+    FreeScratchPixmapHeader(pDstPix);
+}
+
+void
+XAAWriteMono8x8PatternToCache(ScrnInfoPtr pScrn, XAACacheInfoPtr pCache)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    XAAPixmapCachePrivatePtr pCachePriv =
+        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
+    unsigned char *data;
+    int pad, Bpp = (pScrn->bitsPerPixel >> 3);
+
+    pCache->offsets = pCachePriv->MonoOffsets;
+
+    pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel);
+
+    data = (unsigned char *) malloc(pad * pCache->h);
+    if (!data)
+        return;
+
+    if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {
+        CARD32 *ptr = (CARD32 *) data;
+
+        ptr[0] = pCache->pat0;
+        ptr[1] = pCache->pat1;
+    }
+    else {
+        CARD32 *ptr;
+        DDXPointPtr pPoint = pCache->offsets;
+        int patx, paty, i;
+
+        for (i = 0; i < 64; i++, pPoint++) {
+            patx = pCache->pat0;
+            paty = pCache->pat1;
+            XAARotateMonoPattern(&patx, &paty, i & 0x07, i >> 3,
+                                 (infoRec->Mono8x8PatternFillFlags &
+                                  BIT_ORDER_IN_BYTE_MSBFIRST));
+            ptr = (CARD32 *) (data + (pad * pPoint->y) + (Bpp * pPoint->x));
+            ptr[0] = patx;
+            ptr[1] = paty;
+        }
+    }
+
+    (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y,
+                                    pCache->w, pCache->h, data, pad,
+                                    pScrn->bitsPerPixel, pScrn->depth);
+
+    free(data);
+}
+
+void
+XAAWriteColor8x8PatternToCache(ScrnInfoPtr pScrn,
+                               PixmapPtr pPix, XAACacheInfoPtr pCache)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
+    XAAPixmapCachePrivatePtr pCachePriv =
+        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
+    int pad, i, w, h, nw, nh, Bpp;
+    unsigned char *data, *srcPtr, *dstPtr;
+
+    pCache->offsets = pCachePriv->ColorOffsets;
+
+    if (pixPriv->flags & REDUCIBLE_TO_2_COLOR) {
+        CARD32 *ptr;
+
+        pad = BitmapBytePad(pCache->w);
+        data = (unsigned char *) malloc(pad * pCache->h);
+        if (!data)
+            return;
+
+        if (infoRec->Color8x8PatternFillFlags &
+            HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {
+            ptr = (CARD32 *) data;
+            ptr[0] = pCache->pat0;
+            ptr[1] = pCache->pat1;
+        }
+        else {
+            int patx, paty;
+
+            ptr = (CARD32 *) data;
+            ptr[0] = ptr[2] = pCache->pat0;
+            ptr[1] = ptr[3] = pCache->pat1;
+            for (i = 1; i < 8; i++) {
+                patx = pCache->pat0;
+                paty = pCache->pat1;
+                XAARotateMonoPattern(&patx, &paty, i, 0,
+                                     (infoRec->Mono8x8PatternFillFlags &
+                                      BIT_ORDER_IN_BYTE_MSBFIRST));
+                ptr = (CARD32 *) (data + (pad * i));
+                ptr[0] = ptr[2] = patx;
+                ptr[1] = ptr[3] = paty;
+            }
+        }
+
+        (*infoRec->WriteBitmapToCache) (pScrn, pCache->x, pCache->y,
+                                        pCache->w, pCache->h, data, pad,
+                                        pCache->fg, pCache->bg);
+
+        free(data);
+        return;
+    }
+
+    Bpp = pScrn->bitsPerPixel >> 3;
+    h = min(8, pPix->drawable.height);
+    w = min(8, pPix->drawable.width);
+    pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel);
+
+    data = (unsigned char *) malloc(pad * pCache->h);
+    if (!data)
+        return;
+
+    /* Write and expand horizontally. */
+    for (i = h, dstPtr = data, srcPtr = pPix->devPrivate.ptr; i--;
+         srcPtr += pPix->devKind, dstPtr += pScrn->bitsPerPixel) {
+        nw = w;
+        memcpy(dstPtr, srcPtr, w * Bpp);
+        while (nw != 8) {
+            memcpy(dstPtr + (nw * Bpp), dstPtr, nw * Bpp);
+            nw <<= 1;
+        }
+    }
+    nh = h;
+    /* Expand vertically. */
+    while (nh != 8) {
+        memcpy(data + (nh * pScrn->bitsPerPixel), data,
+               nh * pScrn->bitsPerPixel);
+        nh <<= 1;
+    }
+
+    if (!(infoRec->Color8x8PatternFillFlags &
+          HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
+        int j;
+        unsigned char *ptr = data + (128 * Bpp);
+
+        memcpy(data + (64 * Bpp), data, 64 * Bpp);
+        for (i = 1; i < 8; i++, ptr += (128 * Bpp)) {
+            for (j = 0; j < 8; j++) {
+                memcpy(ptr + (j * 8) * Bpp, data + (j * 8 + i) * Bpp,
+                       (8 - i) * Bpp);
+                memcpy(ptr + (j * 8 + 8 - i) * Bpp, data + j * 8 * Bpp,
+                       i * Bpp);
+            }
+            memcpy(ptr + (64 * Bpp), ptr, 64 * Bpp);
+        }
+    }
+
+    (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y,
+                                    pCache->w, pCache->h, data, pad,
+                                    pScrn->bitsPerPixel, pScrn->depth);
+
+    free(data);
+}
+
+int
+XAAStippledFillChooser(GCPtr pGC)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    PixmapPtr pPixmap = pGC->stipple;
+    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
+
+    if (!(pPriv->flags & REDUCIBILITY_CHECKED) &&
+        (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {
+        XAACheckStippleReducibility(pPixmap);
+    }
+
+    if (pPriv->flags & REDUCIBLE_TO_8x8) {
+        if (infoRec->CanDoMono8x8 &&
+            !(infoRec->FillMono8x8PatternSpansFlags & NO_TRANSPARENCY) &&
+            ((pGC->alu == GXcopy) || !(infoRec->FillMono8x8PatternSpansFlags &
+                                       TRANSPARENCY_GXCOPY_ONLY)) &&
+            CHECK_ROP(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
+            CHECK_ROPSRC(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
+            CHECK_FG(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
+            CHECK_PLANEMASK(pGC, infoRec->FillMono8x8PatternSpansFlags)) {
+
+            return DO_MONO_8x8;
+        }
+
+        if (infoRec->CanDoColor8x8 &&
+            !(infoRec->FillColor8x8PatternSpansFlags & NO_TRANSPARENCY) &&
+            ((pGC->alu == GXcopy) || !(infoRec->FillColor8x8PatternSpansFlags &
+                                       TRANSPARENCY_GXCOPY_ONLY)) &&
+            CHECK_ROP(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
+            CHECK_ROPSRC(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
+            CHECK_PLANEMASK(pGC, infoRec->FillColor8x8PatternSpansFlags)) {
+
+            return DO_COLOR_8x8;
+        }
+    }
+
+    if (infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans &&
+        (pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) &&
+        (pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth /
+         infoRec->CacheColorExpandDensity) &&
+        !(infoRec->FillCacheExpandSpansFlags & NO_TRANSPARENCY) &&
+        ((pGC->alu == GXcopy) || !(infoRec->FillCacheExpandSpansFlags &
+                                   TRANSPARENCY_GXCOPY_ONLY)) &&
+        CHECK_ROP(pGC, infoRec->FillCacheExpandSpansFlags) &&
+        CHECK_ROPSRC(pGC, infoRec->FillCacheExpandSpansFlags) &&
+        CHECK_FG(pGC, infoRec->FillCacheExpandSpansFlags) &&
+        CHECK_PLANEMASK(pGC, infoRec->FillCacheExpandSpansFlags)) {
+
+        return DO_CACHE_EXPAND;
+    }
+
+    if (infoRec->UsingPixmapCache &&
+        !(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) &&
+        infoRec->FillCacheBltSpans &&
+        (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) &&
+        (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) &&
+        !(infoRec->FillCacheBltSpansFlags & NO_TRANSPARENCY) &&
+        ((pGC->alu == GXcopy) || !(infoRec->FillCacheBltSpansFlags &
+                                   TRANSPARENCY_GXCOPY_ONLY)) &&
+        CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) &&
+        CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) &&
+        CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) {
+
+        return DO_CACHE_BLT;
+    }
+
+    if (infoRec->FillColorExpandSpans &&
+        !(infoRec->FillColorExpandSpansFlags & NO_TRANSPARENCY) &&
+        ((pGC->alu == GXcopy) || !(infoRec->FillColorExpandSpansFlags &
+                                   TRANSPARENCY_GXCOPY_ONLY)) &&
+        CHECK_ROP(pGC, infoRec->FillColorExpandSpansFlags) &&
+        CHECK_ROPSRC(pGC, infoRec->FillColorExpandSpansFlags) &&
+        CHECK_FG(pGC, infoRec->FillColorExpandSpansFlags) &&
+        CHECK_PLANEMASK(pGC, infoRec->FillColorExpandSpansFlags)) {
+
+        return DO_COLOR_EXPAND;
+    }
+
+    return 0;
+}
+
+int
+XAAOpaqueStippledFillChooser(GCPtr pGC)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    PixmapPtr pPixmap = pGC->stipple;
+    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
+
+    if (XAA_DEPTH_BUG(pGC))
+        return 0;
+
+    if (!(pPriv->flags & REDUCIBILITY_CHECKED) &&
+        (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {
+        XAACheckStippleReducibility(pPixmap);
+    }
+
+    if (pPriv->flags & REDUCIBLE_TO_8x8) {
+        if (infoRec->CanDoMono8x8 &&
+            !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) &&
+            CHECK_ROP(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
+            CHECK_ROPSRC(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
+            CHECK_COLORS(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
+            CHECK_PLANEMASK(pGC, infoRec->FillMono8x8PatternSpansFlags)) {
+
+            return DO_MONO_8x8;
+        }
+
+        if (infoRec->CanDoColor8x8 &&
+            CHECK_ROP(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
+            CHECK_ROPSRC(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
+            CHECK_PLANEMASK(pGC, infoRec->FillColor8x8PatternSpansFlags)) {
+
+            return DO_COLOR_8x8;
+        }
+    }
+
+    if (infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans &&
+        (pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) &&
+        (pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth /
+         infoRec->CacheColorExpandDensity) &&
+        !(infoRec->FillCacheExpandSpansFlags & TRANSPARENCY_ONLY) &&
+        CHECK_ROP(pGC, infoRec->FillCacheExpandSpansFlags) &&
+        CHECK_ROPSRC(pGC, infoRec->FillCacheExpandSpansFlags) &&
+        CHECK_COLORS(pGC, infoRec->FillCacheExpandSpansFlags) &&
+        CHECK_PLANEMASK(pGC, infoRec->FillCacheExpandSpansFlags)) {
+
+        return DO_CACHE_EXPAND;
+    }
+
+    if (infoRec->UsingPixmapCache &&
+        !(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) &&
+        infoRec->FillCacheBltSpans &&
+        (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) &&
+        (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) &&
+        CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) &&
+        CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) &&
+        CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) {
+
+        return DO_CACHE_BLT;
+    }
+
+    if (infoRec->FillColorExpandSpans &&
+        !(infoRec->FillColorExpandSpansFlags & TRANSPARENCY_ONLY) &&
+        CHECK_ROP(pGC, infoRec->FillColorExpandSpansFlags) &&
+        CHECK_ROPSRC(pGC, infoRec->FillColorExpandSpansFlags) &&
+        CHECK_COLORS(pGC, infoRec->FillColorExpandSpansFlags) &&
+        CHECK_PLANEMASK(pGC, infoRec->FillColorExpandSpansFlags)) {
+
+        return DO_COLOR_EXPAND;
+    }
+
+    return 0;
+}
+
+int
+XAATiledFillChooser(GCPtr pGC)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    PixmapPtr pPixmap = pGC->tile.pixmap;
+    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
+
+    if (IS_OFFSCREEN_PIXMAP(pPixmap) && infoRec->FillCacheBltSpans &&
+        CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) &&
+        CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) &&
+        CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) {
+
+        return DO_PIXMAP_COPY;
+    }
+
+    if (!(pPriv->flags & REDUCIBILITY_CHECKED) &&
+        (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {
+        XAACheckTileReducibility(pPixmap, infoRec->CanDoMono8x8);
+    }
+
+    if (pPriv->flags & REDUCIBLE_TO_8x8) {
+        if ((pPriv->flags & REDUCIBLE_TO_2_COLOR) && infoRec->CanDoMono8x8 &&
+            !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) &&
+            CHECK_ROP(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
+            CHECK_ROPSRC(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
+            (!(infoRec->FillMono8x8PatternSpansFlags & RGB_EQUAL) ||
+             (CHECK_RGB_EQUAL(pPriv->fg) && CHECK_RGB_EQUAL(pPriv->bg))) &&
+            CHECK_PLANEMASK(pGC, infoRec->FillMono8x8PatternSpansFlags)) {
+
+            return DO_MONO_8x8;
+        }
+
+        if (infoRec->CanDoColor8x8 &&
+            CHECK_ROP(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
+            CHECK_ROPSRC(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
+            CHECK_PLANEMASK(pGC, infoRec->FillColor8x8PatternSpansFlags)) {
+
+            return DO_COLOR_8x8;
+        }
+    }
+
+    if (infoRec->UsingPixmapCache && infoRec->FillCacheBltSpans &&
+        (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) &&
+        (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) &&
+        CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) &&
+        CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) &&
+        CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) {
+
+        return DO_CACHE_BLT;
+    }
+
+    if (infoRec->FillImageWriteRects &&
+        CHECK_NO_GXCOPY(pGC, infoRec->FillImageWriteRectsFlags) &&
+        CHECK_ROP(pGC, infoRec->FillImageWriteRectsFlags) &&
+        CHECK_ROPSRC(pGC, infoRec->FillImageWriteRectsFlags) &&
+        CHECK_PLANEMASK(pGC, infoRec->FillImageWriteRectsFlags)) {
+
+        return DO_IMAGE_WRITE;
+    }
+
+    return 0;
+}
+
+static int RotateMasksX[8] = {
+    0xFFFFFFFF, 0x7F7F7F7F, 0x3F3F3F3F, 0x1F1F1F1F,
+    0x0F0F0F0F, 0x07070707, 0x03030303, 0x01010101
+};
+
+static int RotateMasksY[4] = {
+    0xFFFFFFFF, 0x00FFFFFF, 0x0000FFFF, 0x000000FF
+};
+
+void
+XAARotateMonoPattern(int *pat0, int *pat1, int xorg, int yorg, Bool msbfirst)
+{
+    int tmp, mask;
+
+    if (xorg) {
+        if (msbfirst)
+            xorg = 8 - xorg;
+        mask = RotateMasksX[xorg];
+        *pat0 = ((*pat0 >> xorg) & mask) | ((*pat0 << (8 - xorg)) & ~mask);
+        *pat1 = ((*pat1 >> xorg) & mask) | ((*pat1 << (8 - xorg)) & ~mask);
+    }
+    if (yorg >= 4) {
+        tmp = *pat0;
+        *pat0 = *pat1;
+        *pat1 = tmp;
+        yorg -= 4;
+    }
+    if (yorg) {
+        mask = RotateMasksY[yorg];
+        yorg <<= 3;
+        tmp = *pat0;
+        *pat0 = ((*pat0 >> yorg) & mask) | ((*pat1 << (32 - yorg)) & ~mask);
+        *pat1 = ((*pat1 >> yorg) & mask) | ((tmp << (32 - yorg)) & ~mask);
+    }
+}
+
+void
+XAAInvalidatePixmapCache(ScreenPtr pScreen)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
+    XAAPixmapCachePrivatePtr pCachePriv =
+        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
+    int i;
+
+    if (!pCachePriv)
+        return;
+
+    for (i = 0; i < pCachePriv->Num512x512; i++)
+        (pCachePriv->Info512)[i].serialNumber = 0;
+    for (i = 0; i < pCachePriv->Num256x256; i++)
+        (pCachePriv->Info256)[i].serialNumber = 0;
+    for (i = 0; i < pCachePriv->Num128x128; i++)
+        (pCachePriv->Info128)[i].serialNumber = 0;
+    for (i = 0; i < pCachePriv->NumPartial; i++)
+        (pCachePriv->InfoPartial)[i].serialNumber = 0;
+    for (i = 0; i < pCachePriv->NumMono; i++)
+        (pCachePriv->InfoMono)[i].serialNumber = 0;
+    for (i = 0; i < pCachePriv->NumColor; i++)
+        (pCachePriv->InfoColor)[i].serialNumber = 0;
+}