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, 534 insertions, 521 deletions

diff --git a/xorg-server/hw/xfree86/xaa/xaaImage.c b/xorg-server/hw/xfree86/xaa/xaaImage.c
index 1967c5e0e..4457c9efa 100644
--- a/xorg-server/hw/xfree86/xaa/xaaImage.c
+++ b/xorg-server/hw/xfree86/xaa/xaaImage.c
@@ -1,521 +1,534 @@
-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include "misc.h"

-#include "xf86.h"

-#include "xf86_OSproc.h"

-#include "servermd.h"

-

-#include <X11/X.h>

-#include "scrnintstr.h"

-#include "mi.h"

-#include "pixmapstr.h"

-#include "xf86str.h"

-#include "xaa.h"

-#include "xaalocal.h"

-

-void XAAMoveDWORDS_FixedBase(

-   register CARD32* dest,

-   register CARD32* src,

-   register int dwords )

-{

-     while(dwords & ~0x03) {

-	 *dest = *src;

-	 *dest = *(src + 1);

-	 *dest = *(src + 2);

-	 *dest = *(src + 3);	

-	 dwords -= 4;

-	 src += 4;

-     }

-

-     if(!dwords) return;

-     *dest = *src;

-     if(dwords == 1) return;

-     *dest = *(src + 1);

-     if(dwords == 2) return;

-     *dest = *(src + 2);

-}

-

-void XAAMoveDWORDS(

-   register CARD32* dest,

-   register CARD32* src,

-   register int dwords )

-{

-     while(dwords & ~0x03) {

-	*dest = *src;

-	*(dest + 1) = *(src + 1);

-	*(dest + 2) = *(src + 2);

-	*(dest + 3) = *(src + 3);

-	src += 4;

-	dest += 4;

-	dwords -= 4;

-     }	

-     if(!dwords) return;

-     *dest = *src;

-     if(dwords == 1) return;

-     *(dest + 1) = *(src + 1);

-     if(dwords == 2) return;

-     *(dest + 2) = *(src + 2);

-}

-

-void XAAMoveDWORDS_FixedSrc(

-   register CARD32* dest,

-   register CARD32* src,

-   register int dwords )

-{

-     while(dwords & ~0x03) {

-	*dest = *src;

-	*(dest + 1) = *src;

-	*(dest + 2) = *src;

-	*(dest + 3) = *src;

-	dest += 4;

-	dwords -= 4;

-     }	

-     if(!dwords) return;

-     *dest = *src;

-     if(dwords == 1) return;

-     *(dest + 1) = *src;

-     if(dwords == 2) return;

-     *(dest + 2) = *src;

-}

-

-static void

-XAAWritePixmap32To24(

-   ScrnInfoPtr pScrn,

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

-   unsigned char *srcInit,	

-   int srcwidth,	/* bytes */

-   int rop,

-   unsigned int planemask,

-   int trans

-){

-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-    int count, dwords = bytes_to_int32(w * 3);

-    CARD32 *src, *dst;

-    Bool PlusOne = FALSE;

-

-    if((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) && 

-					((dwords * h) & 0x01)) {

-	PlusOne = TRUE;

-    }

-

-    (*infoRec->SetupForImageWrite)(pScrn, rop, planemask, trans, 24, 24);

-    (*infoRec->SubsequentImageWriteRect)(pScrn, x, y, w, h, 0);

-  

-    if(dwords > infoRec->ImageWriteRange) {

-	dst = (CARD32*)infoRec->ImageWriteBase;

-	while(h--) {

-	    src = (CARD32*)srcInit;

-  	    count = w;

-

-	    while(count >= 4) {

-		*dst = (src[0] & 0x00ffffff) | (src[1] << 24);

-		*dst = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);

-		*dst = ((src[2] >> 16) & 0x000000ff) | (src[3] << 8);

-		src += 4;

-		count -= 4;

-	    }

-	    switch(count) {

-	    case 0:	break;

-	    case 1:	*dst = src[0];

-			break;

-	    case 2:	*dst = (src[0] & 0x00ffffff) | (src[1] << 24);

-			*dst = src[1] >> 8;

-			break;

-	    default:	*dst = (src[0] & 0x00ffffff) | (src[1] << 24);

-			*dst = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);

-			*dst = src[2] >> 16;

-			break;

-	    }

-	    srcInit += srcwidth;

-	}

