Merge remote-tracking branch 'origin/released'

Conflicts:
	xorg-server/Xext/shm.c
	xorg-server/Xext/sync.c
	xorg-server/Xext/xf86bigfont.c
	xorg-server/Xi/opendev.c
	xorg-server/dix/dispatch.c
	xorg-server/include/globals.h
	xorg-server/mi/miinitext.c

1 files changed, 0 insertions, 1101 deletions

diff --git a/xorg-server/hw/xfree86/xaa/xaaFillRect.c b/xorg-server/hw/xfree86/xaa/xaaFillRect.c
deleted file mode 100644
index ec0fb9df7..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaFillRect.c
+++ /dev/null
@@ -1,1101 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-static void XAARenderSolidRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderColor8x8Rects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderMono8x8Rects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderColorExpandRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderCacheExpandRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderCacheBltRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderImageWriteRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderPixmapCopyRects(GCPtr, int, BoxPtr, int, int);
-
-void
-XAAPolyFillRect(DrawablePtr pDraw, GCPtr pGC, int nrectFill,    /* number of rectangles to fill */
-                xRectangle *prectInit   /* Pointer to first rectangle to fill */
-    )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int xorg = pDraw->x;
-    int yorg = pDraw->y;
-    int type = 0;
-    ClipAndRenderRectsFunc function;
-
-    if ((nrectFill <= 0) || !pGC->planemask)
-        return;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    switch (pGC->fillStyle) {
-    case FillSolid:
-        type = DO_SOLID;
-        break;
-    case FillStippled:
-        type = (*infoRec->StippledFillChooser) (pGC);
-        break;
-    case FillOpaqueStippled:
-        if ((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSolidRects &&
-            CHECK_PLANEMASK(pGC, infoRec->FillSolidRectsFlags) &&
-            CHECK_ROP(pGC, infoRec->FillSolidRectsFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillSolidRectsFlags) &&
-            CHECK_FG(pGC, infoRec->FillSolidRectsFlags))
-            type = DO_SOLID;
-        else
-            type = (*infoRec->OpaqueStippledFillChooser) (pGC);
-        break;
-    case FillTiled:
-        type = (*infoRec->TiledFillChooser) (pGC);
-        break;
-    }
-
-    switch (type) {
-    case DO_SOLID:
-        function = XAARenderSolidRects;
-        break;
-    case DO_COLOR_8x8:
-        function = XAARenderColor8x8Rects;
-        break;
-    case DO_MONO_8x8:
-        function = XAARenderMono8x8Rects;
-        break;
-    case DO_CACHE_BLT:
-        function = XAARenderCacheBltRects;
-        break;
-    case DO_COLOR_EXPAND:
-        function = XAARenderColorExpandRects;
-        break;
-    case DO_CACHE_EXPAND:
-        function = XAARenderCacheExpandRects;
-        break;
-    case DO_IMAGE_WRITE:
-        function = XAARenderImageWriteRects;
-        break;
-    case DO_PIXMAP_COPY:
-        function = XAARenderPixmapCopyRects;
-        break;
-    default:
-        (*XAAFallbackOps.PolyFillRect) (pDraw, pGC, nrectFill, prectInit);
-        return;
-    }
-
-    if (xorg | yorg) {
-        int n = nrectFill;
-        xRectangle *prect = prectInit;
-
-        while (n--) {
-            prect->x += xorg;
-            prect->y += yorg;
-            prect++;
-        }
-    }
-
-    XAAClipAndRenderRects(pGC, function, nrectFill, prectInit, xorg, yorg);
-}
-
-        /*********************\
-	|     Solid Rects     |
-	\*********************/
-
-static void
-XAARenderSolidRects(GCPtr pGC,
-                    int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    (*infoRec->FillSolidRects) (infoRec->pScrn,
-                                pGC->fgPixel, pGC->alu, pGC->planemask, nboxes,
-                                pClipBoxes);
-}
-
-        /************************\
-	|     Mono 8x8 Rects     |
-	\************************/
-
-static void
-XAARenderMono8x8Rects(GCPtr pGC,
-                      int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAPixmapPtr pPriv;
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    case FillTiled:
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-        fg = pPriv->fg;
-        bg = pPriv->bg;
-        break;
-    default:                   /* Muffle compiler */
-        pPriv = NULL;           /* Kaboom */
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    (*infoRec->FillMono8x8PatternRects) (infoRec->pScrn,
-                                         fg, bg, pGC->alu, pGC->planemask,
-                                         nboxes, pClipBoxes, pPriv->pattern0,
-                                         pPriv->pattern1,
-                                         (xorg + pGC->patOrg.x),
-                                         (yorg + pGC->patOrg.y));
-}
-
-        /*************************\
-	|     Color 8x8 Rects     |
-	\*************************/
-
-static void
-XAARenderColor8x8Rects(GCPtr pGC,
-                       int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAACacheInfoPtr pCache;
-    PixmapPtr pPix;
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        pPix = pGC->stipple;
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        pPix = pGC->stipple;
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    case FillTiled:
-        pPix = pGC->tile.pixmap;
-        fg = -1;
-        bg = -1;
-        break;
-    default:                   /* Muffle compiler */
-        pPix = NULL;
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    pCache = (*infoRec->CacheColor8x8Pattern) (infoRec->pScrn, pPix, fg, bg);
-    (*infoRec->FillColor8x8PatternRects) (infoRec->pScrn,
-                                          pGC->alu, pGC->planemask, nboxes,
-                                          pClipBoxes, (xorg + pGC->patOrg.x),
-                                          (yorg + pGC->patOrg.y), pCache);
-}
-
-        /****************************\
-	|     Color Expand Rects     |
-	\****************************/
-
-static void
-XAARenderColorExpandRects(GCPtr pGC,
-                          int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    default:                   /* Muffle compiler */
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    (*infoRec->FillColorExpandRects) (infoRec->pScrn, fg, bg,
-                                      pGC->alu, pGC->planemask, nboxes,
-                                      pClipBoxes, (xorg + pGC->patOrg.x),
-                                      (yorg + pGC->patOrg.y), pGC->stipple);
-}
-
-        /*************************\
-	|     Cache Blt Rects     |
-	\*************************/
-
-static void
-XAARenderCacheBltRects(GCPtr pGC,
-                       int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAACacheInfoPtr pCache;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        pCache = (*infoRec->CacheStipple) (infoRec->pScrn, pGC->stipple,
-                                           pGC->fgPixel, -1);
-        break;
-    case FillOpaqueStippled:
-        pCache = (*infoRec->CacheStipple) (infoRec->pScrn, pGC->stipple,
-                                           pGC->fgPixel, pGC->bgPixel);
-        break;
-    case FillTiled:
-        pCache = (*infoRec->CacheTile) (infoRec->pScrn, pGC->tile.pixmap);
-        break;
-    default:                   /* Muffle compiler */
-        pCache = NULL;
-        break;
-    }
-
-    (*infoRec->FillCacheBltRects) (infoRec->pScrn, pGC->alu,
-                                   pGC->planemask, nboxes, pClipBoxes,
-                                   (xorg + pGC->patOrg.x),
-                                   (yorg + pGC->patOrg.y), pCache);
-}
-
-        /****************************\
-	|     Cache Expand Rects     |
-	\****************************/
-
-static void
-XAARenderCacheExpandRects(GCPtr pGC,
-                          int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    default:                   /* Muffle compiler */
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    (*infoRec->FillCacheExpandRects) (infoRec->pScrn, fg, bg,
-                                      pGC->alu, pGC->planemask, nboxes,
-                                      pClipBoxes, (xorg + pGC->patOrg.x),
-                                      (yorg + pGC->patOrg.y), pGC->stipple);
-}
-
-        /***************************\
-	|     Image Write Rects     |
-	\***************************/
-
-static void
-XAARenderImageWriteRects(GCPtr pGC,
-                         int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    (*infoRec->FillImageWriteRects) (infoRec->pScrn, pGC->alu,
-                                     pGC->planemask, nboxes, pClipBoxes,
-                                     (xorg + pGC->patOrg.x),
-                                     (yorg + pGC->patOrg.y), pGC->tile.pixmap);
-}
-
-        /***************************\
-	|     Pixmap Copy Rects     |
-	\***************************/
-
-static void
-XAARenderPixmapCopyRects(GCPtr pGC,
-                         int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-
-    pCache->x = pPriv->offscreenArea->box.x1;
-    pCache->y = pPriv->offscreenArea->box.y1;
-    pCache->w = pCache->orig_w = pPriv->offscreenArea->box.x2 - pCache->x;
-    pCache->h = pCache->orig_h = pPriv->offscreenArea->box.y2 - pCache->y;
-    pCache->trans_color = -1;
-
-    (*infoRec->FillCacheBltRects) (infoRec->pScrn, pGC->alu,
-                                   pGC->planemask, nboxes, pClipBoxes,
-                                   (xorg + pGC->patOrg.x),
-                                   (yorg + pGC->patOrg.y), pCache);
-}
-
-        /************\
-	|   Solid    |
-	\************/
-
-void
-XAAFillSolidRects(ScrnInfoPtr pScrn, int fg, int rop, unsigned int planemask, int nBox, /* number of rectangles to fill */
-                  BoxPtr pBox   /* Pointer to first rectangle to fill */
-    )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SetupForSolidFill) (pScrn, fg, rop, planemask);
-    while (nBox--) {
-        (*infoRec->SubsequentSolidFillRect) (pScrn, pBox->x1, pBox->y1,
-                                             pBox->x2 - pBox->x1,
-                                             pBox->y2 - pBox->y1);
-        pBox++;
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /*********************\
-	|  8x8 Mono Patterns  |
-	\*********************/
-
-void
-XAAFillMono8x8PatternRectsScreenOrigin(ScrnInfoPtr pScrn,
-                                       int fg, int bg, int rop,
-                                       unsigned int planemask,
-                                       int nBox,
-                                       BoxPtr pBox,
-                                       int pattern0, int pattern1,
-                                       int xorigin, int yorigin)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-    if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-                                 (infoRec->Mono8x8PatternFillFlags &
-                                  BIT_ORDER_IN_BYTE_MSBFIRST));
-            xorg = patx;
-            yorg = paty;
-        }
-    }
-    else {
-        XAACacheInfoPtr pCache =
-            (*infoRec->CacheMono8x8Pattern) (pScrn, pattern0, pattern1);
-        patx = pCache->x;
-        paty = pCache->y;
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            int slot = (yorg << 3) + xorg;
-
-            patx += pCache->offsets[slot].x;
-            paty += pCache->offsets[slot].y;
-            xorg = patx;
-            yorg = paty;
-        }
-    }
-
-    (*infoRec->SetupForMono8x8PatternFill) (pScrn, patx, paty,
-                                            fg, bg, rop, planemask);
-
-    while (nBox--) {
-        (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn,
-                                                      xorg, yorg, pBox->x1,
-                                                      pBox->y1,
-                                                      pBox->x2 - pBox->x1,
-                                                      pBox->y2 - pBox->y1);
-        pBox++;
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAFillMono8x8PatternRects(ScrnInfoPtr pScrn,
-                           int fg, int bg, int rop,
-                           unsigned int planemask,
-                           int nBox,
-                           BoxPtr pBox,
-                           int pattern0, int pattern1, int xorigin, int yorigin)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg, yorg;
-    XAACacheInfoPtr pCache = NULL;
-
-    if (!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)) {
-        pCache = (*infoRec->CacheMono8x8Pattern) (pScrn, pattern0, pattern1);
-        patx = pCache->x;
-        paty = pCache->y;
-    }
-
-    (*infoRec->SetupForMono8x8PatternFill) (pScrn, patx, paty,
-                                            fg, bg, rop, planemask);
-
-    while (nBox--) {
-        xorg = (pBox->x1 - xorigin) & 0x07;
-        yorg = (pBox->y1 - yorigin) & 0x07;
-
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            if (infoRec->Mono8x8PatternFillFlags &
-                HARDWARE_PATTERN_PROGRAMMED_BITS) {
-                patx = pattern0;
-                paty = pattern1;
-                XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-                                     (infoRec->Mono8x8PatternFillFlags &
-                                      BIT_ORDER_IN_BYTE_MSBFIRST));
-                xorg = patx;
-                yorg = paty;
-            }
-            else {
-                int slot = (yorg << 3) + xorg;
-
-                xorg = patx + pCache->offsets[slot].x;
-                yorg = paty + pCache->offsets[slot].y;
-            }
-        }
-
-        (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn,
-                                                      xorg, yorg, pBox->x1,
-                                                      pBox->y1,
-                                                      pBox->x2 - pBox->x1,
-                                                      pBox->y2 - pBox->y1);
-        pBox++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /**********************\
-	|  8x8 Color Patterns  |
-	\**********************/
-
-void
-XAAFillColor8x8PatternRectsScreenOrigin(ScrnInfoPtr pScrn,
-                                        int rop,
-                                        unsigned int planemask,
-                                        int nBox,
-                                        BoxPtr pBox,
-                                        int xorigin, int yorigin,
-                                        XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pCache->x, paty = pCache->y;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-    if (!(infoRec->Color8x8PatternFillFlags &
-          HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-        int slot = (yorg << 3) + xorg;
-
-        paty += pCache->offsets[slot].y;
-        patx += pCache->offsets[slot].x;
-        xorg = patx;
-        yorg = paty;
-    }
-
-    (*infoRec->SetupForColor8x8PatternFill) (pScrn, patx, paty,
-                                             rop, planemask,
-                                             pCache->trans_color);
-
-    while (nBox--) {
-        (*infoRec->SubsequentColor8x8PatternFillRect) (pScrn,
-                                                       xorg, yorg, pBox->x1,
-                                                       pBox->y1,
-                                                       pBox->x2 - pBox->x1,
-                                                       pBox->y2 - pBox->y1);
-        pBox++;
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAFillColor8x8PatternRects(ScrnInfoPtr pScrn,
-                            int rop,
-                            unsigned int planemask,
-                            int nBox,
-                            BoxPtr pBox,
-                            int xorigin, int yorigin, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int xorg, yorg;
-
-    (*infoRec->SetupForColor8x8PatternFill) (pScrn, pCache->x, pCache->y,
-                                             rop, planemask,
-                                             pCache->trans_color);
-
-    while (nBox--) {
-        xorg = (pBox->x1 - xorigin) & 0x07;
-        yorg = (pBox->y1 - yorigin) & 0x07;
-
-        if (!(infoRec->Color8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            int slot = (yorg << 3) + xorg;
-
-            yorg = pCache->y + pCache->offsets[slot].y;
-            xorg = pCache->x + pCache->offsets[slot].x;
-        }
-
-        (*infoRec->SubsequentColor8x8PatternFillRect) (pScrn,
-                                                       xorg, yorg, pBox->x1,
-                                                       pBox->y1,
-                                                       pBox->x2 - pBox->x1,
-                                                       pBox->y2 - pBox->y1);
-        pBox++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /***************\
-	|  Cache Blits  |
-	\***************/
-
-void
-XAAFillCacheBltRects(ScrnInfoPtr pScrn,
-                     int rop,
-                     unsigned int planemask,
-                     int nBox,
-                     BoxPtr pBox, int xorg, int yorg, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;
-
-    (*infoRec->SetupForScreenToScreenCopy) (pScrn, 1, 1, rop, planemask,
-                                            pCache->trans_color);
-
-    while (nBox--) {
-        y = pBox->y1;
-        phaseY = (y - yorg) % pCache->orig_h;
-        if (phaseY < 0)
-            phaseY += pCache->orig_h;
-        phaseX = (pBox->x1 - xorg) % pCache->orig_w;
-        if (phaseX < 0)
-            phaseX += pCache->orig_w;
-        height = pBox->y2 - y;
-        width = pBox->x2 - pBox->x1;
-
-#if 0
-        if (rop == GXcopy) {
-            while (1) {
-                w = width;
-                skipleft = phaseX;
-                x = pBox->x1;
-                blit_h = pCache->h - phaseY;
-                if (blit_h > height)
-                    blit_h = height;
-
-                while (1) {
-                    blit_w = pCache->w - skipleft;
-                    if (blit_w > w)
-                        blit_w = w;
-                    (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                              pCache->x +
-                                                              skipleft,
-                                                              pCache->y +
-                                                              phaseY, x, y,
-                                                              blit_w, blit_h);
-                    w -= blit_w;
-                    if (!w)
-                        break;
-                    x += blit_w;
-                    skipleft = (skipleft + blit_w) % pCache->orig_w;
-                    if (blit_w >= pCache->orig_w)
-                        break;
-                }
-
-                /* Expand horizontally */
-                if (w) {
-                    skipleft -= phaseX;
-                    if (skipleft < 0)
-                        skipleft += pCache->orig_w;
-                    blit_w = x - pBox->x1 - skipleft;
-                    while (w) {
-                        if (blit_w > w)
-                            blit_w = w;
-                        (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                                  pBox->x1 +
-                                                                  skipleft, y,
-                                                                  x, y, blit_w,
-                                                                  blit_h);
-                        w -= blit_w;
-                        x += blit_w;
-                        blit_w <<= 1;
-                    }
-                }
-
-                height -= blit_h;
-                if (!height)
-                    break;
-                y += blit_h;
-                phaseY = (phaseY + blit_h) % pCache->orig_h;
-                if (blit_h >= pCache->orig_h)
-                    break;
-            }
-
-            /* Expand vertically */
-            if (height) {
-                blit_w = pBox->x2 - pBox->x1;
-                phaseY -= (pBox->y1 - yorg) % pCache->orig_h;
-                if (phaseY < 0)
-                    phaseY += pCache->orig_h;
-                blit_h = y - pBox->y1 - phaseY;
-                while (height) {
-                    if (blit_h > height)
-                        blit_h = height;
-                    (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pBox->x1,
-                                                              pBox->y1 + phaseY,
-                                                              pBox->x1, y,
-                                                              blit_w, blit_h);
-                    height -= blit_h;
-                    y += blit_h;
-                    blit_h <<= 1;
-                }
-            }
-        }
-        else
-#endif
-        {
-            while (1) {
-                w = width;
-                skipleft = phaseX;
-                x = pBox->x1;
-                blit_h = pCache->h - phaseY;
-                if (blit_h > height)
-                    blit_h = height;
-
-                while (1) {
-                    blit_w = pCache->w - skipleft;
-                    if (blit_w > w)
-                        blit_w = w;
-                    (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                              pCache->x +
-                                                              skipleft,
-                                                              pCache->y +
-                                                              phaseY, x, y,
-                                                              blit_w, blit_h);
-                    w -= blit_w;
-                    if (!w)
-                        break;
-                    x += blit_w;
-                    skipleft = (skipleft + blit_w) % pCache->orig_w;
-                }
-                height -= blit_h;
-                if (!height)
-                    break;
-                y += blit_h;
-                phaseY = (phaseY + blit_h) % pCache->orig_h;
-            }
-        }
-        pBox++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /*******************\
-	|  Cache Expansion  |
-	\*******************/
-
-void
-XAAFillCacheExpandRects(ScrnInfoPtr pScrn,
-                        int fg, int bg, int rop,
-                        unsigned int planemask,
-                        int nBox,
-                        BoxPtr pBox, int xorg, int yorg, PixmapPtr pPix)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;
-    int cacheWidth;
-    XAACacheInfoPtr pCache;
-
-    pCache = (*infoRec->CacheMonoStipple) (pScrn, pPix);
-
-    cacheWidth = (pCache->w * pScrn->bitsPerPixel) /
-        infoRec->CacheColorExpandDensity;
-
-    (*infoRec->SetupForScreenToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                       planemask);
-
-    while (nBox--) {
-        y = pBox->y1;
-        phaseY = (y - yorg) % pCache->orig_h;
-        if (phaseY < 0)
-            phaseY += pCache->orig_h;
-        phaseX = (pBox->x1 - xorg) % pCache->orig_w;
-        if (phaseX < 0)
-            phaseX += pCache->orig_w;
-        height = pBox->y2 - y;
-        width = pBox->x2 - pBox->x1;
-
-        while (1) {
-            w = width;
-            skipleft = phaseX;
-            x = pBox->x1;
-            blit_h = pCache->h - phaseY;
-            if (blit_h > height)
-                blit_h = height;
-
-            while (1) {
-                blit_w = cacheWidth - skipleft;
-                if (blit_w > w)
-                    blit_w = w;
-                (*infoRec->SubsequentScreenToScreenColorExpandFill) (pScrn, x,
-                                                                     y, blit_w,
-                                                                     blit_h,
-                                                                     pCache->x,
-                                                                     pCache->y +
-                                                                     phaseY,
-                                                                     skipleft);
-                w -= blit_w;
-                if (!w)
-                    break;
-                x += blit_w;
-                skipleft = (skipleft + blit_w) % pCache->orig_w;
-            }
-            height -= blit_h;
-            if (!height)
-                break;
-            y += blit_h;
-            phaseY = (phaseY + blit_h) % pCache->orig_h;
-        }
-        pBox++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /******************\
-	|   Image Writes   |
-	\******************/
-
-/*  This requires all LEFT_EDGE clipping.  You get too many problems
-    with reading past the edge of the pattern otherwise */
-
-static void
-WriteColumn(ScrnInfoPtr pScrn,
-            unsigned char *pSrc,
-            int x, int y, int w, int h,
-            int xoff, int yoff, int pHeight, int srcwidth, int Bpp)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    unsigned char *src;
-    Bool PlusOne = FALSE;
-    int skipleft, dwords;
-
-    pSrc += (Bpp * xoff);
-
-    if ((skipleft = (long) pSrc & 0x03L)) {
-        if (Bpp == 3)
-            skipleft = 4 - skipleft;
-        else
-            skipleft /= Bpp;
-
-        x -= skipleft;
-        w += skipleft;
-
-        if (Bpp == 3)
-            pSrc -= 3 * skipleft;
-        else                    /* is this Alpha friendly ? */
-            pSrc = (unsigned char *) ((long) pSrc & ~0x03L);
-    }
-
-    src = pSrc + (yoff * srcwidth);
-
-    dwords = bytes_to_int32(w * Bpp);
-
-    if ((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) &&
-        ((dwords * h) & 0x01)) {
-        PlusOne = TRUE;
-    }
-
-    (*infoRec->SubsequentImageWriteRect) (pScrn, x, y, w, h, skipleft);
-
-    if (dwords > infoRec->ImageWriteRange) {
-        while (h--) {
-            XAAMoveDWORDS_FixedBase((CARD32 *) infoRec->ImageWriteBase,
-                                    (CARD32 *) src, dwords);
-            src += srcwidth;
-            yoff++;
-            if (yoff >= pHeight) {
-                yoff = 0;
-                src = pSrc;
-            }
-        }
-    }
-    else {
-        if (srcwidth == (dwords << 2)) {
-            int maxLines = infoRec->ImageWriteRange / dwords;
-            int step;
-
-            while (h) {
-                step = pHeight - yoff;
-                if (step > maxLines)
-                    step = maxLines;
-                if (step > h)
-                    step = h;
-
-                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
-                              (CARD32 *) src, dwords * step);
-
-                src += (srcwidth * step);
-                yoff += step;
-                if (yoff >= pHeight) {
-                    yoff = 0;
-                    src = pSrc;
-                }
-                h -= step;
-            }
-        }
-        else {
-            while (h--) {
-                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
-                              (CARD32 *) src, dwords);
-                src += srcwidth;
-                yoff++;
-                if (yoff >= pHeight) {
-                    yoff = 0;
-                    src = pSrc;
-                }
-            }
-        }
-    }
-
-    if (PlusOne) {
-        CARD32 *base = (CARD32 *) infoRec->ImageWriteBase;
-
-        *base = 0x00000000;
-    }
-}
-
-void
-XAAFillImageWriteRects(ScrnInfoPtr pScrn,
-                       int rop,
-                       unsigned int planemask,
-                       int nBox,
-                       BoxPtr pBox, int xorg, int yorg, PixmapPtr pPix)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, phaseY, phaseX, height, width, blit_w;
-    int pHeight = pPix->drawable.height;
-    int pWidth = pPix->drawable.width;
-    int Bpp = pPix->drawable.bitsPerPixel >> 3;
-    int srcwidth = pPix->devKind;
-
-    (*infoRec->SetupForImageWrite) (pScrn, rop, planemask, -1,
-                                    pPix->drawable.bitsPerPixel,
-                                    pPix->drawable.depth);
-
-    while (nBox--) {
-        x = pBox->x1;
-        phaseY = (pBox->y1 - yorg) % pHeight;
-        if (phaseY < 0)
-            phaseY += pHeight;
-        phaseX = (x - xorg) % pWidth;
-        if (phaseX < 0)
-            phaseX += pWidth;
-        height = pBox->y2 - pBox->y1;
-        width = pBox->x2 - x;
-
-        while (1) {
-            blit_w = pWidth - phaseX;
-            if (blit_w > width)
-                blit_w = width;
-
-            WriteColumn(pScrn, pPix->devPrivate.ptr, x, pBox->y1,
-                        blit_w, height, phaseX, phaseY, pHeight, srcwidth, Bpp);
-
-            width -= blit_w;
-            if (!width)
-                break;
-            x += blit_w;
-            phaseX = (phaseX + blit_w) % pWidth;
-        }
-        pBox++;
-    }
-
-    if (infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-}
-
-        /*************\
-	|  Utilities  |
-	\*************/
-
-void
-XAAClipAndRenderRects(GCPtr pGC,
-                      ClipAndRenderRectsFunc BoxFunc,
-                      int nrectFill, xRectangle *prect, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int Right, Bottom, MaxBoxes;
-    BoxPtr pextent, pboxClipped, pboxClippedBase;
-
-    MaxBoxes = infoRec->PreAllocSize / sizeof(BoxRec);
-    pboxClippedBase = (BoxPtr) infoRec->PreAllocMem;
-    pboxClipped = pboxClippedBase;
-
-    if (RegionNumRects(pGC->pCompositeClip) == 1) {
-        pextent = RegionRects(pGC->pCompositeClip);
-        while (nrectFill--) {
-            pboxClipped->x1 = max(pextent->x1, prect->x);
-            pboxClipped->y1 = max(pextent->y1, prect->y);
-
-            Right = (int) prect->x + (int) prect->width;
-            pboxClipped->x2 = min(pextent->x2, Right);
-
-            Bottom = (int) prect->y + (int) prect->height;
-            pboxClipped->y2 = min(pextent->y2, Bottom);
-
-            prect++;
-            if ((pboxClipped->x1 < pboxClipped->x2) &&
-                (pboxClipped->y1 < pboxClipped->y2)) {
-                pboxClipped++;
-                if (pboxClipped >= (pboxClippedBase + MaxBoxes)) {
-                    (*BoxFunc) (pGC, MaxBoxes, pboxClippedBase, xorg, yorg);
-                    pboxClipped = pboxClippedBase;
-                }
-            }
-        }
-    }
-    else {
-        pextent = RegionExtents(pGC->pCompositeClip);
-        while (nrectFill--) {
-            int n;
-            BoxRec box, *pbox;
-
-            box.x1 = max(pextent->x1, prect->x);
-            box.y1 = max(pextent->y1, prect->y);
-
-            Right = (int) prect->x + (int) prect->width;
-            box.x2 = min(pextent->x2, Right);
-
-            Bottom = (int) prect->y + (int) prect->height;
-            box.y2 = min(pextent->y2, Bottom);
-
-            prect++;
-
-            if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
-                continue;
-
-            n = RegionNumRects(pGC->pCompositeClip);
-            pbox = RegionRects(pGC->pCompositeClip);
-
-            /* clip the rectangle to each box in the clip region
-               this is logically equivalent to calling Intersect()
-             */
-            while (n--) {
-                pboxClipped->x1 = max(box.x1, pbox->x1);
-                pboxClipped->y1 = max(box.y1, pbox->y1);
-                pboxClipped->x2 = min(box.x2, pbox->x2);
-                pboxClipped->y2 = min(box.y2, pbox->y2);
-                pbox++;
-
-                /* see if clipping left anything */
-                if (pboxClipped->x1 < pboxClipped->x2 &&
-                    pboxClipped->y1 < pboxClipped->y2) {
-                    pboxClipped++;
-                    if (pboxClipped >= (pboxClippedBase + MaxBoxes)) {
-                        (*BoxFunc) (pGC, MaxBoxes, pboxClippedBase, xorg, yorg);
-                        pboxClipped = pboxClippedBase;
-                    }
-                }
-            }
-        }
-    }
-
-    if (pboxClipped != pboxClippedBase)
-        (*BoxFunc) (pGC, pboxClipped - pboxClippedBase, pboxClippedBase,
-                    xorg, yorg);
-}
-
-int
-XAAGetRectClipBoxes(GCPtr pGC,
-                    BoxPtr pboxClippedBase,
-                    int nrectFill, xRectangle *prectInit)
-{
-    int Right, Bottom;
-    BoxPtr pextent, pboxClipped = pboxClippedBase;
-    xRectangle *prect = prectInit;
-    RegionPtr prgnClip = pGC->pCompositeClip;
-
-    if (RegionNumRects(prgnClip) == 1) {
-        pextent = RegionRects(prgnClip);
-        while (nrectFill--) {
-            pboxClipped->x1 = max(pextent->x1, prect->x);
-            pboxClipped->y1 = max(pextent->y1, prect->y);
-
-            Right = (int) prect->x + (int) prect->width;
-            pboxClipped->x2 = min(pextent->x2, Right);
-
-            Bottom = (int) prect->y + (int) prect->height;
-            pboxClipped->y2 = min(pextent->y2, Bottom);
-
-            prect++;
-            if ((pboxClipped->x1 < pboxClipped->x2) &&
-                (pboxClipped->y1 < pboxClipped->y2)) {
-                pboxClipped++;
-            }
-        }
-    }
-    else {
-        pextent = RegionExtents(prgnClip);
-        while (nrectFill--) {
-            int n;
-            BoxRec box, *pbox;
-
-            box.x1 = max(pextent->x1, prect->x);
-            box.y1 = max(pextent->y1, prect->y);
-
-            Right = (int) prect->x + (int) prect->width;
-            box.x2 = min(pextent->x2, Right);
-
-            Bottom = (int) prect->y + (int) prect->height;
-            box.y2 = min(pextent->y2, Bottom);
-
-            prect++;
-
-            if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
-                continue;
-
-            n = RegionNumRects(prgnClip);
-            pbox = RegionRects(prgnClip);
-
-            /* clip the rectangle to each box in the clip region
-               this is logically equivalent to calling Intersect()
-             */
-            while (n--) {
-                pboxClipped->x1 = max(box.x1, pbox->x1);
-                pboxClipped->y1 = max(box.y1, pbox->y1);
-                pboxClipped->x2 = min(box.x2, pbox->x2);
-                pboxClipped->y2 = min(box.y2, pbox->y2);
-                pbox++;
-
-                /* see if clipping left anything */
-                if (pboxClipped->x1 < pboxClipped->x2 &&
-                    pboxClipped->y1 < pboxClipped->y2) {
-                    pboxClipped++;
-                }
-            }
-        }
-    }
-
-    return pboxClipped - pboxClippedBase;
-}