-    } else {

-	while(h--) {

-	    dst = (CARD32*)infoRec->ImageWriteBase;

-	    src = (CARD32*)srcInit;

-  	    count = w;

-

-	    while(count >= 4) {

-		dst[0] = (src[0] & 0x00ffffff) | (src[1] << 24);

-		dst[1] = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);

-		dst[2] = ((src[2] >> 16) & 0x000000ff) | (src[3] << 8);

-		dst += 3;

-		src += 4;

-		count -= 4;

-	    }

-	    switch(count) {

-	    case 0:	break;

-	    case 1:	dst[0] = src[0];

-			break;

-	    case 2:	dst[0] = (src[0] & 0x00ffffff) | (src[1] << 24);

-			dst[1] = src[1] >> 8;

-			break;

-	    default:	dst[0] = (src[0] & 0x00ffffff) | (src[1] << 24);

-			dst[1] = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);

-			dst[2] = src[2] >> 16;

-			break;

-	    }

-	    srcInit += srcwidth;

-	}

-    }

-

-    if(PlusOne) {

-	CARD32* base = (CARD32*)infoRec->ImageWriteBase;

-	*base = 0x00000000;

-    }

-

-    if(infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)

-	(*infoRec->Sync)(pScrn);

-    else SET_SYNC_FLAG(infoRec);

-

-}

-

-void

-XAAWritePixmap (

-   ScrnInfoPtr pScrn,

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

-   unsigned char *src,	

-   int srcwidth,	/* bytes */

-   int rop,

-   unsigned int planemask,

-   int trans,

-   int bpp, int depth

-){

-    XAAInfoRecPtr infoRec;

-    int dwords, skipleft, Bpp; 

-    Bool beCareful, PlusOne;

-

-    if((bpp == 32) && (pScrn->bitsPerPixel == 24)) {

-	XAAWritePixmap32To24(pScrn, x, y, w, h, src, srcwidth, 

-						rop, planemask, trans);	

-	return;

-    }

-

-    infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-    beCareful = PlusOne = FALSE;

-    Bpp = bpp >> 3;

-

-    if((skipleft = (long)src & 0x03L)) {

-	if(!(infoRec->ImageWriteFlags & LEFT_EDGE_CLIPPING)) {

-	   skipleft = 0;

-	   beCareful = TRUE;

-	   goto BAD_ALIGNMENT;

-	}

-

-	if(Bpp == 3)

-	   skipleft = 4 - skipleft;

-	else

-	   skipleft /= Bpp;

-

-	if((x < skipleft) && !(infoRec->ImageWriteFlags &

-				 LEFT_EDGE_CLIPPING_NEGATIVE_X)) {

-	   skipleft = 0;

-	   beCareful = TRUE;

-	   goto BAD_ALIGNMENT;

-	}

-

-	x -= skipleft;	     

-	w += skipleft;

-	

-	if(Bpp == 3)

-	   src -= 3 * skipleft;  

-	else   /* is this Alpha friendly ? */

-	   src = (unsigned char*)((long)src & ~0x03L);     

-    }

-

-BAD_ALIGNMENT:

-

-    dwords = bytes_to_int32(w * Bpp);

-

-    if((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) && 

-						((dwords * h) & 0x01)) {

-	PlusOne = TRUE;

-    } 

-		

-	

-    (*infoRec->SetupForImageWrite)(pScrn, rop, planemask, trans, bpp, depth);

-    (*infoRec->SubsequentImageWriteRect)(pScrn, x, y, w, h, skipleft);

-

-    if(beCareful) {

-	/* in cases with bad alignment we have to be careful not

-	   to read beyond the end of the source */

-	if(((x * Bpp) + (dwords << 2)) > srcwidth) h--;

-	else beCareful = FALSE;

-    }

-

-    if(dwords > infoRec->ImageWriteRange) {

-	while(h--) {

-	    XAAMoveDWORDS_FixedBase((CARD32*)infoRec->ImageWriteBase,

-		(CARD32*)src, dwords);

-	    src += srcwidth;

-	}

-	if(beCareful) {

-	   int shift = ((long)src & 0x03L) << 3;

-	   if(--dwords)

-		XAAMoveDWORDS_FixedBase((CARD32*)infoRec->ImageWriteBase,

-			(CARD32*)src, dwords);

-	   src = (unsigned char*)((long)(src + (dwords << 2)) & ~0x03L);

-	   *((CARD32*)infoRec->ImageWriteBase) = *((CARD32*)src) >> shift;

-	}

-    } else {

-	if(srcwidth == (dwords << 2)) {

-	   int decrement = infoRec->ImageWriteRange/dwords;

-

-	   while(h > decrement) {

-		XAAMoveDWORDS((CARD32*)infoRec->ImageWriteBase,

-	 		(CARD32*)src, dwords * decrement);

-		src += (srcwidth * decrement);

-		h -= decrement;

-	   }

-	   if(h) {

-		XAAMoveDWORDS((CARD32*)infoRec->ImageWriteBase,

-	 		(CARD32*)src, dwords * h);

-		if(beCareful) src += (srcwidth * h);

-	   }

-	} else {

-	    while(h--) {

-		XAAMoveDWORDS((CARD32*)infoRec->ImageWriteBase,

-	 		(CARD32*)src, dwords);

-		src += srcwidth;

-	    }

-	}

-

-	if(beCareful) {

-	    int shift = ((long)src & 0x03L) << 3;

-	    if(--dwords)

-		XAAMoveDWORDS((CARD32*)infoRec->ImageWriteBase,

-					(CARD32*)src, dwords);

-	    src = (unsigned char*)((long)(src + (dwords << 2)) & ~0x03L);

-     

-	    ((CARD32*)infoRec->ImageWriteBase)[dwords] = 

-			*((CARD32*)src) >> shift;

-	}

-    }

-

-    if(PlusOne) {

-	CARD32* base = (CARD32*)infoRec->ImageWriteBase;

-	*base = 0x00000000;

-    }

-

-    if(infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)

-	(*infoRec->Sync)(pScrn);

-    else SET_SYNC_FLAG(infoRec);

-}

-

-

-void

-XAAWritePixmapScanline (

-   ScrnInfoPtr pScrn,

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

-   unsigned char *src,	

-   int srcwidth,	/* bytes */

-   int rop,

-   unsigned int planemask,

-   int trans,

-   int bpp, int depth

-){

-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);

-    int dwords, skipleft, bufferNo = 0, Bpp = bpp >> 3; 

-    Bool beCareful = FALSE;

-    CARD32* base;

-

-    if((skipleft = (long)src & 0x03L)) {

-	if(!(infoRec->ScanlineImageWriteFlags & LEFT_EDGE_CLIPPING)) {

-	   skipleft = 0;

-	   beCareful = TRUE;

-	   goto BAD_ALIGNMENT;

-	}

-

-	if(Bpp == 3)

-	   skipleft = 4 - skipleft;

-	else

-	   skipleft /= Bpp;

-

-	if((x < skipleft) && !(infoRec->ScanlineImageWriteFlags &

-				 LEFT_EDGE_CLIPPING_NEGATIVE_X)) {

-	   skipleft = 0;

-	   beCareful = TRUE;

-	   goto BAD_ALIGNMENT;

-	}

-

-	x -= skipleft;	     

-	w += skipleft;

-	

-	if(Bpp == 3)

-	   src -= 3 * skipleft;  

-	else

-	   src = (unsigned char*)((long)src & ~0x03L);     

-    }

-

-BAD_ALIGNMENT:

-

-    dwords = bytes_to_int32(w * Bpp);

-

-    (*infoRec->SetupForScanlineImageWrite)(

-				pScrn, rop, planemask, trans, bpp, depth);

-    (*infoRec->SubsequentScanlineImageWriteRect)(pScrn, x, y, w, h, skipleft);

-

-    if(beCareful) {

-	/* in cases with bad alignment we have to be careful not

-	   to read beyond the end of the source */

-	if(((x * Bpp) + (dwords << 2)) > srcwidth) h--;

-	else beCareful = FALSE;

-    }

-

-    while(h--) {

-	base = (CARD32*)infoRec->ScanlineImageWriteBuffers[bufferNo];

-	XAAMoveDWORDS(base, (CARD32*)src, dwords);

-	(*infoRec->SubsequentImageWriteScanline)(pScrn, bufferNo++);

-	src += srcwidth;

-	if(bufferNo >= infoRec->NumScanlineImageWriteBuffers)

-	    bufferNo = 0;

-    }

-

-    if(beCareful) {

-	int shift = ((long)src & 0x03L) << 3;

-	base = (CARD32*)infoRec->ScanlineImageWriteBuffers[bufferNo];

-	if(--dwords)

-	    XAAMoveDWORDS(base,(CARD32*)src, dwords);

-	src = (unsigned char*)((long)(src + (dwords << 2)) & ~0x03L);

-     

-	base[dwords] = *((CARD32*)src) >> shift;

-	(*infoRec->SubsequentImageWriteScanline)(pScrn, bufferNo);

-    }

-

-    SET_SYNC_FLAG(infoRec);

-}

-

-

-void

-XAAPutImage(

-    DrawablePtr pDraw,

-    GCPtr       pGC,

-    int         depth, 

-    int 	x, 

-    int		y, 

-    int		w, 

-    int		h,

-    int         leftPad,

-    int         format,

-    char        *pImage

-){

-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

-    int bpp = BitsPerPixel(depth);

-    Bool depthBug = FALSE;

-    if(!w || !h) return;

-

-    if(!RegionNumRects(pGC->pCompositeClip))

-	return;

-

-    depthBug = XAA_DEPTH_BUG(pGC);

-

-    if(((format == ZPixmap) && infoRec->WritePixmap &&

-	     ((pDraw->bitsPerPixel == bpp) ||

-		((pDraw->bitsPerPixel == 24) &&  (bpp == 32) &&

-		(infoRec->WritePixmapFlags & CONVERT_32BPP_TO_24BPP))) &&

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

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

-	     CHECK_PLANEMASK(pGC,infoRec->WritePixmapFlags) &&

-	     CHECK_NO_GXCOPY(pGC,infoRec->WritePixmapFlags)) ||

-       ((format == XYBitmap) && !depthBug && infoRec->WriteBitmap &&

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

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

-	     CHECK_PLANEMASK(pGC,infoRec->WriteBitmapFlags) &&

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

-	     !(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY)) ||

-       ((format == XYPixmap) && !depthBug && infoRec->WriteBitmap &&

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

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

-	     !(infoRec->WriteBitmapFlags & NO_PLANEMASK) &&

-	     !(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY))){

-

-	int MaxBoxes = RegionNumRects(pGC->pCompositeClip);

-	BoxPtr pbox, pClipBoxes;

-	int nboxes, srcx, srcy, srcwidth;

-	xRectangle TheRect;

-

-	TheRect.x = pDraw->x + x;

-	TheRect.y = pDraw->y + y;

-	TheRect.width = w;

-	TheRect.height = h; 

-

-	if(MaxBoxes > (infoRec->PreAllocSize/sizeof(BoxRec))) {

-	    pClipBoxes = malloc(MaxBoxes * sizeof(BoxRec));

-	    if(!pClipBoxes) return;	

-	} else pClipBoxes = (BoxPtr)infoRec->PreAllocMem;

-

-	nboxes = XAAGetRectClipBoxes(pGC, pClipBoxes, 1, &TheRect);

-	pbox = pClipBoxes;

-

-	if(format == XYBitmap) {

-	    srcwidth = BitmapBytePad(leftPad + w);

-	    while(nboxes--) {

-		srcx = pbox->x1 - TheRect.x + leftPad;

-		srcy = pbox->y1 - TheRect.y;

-		(*infoRec->WriteBitmap)(infoRec->pScrn, pbox->x1, pbox->y1, 

-			pbox->x2 - pbox->x1, pbox->y2 - pbox->y1, 

-			(unsigned char*)pImage + 

-				(srcwidth * srcy) + ((srcx >> 5) << 2), 

-			srcwidth, srcx & 31, pGC->fgPixel, pGC->bgPixel,

-	 		pGC->alu, pGC->planemask);

-		pbox++;

-	    }

-        } else if(format == ZPixmap) {

-	    int Bpp = bpp >> 3;

-	    srcwidth = PixmapBytePad(leftPad + w, depth);

-	    while(nboxes--) {

-		srcx = pbox->x1 - TheRect.x + leftPad;

-		srcy = pbox->y1 - TheRect.y;

-		(*infoRec->WritePixmap)(infoRec->pScrn, pbox->x1, pbox->y1, 

-			pbox->x2 - pbox->x1, pbox->y2 - pbox->y1, 

-			(unsigned char*)pImage + 

-				(srcwidth * srcy) + (srcx * Bpp), 

-			srcwidth, pGC->alu, pGC->planemask, -1, 

-			Bpp << 3, depth);

-		pbox++;

-	    }

-	} else { /* XYPixmap */

-	    int depth = pGC->depth;

-	    int numBox, increment;

-	    unsigned long i, mask;

-	    BoxPtr pntBox;

-	    

-	    srcwidth = BitmapBytePad(w + leftPad);

-	    increment = h * srcwidth;

- 	    i = 1 << (depth - 1);

-	    mask = ~0;

-

-	    if((infoRec->pScrn->overlayFlags & OVERLAY_8_32_PLANAR) &&

-							 (pGC->depth == 8)){

-		i = 0x80000000;  mask = 0xff000000;

-	    }

-

-	    for(; i & mask; i >>= 1, pImage += increment) {

-		if(i & pGC->planemask) {

-		    pntBox = pbox;

-		    numBox = nboxes;

-		    while(numBox--) {

-			srcx = pntBox->x1 - TheRect.x + leftPad;

-			srcy = pntBox->y1 - TheRect.y;

-			(*infoRec->WriteBitmap)(infoRec->pScrn, 

-				pntBox->x1, pntBox->y1, 

-				pntBox->x2 - pntBox->x1, 

-				pntBox->y2 - pntBox->y1, 

-				(unsigned char*)pImage + 

-				(srcwidth * srcy) + ((srcx >> 5) << 2), 

-				srcwidth, srcx & 31, ~0, 0, pGC->alu, i);

-			pntBox++;

-	    	    }

-		}

-	    }

-

-	}

-

-	if(pClipBoxes != (BoxPtr)infoRec->PreAllocMem)

-	    free(pClipBoxes);

-    } else 

-	XAAFallbackOps.PutImage(pDraw, pGC, depth, x, y, w, h, leftPad, 

-				format, pImage);

-}

+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include "misc.h"
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "servermd.h"
+
+#include <X11/X.h>
+#include "scrnintstr.h"
+#include "mi.h"
+#include "pixmapstr.h"
+#include "xf86str.h"
+#include "xaa.h"
+#include "xaalocal.h"
+
+void
+XAAMoveDWORDS_FixedBase(register CARD32 *dest,
+                        register CARD32 *src, register int dwords)
+{
+    while (dwords & ~0x03) {
+        *dest = *src;
+        *dest = *(src + 1);
+        *dest = *(src + 2);
+        *dest = *(src + 3);
+        dwords -= 4;
+        src += 4;
+    }
+
+    if (!dwords)
+        return;
+    *dest = *src;
+    if (dwords == 1)
+        return;
+    *dest = *(src + 1);
+    if (dwords == 2)
+        return;
+    *dest = *(src + 2);
+}
+
+void
+XAAMoveDWORDS(register CARD32 *dest, register CARD32 *src, register int dwords)
+{
+    while (dwords & ~0x03) {
+        *dest = *src;
+        *(dest + 1) = *(src + 1);
+        *(dest + 2) = *(src + 2);
+        *(dest + 3) = *(src + 3);
+        src += 4;
+        dest += 4;
+        dwords -= 4;
+    }
+    if (!dwords)
+        return;
+    *dest = *src;
+    if (dwords == 1)
+        return;
+    *(dest + 1) = *(src + 1);
+    if (dwords == 2)
+        return;
+    *(dest + 2) = *(src + 2);
+}
+
+void
+XAAMoveDWORDS_FixedSrc(register CARD32 *dest,
+                       register CARD32 *src, register int dwords)
+{
+    while (dwords & ~0x03) {
+        *dest = *src;
+        *(dest + 1) = *src;
+        *(dest + 2) = *src;
+        *(dest + 3) = *src;
+        dest += 4;
+        dwords -= 4;
+    }
+    if (!dwords)
+        return;
+    *dest = *src;
+    if (dwords == 1)
+        return;
+    *(dest + 1) = *src;
+    if (dwords == 2)
+        return;
+    *(dest + 2) = *src;
+}
+
+static void
+XAAWritePixmap32To24(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned char *srcInit, int srcwidth,       /* bytes */
+                     int rop, unsigned int planemask, int trans)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    int count, dwords = bytes_to_int32(w * 3);
+    CARD32 *src, *dst;
+    Bool PlusOne = FALSE;
+
+    if ((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) &&
+        ((dwords * h) & 0x01)) {
+        PlusOne = TRUE;
+    }
+
+    (*infoRec->SetupForImageWrite) (pScrn, rop, planemask, trans, 24, 24);
+    (*infoRec->SubsequentImageWriteRect) (pScrn, x, y, w, h, 0);
+
+    if (dwords > infoRec->ImageWriteRange) {
+        dst = (CARD32 *) infoRec->ImageWriteBase;
+        while (h--) {
+            src = (CARD32 *) srcInit;
+            count = w;
+
+            while (count >= 4) {
+                *dst = (src[0] & 0x00ffffff) | (src[1] << 24);
+                *dst = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);
+                *dst = ((src[2] >> 16) & 0x000000ff) | (src[3] << 8);
+                src += 4;
+                count -= 4;
+            }
+            switch (count) {
+            case 0:
+                break;
+            case 1:
+                *dst = src[0];
+                break;
+            case 2:
+                *dst = (src[0] & 0x00ffffff) | (src[1] << 24);
+                *dst = src[1] >> 8;
+                break;
+            default:
+                *dst = (src[0] & 0x00ffffff) | (src[1] << 24);
+                *dst = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);
+                *dst = src[2] >> 16;
+                break;
+            }
+            srcInit += srcwidth;
+        }
+    }
+    else {
+        while (h--) {
+            dst = (CARD32 *) infoRec->ImageWriteBase;
+            src = (CARD32 *) srcInit;
+            count = w;
+
+            while (count >= 4) {
+                dst[0] = (src[0] & 0x00ffffff) | (src[1] << 24);
+                dst[1] = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);
+                dst[2] = ((src[2] >> 16) & 0x000000ff) | (src[3] << 8);
+                dst += 3;
+                src += 4;
+                count -= 4;
+            }
+            switch (count) {
+            case 0:
+                break;
+            case 1:
+                dst[0] = src[0];
+                break;
+            case 2:
+                dst[0] = (src[0] & 0x00ffffff) | (src[1] << 24);
+                dst[1] = src[1] >> 8;
+                break;
+            default:
+                dst[0] = (src[0] & 0x00ffffff) | (src[1] << 24);
+                dst[1] = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);
+                dst[2] = src[2] >> 16;
+                break;
+            }
+            srcInit += srcwidth;
+        }
+    }
+
+    if (PlusOne) {
+        CARD32 *base = (CARD32 *) infoRec->ImageWriteBase;
+
+        *base = 0x00000000;
+    }
+
+    if (infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)
+        (*infoRec->Sync) (pScrn);
+    else
+        SET_SYNC_FLAG(infoRec);
+
+}
+
+void
+XAAWritePixmap(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned char *src, int srcwidth, /* bytes */
+               int rop, unsigned int planemask, int trans, int bpp, int depth)
+{
+    XAAInfoRecPtr infoRec;
+    int dwords, skipleft, Bpp;
+    Bool beCareful, PlusOne;
+
+    if ((bpp == 32) && (pScrn->bitsPerPixel == 24)) {
+        XAAWritePixmap32To24(pScrn, x, y, w, h, src, srcwidth,
+                             rop, planemask, trans);
+        return;
+    }
+
+    infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    beCareful = PlusOne = FALSE;
+    Bpp = bpp >> 3;
+
+    if ((skipleft = (long) src & 0x03L)) {
+        if (!(infoRec->ImageWriteFlags & LEFT_EDGE_CLIPPING)) {
+            skipleft = 0;
+            beCareful = TRUE;
+            goto BAD_ALIGNMENT;
+        }
+
+        if (Bpp == 3)
+            skipleft = 4 - skipleft;
+        else
+            skipleft /= Bpp;
+
+        if ((x < skipleft) && !(infoRec->ImageWriteFlags &
+                                LEFT_EDGE_CLIPPING_NEGATIVE_X)) {
+            skipleft = 0;
+            beCareful = TRUE;
+            goto BAD_ALIGNMENT;
+        }
+
+        x -= skipleft;
+        w += skipleft;
+
+        if (Bpp == 3)
+            src -= 3 * skipleft;
+        else                    /* is this Alpha friendly ? */
+            src = (unsigned char *) ((long) src & ~0x03L);
+    }
+
+ BAD_ALIGNMENT:
+
+    dwords = bytes_to_int32(w * Bpp);
+
+    if ((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) &&
+        ((dwords * h) & 0x01)) {
+        PlusOne = TRUE;
+    }
+
+    (*infoRec->SetupForImageWrite) (pScrn, rop, planemask, trans, bpp, depth);
+    (*infoRec->SubsequentImageWriteRect) (pScrn, x, y, w, h, skipleft);
+
+    if (beCareful) {
+        /* in cases with bad alignment we have to be careful not
+           to read beyond the end of the source */
+        if (((x * Bpp) + (dwords << 2)) > srcwidth)
+            h--;
+        else
+            beCareful = FALSE;
+    }
+
+    if (dwords > infoRec->ImageWriteRange) {
+        while (h--) {
+            XAAMoveDWORDS_FixedBase((CARD32 *) infoRec->ImageWriteBase,
+                                    (CARD32 *) src, dwords);
+            src += srcwidth;
+        }
+        if (beCareful) {
+            int shift = ((long) src & 0x03L) << 3;
+
+            if (--dwords)
+                XAAMoveDWORDS_FixedBase((CARD32 *) infoRec->ImageWriteBase,
+                                        (CARD32 *) src, dwords);
+            src = (unsigned char *) ((long) (src + (dwords << 2)) & ~0x03L);
+            *((CARD32 *) infoRec->ImageWriteBase) = *((CARD32 *) src) >> shift;
+        }
+    }
+    else {
+        if (srcwidth == (dwords << 2)) {
+            int decrement = infoRec->ImageWriteRange / dwords;
+
+            while (h > decrement) {
+                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
+                              (CARD32 *) src, dwords * decrement);
+                src += (srcwidth * decrement);
+                h -= decrement;
+            }
+            if (h) {
+                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
+                              (CARD32 *) src, dwords * h);
+                if (beCareful)
+                    src += (srcwidth * h);
+            }
+        }
+        else {
+            while (h--) {
+                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
+                              (CARD32 *) src, dwords);
+                src += srcwidth;
+            }
+        }
+
+        if (beCareful) {
+            int shift = ((long) src & 0x03L) << 3;
+
+            if (--dwords)
+                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
+                              (CARD32 *) src, dwords);
+            src = (unsigned char *) ((long) (src + (dwords << 2)) & ~0x03L);
+
+            ((CARD32 *) infoRec->ImageWriteBase)[dwords] =
+                *((CARD32 *) src) >> shift;
+        }
+    }
+
+    if (PlusOne) {
+        CARD32 *base = (CARD32 *) infoRec->ImageWriteBase;
+
+        *base = 0x00000000;
+    }
+
+    if (infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)
+        (*infoRec->Sync) (pScrn);
+    else
+        SET_SYNC_FLAG(infoRec);
+}
+
+void
+XAAWritePixmapScanline(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned char *src, int srcwidth, /* bytes */
+                       int rop,
+                       unsigned int planemask, int trans, int bpp, int depth)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    int dwords, skipleft, bufferNo = 0, Bpp = bpp >> 3;
+    Bool beCareful = FALSE;
+    CARD32 *base;
+
+    if ((skipleft = (long) src & 0x03L)) {
+        if (!(infoRec->ScanlineImageWriteFlags & LEFT_EDGE_CLIPPING)) {
+            skipleft = 0;
+            beCareful = TRUE;
+            goto BAD_ALIGNMENT;
+        }
+
+        if (Bpp == 3)
+            skipleft = 4 - skipleft;
+        else
+            skipleft /= Bpp;
+
+        if ((x < skipleft) && !(infoRec->ScanlineImageWriteFlags &
+                                LEFT_EDGE_CLIPPING_NEGATIVE_X)) {
+            skipleft = 0;
+            beCareful = TRUE;
+            goto BAD_ALIGNMENT;
+        }
+
+        x -= skipleft;
+        w += skipleft;
+
+        if (Bpp == 3)
+            src -= 3 * skipleft;
+        else
+            src = (unsigned char *) ((long) src & ~0x03L);
+    }
+
+ BAD_ALIGNMENT:
+
+    dwords = bytes_to_int32(w * Bpp);
+
+    (*infoRec->SetupForScanlineImageWrite) (pScrn, rop, planemask, trans, bpp,
+                                            depth);
+    (*infoRec->SubsequentScanlineImageWriteRect) (pScrn, x, y, w, h, skipleft);
+
+    if (beCareful) {
+        /* in cases with bad alignment we have to be careful not
+           to read beyond the end of the source */
+        if (((x * Bpp) + (dwords << 2)) > srcwidth)
+            h--;
+        else
+            beCareful = FALSE;
+    }
+
+    while (h--) {
+        base = (CARD32 *) infoRec->ScanlineImageWriteBuffers[bufferNo];
+        XAAMoveDWORDS(base, (CARD32 *) src, dwords);
+        (*infoRec->SubsequentImageWriteScanline) (pScrn, bufferNo++);
+        src += srcwidth;
+        if (bufferNo >= infoRec->NumScanlineImageWriteBuffers)
+            bufferNo = 0;
+    }
+
+    if (beCareful) {
+        int shift = ((long) src & 0x03L) << 3;
+
+        base = (CARD32 *) infoRec->ScanlineImageWriteBuffers[bufferNo];
+        if (--dwords)
+            XAAMoveDWORDS(base, (CARD32 *) src, dwords);
+        src = (unsigned char *) ((long) (src + (dwords << 2)) & ~0x03L);
+
+        base[dwords] = *((CARD32 *) src) >> shift;
+        (*infoRec->SubsequentImageWriteScanline) (pScrn, bufferNo);
+    }
+
+    SET_SYNC_FLAG(infoRec);
+}
+
+void
+XAAPutImage(DrawablePtr pDraw,
+            GCPtr pGC,
+            int depth,
+            int x, int y, int w, int h, int leftPad, int format, char *pImage)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    int bpp = BitsPerPixel(depth);
+    Bool depthBug = FALSE;
+
+    if (!w || !h)
+        return;
+
+    if (!RegionNumRects(pGC->pCompositeClip))
+        return;
+
+    depthBug = XAA_DEPTH_BUG(pGC);
+
+    if (((format == ZPixmap) && infoRec->WritePixmap &&
+         ((pDraw->bitsPerPixel == bpp) ||
+          ((pDraw->bitsPerPixel == 24) && (bpp == 32) &&
+           (infoRec->WritePixmapFlags & CONVERT_32BPP_TO_24BPP))) &&
+         CHECK_ROP(pGC, infoRec->WritePixmapFlags) &&
+         CHECK_ROPSRC(pGC, infoRec->WritePixmapFlags) &&
+         CHECK_PLANEMASK(pGC, infoRec->WritePixmapFlags) &&
+         CHECK_NO_GXCOPY(pGC, infoRec->WritePixmapFlags)) ||
+        ((format == XYBitmap) && !depthBug && infoRec->WriteBitmap &&
+         CHECK_ROP(pGC, infoRec->WriteBitmapFlags) &&
+         CHECK_ROPSRC(pGC, infoRec->WriteBitmapFlags) &&
+         CHECK_PLANEMASK(pGC, infoRec->WriteBitmapFlags) &&
+         CHECK_COLORS(pGC, infoRec->WriteBitmapFlags) &&
+         !(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY)) ||
+        ((format == XYPixmap) && !depthBug && infoRec->WriteBitmap &&
+         CHECK_ROP(pGC, infoRec->WriteBitmapFlags) &&
+         CHECK_ROPSRC(pGC, infoRec->WriteBitmapFlags) &&
+         !(infoRec->WriteBitmapFlags & NO_PLANEMASK) &&
+         !(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY))) {
+
+        int MaxBoxes = RegionNumRects(pGC->pCompositeClip);
+        BoxPtr pbox, pClipBoxes;
+        int nboxes, srcx, srcy, srcwidth;
+        xRectangle TheRect;
+
+        TheRect.x = pDraw->x + x;
+        TheRect.y = pDraw->y + y;
+        TheRect.width = w;
+        TheRect.height = h;
+
+        if (MaxBoxes > (infoRec->PreAllocSize / sizeof(BoxRec))) {
+            pClipBoxes = malloc(MaxBoxes * sizeof(BoxRec));
+            if (!pClipBoxes)
+                return;
+        }
+        else
+            pClipBoxes = (BoxPtr) infoRec->PreAllocMem;
+
+        nboxes = XAAGetRectClipBoxes(pGC, pClipBoxes, 1, &TheRect);
+        pbox = pClipBoxes;
+
+        if (format == XYBitmap) {
+            srcwidth = BitmapBytePad(leftPad + w);
+            while (nboxes--) {
+                srcx = pbox->x1 - TheRect.x + leftPad;
+                srcy = pbox->y1 - TheRect.y;
+                (*infoRec->WriteBitmap) (infoRec->pScrn, pbox->x1, pbox->y1,
+                                         pbox->x2 - pbox->x1,
+                                         pbox->y2 - pbox->y1,
+                                         (unsigned char *) pImage +
+                                         (srcwidth * srcy) + ((srcx >> 5) << 2),
+                                         srcwidth, srcx & 31, pGC->fgPixel,
+                                         pGC->bgPixel, pGC->alu,
+                                         pGC->planemask);
+                pbox++;
+            }
+        }
+        else if (format == ZPixmap) {
+            int Bpp = bpp >> 3;
+
+            srcwidth = PixmapBytePad(leftPad + w, depth);
+            while (nboxes--) {
+                srcx = pbox->x1 - TheRect.x + leftPad;
+                srcy = pbox->y1 - TheRect.y;
+                (*infoRec->WritePixmap) (infoRec->pScrn, pbox->x1, pbox->y1,
+                                         pbox->x2 - pbox->x1,
+                                         pbox->y2 - pbox->y1,
+                                         (unsigned char *) pImage +
+                                         (srcwidth * srcy) + (srcx * Bpp),
+                                         srcwidth, pGC->alu, pGC->planemask, -1,
+                                         Bpp << 3, depth);
+                pbox++;
+            }
+        }
+        else {                  /* XYPixmap */
+            int depth = pGC->depth;
+            int numBox, increment;
+            unsigned long i, mask;
+            BoxPtr pntBox;
+
+            srcwidth = BitmapBytePad(w + leftPad);
+            increment = h * srcwidth;
+            i = 1 << (depth - 1);
+            mask = ~0;
+
+            if ((infoRec->pScrn->overlayFlags & OVERLAY_8_32_PLANAR) &&
+                (pGC->depth == 8)) {
+                i = 0x80000000;
+                mask = 0xff000000;
+            }
+
+            for (; i & mask; i >>= 1, pImage += increment) {
+                if (i & pGC->planemask) {
+                    pntBox = pbox;
+                    numBox = nboxes;
+                    while (numBox--) {
+                        srcx = pntBox->x1 - TheRect.x + leftPad;
+                        srcy = pntBox->y1 - TheRect.y;
+                        (*infoRec->WriteBitmap) (infoRec->pScrn,
+                                                 pntBox->x1, pntBox->y1,
+                                                 pntBox->x2 - pntBox->x1,
+                                                 pntBox->y2 - pntBox->y1,
+                                                 (unsigned char *) pImage +
+                                                 (srcwidth * srcy) +
+                                                 ((srcx >> 5) << 2), srcwidth,
+                                                 srcx & 31, ~0, 0, pGC->alu, i);
+                        pntBox++;
+                    }
+                }
+            }
+
+        }
+
+        if (pClipBoxes != (BoxPtr) infoRec->PreAllocMem)
+            free(pClipBoxes);
+    }
+    else
+        XAAFallbackOps.PutImage(pDraw, pGC, depth, x, y, w, h, leftPad,
+                                format, pImage);
+}