libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 607 insertions, 765 deletions

diff --git a/xorg-server/fb/fbblt.c b/xorg-server/fb/fbblt.c
index 680940467..17bd6986b 100644
--- a/xorg-server/fb/fbblt.c
+++ b/xorg-server/fb/fbblt.c
@@ -40,47 +40,38 @@
 }
 
 void
-fbBlt (FbBits   *srcLine,
-       FbStride	srcStride,
-       int	srcX,
-       
-       FbBits   *dstLine,
-       FbStride dstStride,
-       int	dstX,
-       
-       int	width, 
-       int	height,
-       
-       int	alu,
-       FbBits	pm,
-       int	bpp,
-       
-       Bool	reverse,
-       Bool	upsidedown)
+fbBlt(FbBits * srcLine,
+      FbStride srcStride,
+      int srcX,
+      FbBits * dstLine,
+      FbStride dstStride,
+      int dstX,
+      int width,
+      int height, int alu, FbBits pm, int bpp, Bool reverse, Bool upsidedown)
 {
-    FbBits  *src, *dst;
-    int	    leftShift, rightShift;
-    FbBits  startmask, endmask;
-    FbBits  bits, bits1;
-    int	    n, nmiddle;
-    Bool    destInvarient;
-    int	    startbyte, endbyte;
-    int     careful;
-    FbDeclareMergeRop ();
-
-    if (bpp == 24 && !FbCheck24Pix (pm))
-    {
-	fbBlt24 (srcLine, srcStride, srcX, dstLine, dstStride, dstX,
-		 width, height, alu, pm, reverse, upsidedown);
-	return;
+    FbBits *src, *dst;
+    int leftShift, rightShift;
+    FbBits startmask, endmask;
+    FbBits bits, bits1;
+    int n, nmiddle;
+    Bool destInvarient;
+    int startbyte, endbyte;
+    int careful;
+
+    FbDeclareMergeRop();
+
+    if (bpp == 24 && !FbCheck24Pix(pm)) {
+        fbBlt24(srcLine, srcStride, srcX, dstLine, dstStride, dstX,
+                width, height, alu, pm, reverse, upsidedown);
+        return;
     }
 
-    careful = !((srcLine < dstLine && srcLine + width * (bpp>>3) > dstLine) ||
-                (dstLine < srcLine && dstLine + width * (bpp>>3) > srcLine)) ||
-              (bpp & 7);
+    careful = !((srcLine < dstLine && srcLine + width * (bpp >> 3) > dstLine) ||
+                (dstLine < srcLine && dstLine + width * (bpp >> 3) > srcLine))
+        || (bpp & 7);
 
     if (alu == GXcopy && pm == FB_ALLONES && !careful &&
-            !(srcX & 7) && !(dstX & 7) && !(width & 7)) {
+        !(srcX & 7) && !(dstX & 7) && !(width & 7)) {
         int i;
         CARD8 *src = (CARD8 *) srcLine;
         CARD8 *dst = (CARD8 *) dstLine;
@@ -103,506 +94,423 @@ fbBlt (FbBits   *srcLine,
 
     FbInitializeMergeRop(alu, pm);
     destInvarient = FbDestInvarientMergeRop();
-    if (upsidedown)
-    {
-	srcLine += (height - 1) * (srcStride);
-	dstLine += (height - 1) * (dstStride);
-	srcStride = -srcStride;
-	dstStride = -dstStride;
+    if (upsidedown) {
+        srcLine += (height - 1) * (srcStride);
+        dstLine += (height - 1) * (dstStride);
+        srcStride = -srcStride;
+        dstStride = -dstStride;
     }
-    FbMaskBitsBytes (dstX, width, destInvarient, startmask, startbyte,
-		     nmiddle, endmask, endbyte);
-    if (reverse)
-    {
-	srcLine += ((srcX + width - 1) >> FB_SHIFT) + 1;
-	dstLine += ((dstX + width - 1) >> FB_SHIFT) + 1;
-	srcX = (srcX + width - 1) & FB_MASK;
-	dstX = (dstX + width - 1) & FB_MASK;
+    FbMaskBitsBytes(dstX, width, destInvarient, startmask, startbyte,
+                    nmiddle, endmask, endbyte);
+    if (reverse) {
+        srcLine += ((srcX + width - 1) >> FB_SHIFT) + 1;
+        dstLine += ((dstX + width - 1) >> FB_SHIFT) + 1;
+        srcX = (srcX + width - 1) & FB_MASK;
+        dstX = (dstX + width - 1) & FB_MASK;
     }
-    else
-    {
-	srcLine += srcX >> FB_SHIFT;
-	dstLine += dstX >> FB_SHIFT;
-	srcX &= FB_MASK;
-	dstX &= FB_MASK;
+    else {
+        srcLine += srcX >> FB_SHIFT;
+        dstLine += dstX >> FB_SHIFT;
+        srcX &= FB_MASK;
+        dstX &= FB_MASK;
     }
-    if (srcX == dstX)
-    {
-	while (height--)
-	{
-	    src = srcLine;
-	    srcLine += srcStride;
-	    dst = dstLine;
-	    dstLine += dstStride;
-	    if (reverse)
-	    {
-		if (endmask)
-		{
-		    bits = READ(--src);
-		    --dst;
-		    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
-		}
-		n = nmiddle;
-		if (destInvarient)
-		{
-		    while (n--)
-			WRITE(--dst, FbDoDestInvarientMergeRop(READ(--src)));
-		}
-		else
-		{
-		    while (n--)
-		    {
-			bits = READ(--src);
-			--dst;
-			WRITE(dst, FbDoMergeRop (bits, READ(dst)));
-		    }
-		}
-		if (startmask)
-		{
-		    bits = READ(--src);
-		    --dst;
-		    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
-		}
-	    }
-	    else
-	    {
-		if (startmask)
-		{
-		    bits = READ(src++);
-		    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
-		    dst++;
-		}
-		n = nmiddle;
-		if (destInvarient)
-		{
+    if (srcX == dstX) {
+        while (height--) {
+            src = srcLine;
+            srcLine += srcStride;
+            dst = dstLine;
+            dstLine += dstStride;
+            if (reverse) {
+                if (endmask) {
+                    bits = READ(--src);
+                    --dst;
+                    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
+                }
+                n = nmiddle;
+                if (destInvarient) {
+                    while (n--)
+                        WRITE(--dst, FbDoDestInvarientMergeRop(READ(--src)));
+                }
+                else {
+                    while (n--) {
+                        bits = READ(--src);
+                        --dst;
+                        WRITE(dst, FbDoMergeRop(bits, READ(dst)));
+                    }
+                }
+                if (startmask) {
+                    bits = READ(--src);
+                    --dst;
+                    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
+                }
+            }
+            else {
+                if (startmask) {
+                    bits = READ(src++);
+                    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
+                    dst++;
+                }
+                n = nmiddle;
+                if (destInvarient) {
 #if 0
-		    /*
-		     * This provides some speedup on screen->screen blts
-		     * over the PCI bus, usually about 10%.  But fb
-		     * isn't usually used for this operation...
-		     */
-		    if (_ca2 + 1 == 0 && _cx2 == 0)
-		    {
-			FbBits	t1, t2, t3, t4;
-			while (n >= 4)
-			{
-			    t1 = *src++;
-			    t2 = *src++;
-			    t3 = *src++;
-			    t4 = *src++;
-			    *dst++ = t1;
-			    *dst++ = t2;
-			    *dst++ = t3;
-			    *dst++ = t4;
-			    n -= 4;
-			}
-		    }
+                    /*
+                     * This provides some speedup on screen->screen blts
+                     * over the PCI bus, usually about 10%.  But fb
+                     * isn't usually used for this operation...
+                     */
+                    if (_ca2 + 1 == 0 && _cx2 == 0) {
+                        FbBits t1, t2, t3, t4;
+
+                        while (n >= 4) {
+                            t1 = *src++;
+                            t2 = *src++;
+                            t3 = *src++;
+                            t4 = *src++;
+                            *dst++ = t1;
+                            *dst++ = t2;
+                            *dst++ = t3;
+                            *dst++ = t4;
+                            n -= 4;
+                        }
+                    }
 #endif
-		    while (n--)
-			WRITE(dst++, FbDoDestInvarientMergeRop(READ(src++)));
-		}
-		else
-		{
-		    while (n--)
-		    {
-			bits = READ(src++);
-			WRITE(dst, FbDoMergeRop (bits, READ(dst)));
-			dst++;
-		    }
-		}
-		if (endmask)
-		{
-		    bits = READ(src);
-		    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
-		}
-	    }
-	}
+                    while (n--)
+                        WRITE(dst++, FbDoDestInvarientMergeRop(READ(src++)));
+                }
+                else {
+                    while (n--) {
+                        bits = READ(src++);
+                        WRITE(dst, FbDoMergeRop(bits, READ(dst)));
+                        dst++;
+                    }
+                }
+                if (endmask) {
+                    bits = READ(src);
+                    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
+                }
+            }
+        }
     }
-    else
-    {
-	if (srcX > dstX)
-	{
-	    leftShift = srcX - dstX;
-	    rightShift = FB_UNIT - leftShift;
-	}
-	else
-	{
-	    rightShift = dstX - srcX;
-	    leftShift = FB_UNIT - rightShift;
-	}
-	while (height--)
-	{
-	    src = srcLine;
-	    srcLine += srcStride;
-	    dst = dstLine;
-	    dstLine += dstStride;
-	    
-	    bits1 = 0;
-	    if (reverse)
-	    {
-		if (srcX < dstX)
-		    bits1 = READ(--src);
-		if (endmask)
-		{
-		    bits = FbScrRight(bits1, rightShift); 
-		    if (FbScrRight(endmask, leftShift))
-		    {
-			bits1 = READ(--src);
-			bits |= FbScrLeft(bits1, leftShift);
-		    }
-		    --dst;
-		    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
-		}
-		n = nmiddle;
-		if (destInvarient)
-		{
-		    while (n--)
-		    {
-			bits = FbScrRight(bits1, rightShift); 
-			bits1 = READ(--src);
-			bits |= FbScrLeft(bits1, leftShift);
-			--dst;
-			WRITE(dst, FbDoDestInvarientMergeRop(bits));
-		    }
-		}
-		else
-		{
-		    while (n--)
-		    {
-			bits = FbScrRight(bits1, rightShift); 
-			bits1 = READ(--src);
-			bits |= FbScrLeft(bits1, leftShift);
-			--dst;
-			WRITE(dst, FbDoMergeRop(bits, READ(dst)));
-		    }
-		}
-		if (startmask)
-		{
-		    bits = FbScrRight(bits1, rightShift); 
-		    if (FbScrRight(startmask, leftShift))
-		    {
-			bits1 = READ(--src);
-			bits |= FbScrLeft(bits1, leftShift);
-		    }
-		    --dst;
-		    FbDoLeftMaskByteMergeRop (dst, bits, startbyte, startmask);
-		}
-	    }
-	    else
-	    {
-		if (srcX > dstX)
-		    bits1 = READ(src++);
-		if (startmask)
-		{
-		    bits = FbScrLeft(bits1, leftShift); 
-		    if (FbScrLeft(startmask, rightShift))
-		    {
-			bits1 = READ(src++);
-			bits |= FbScrRight(bits1, rightShift);
-		    }
-		    FbDoLeftMaskByteMergeRop (dst, bits, startbyte, startmask);
-		    dst++;
-		}
-		n = nmiddle;
-		if (destInvarient)
-		{
-		    while (n--)
-		    {
-			bits = FbScrLeft(bits1, leftShift); 
-			bits1 = READ(src++);
-			bits |= FbScrRight(bits1, rightShift);
-			WRITE(dst, FbDoDestInvarientMergeRop(bits));
-			dst++;
-		    }
-		}
-		else
-		{
-		    while (n--)
-		    {
-			bits = FbScrLeft(bits1, leftShift); 
-			bits1 = READ(src++);
-			bits |= FbScrRight(bits1, rightShift);
-			WRITE(dst, FbDoMergeRop(bits, READ(dst)));
-			dst++;
-		    }
-		}
-		if (endmask)
-		{
-		    bits = FbScrLeft(bits1, leftShift); 
-		    if (FbScrLeft(endmask, rightShift))
-		    {
-			bits1 = READ(src);
-			bits |= FbScrRight(bits1, rightShift);
-		    }
-		    FbDoRightMaskByteMergeRop (dst, bits, endbyte, endmask);
-		}
-	    }
-	}
+    else {
+        if (srcX > dstX) {
+            leftShift = srcX - dstX;
+            rightShift = FB_UNIT - leftShift;
+        }
+        else {
+            rightShift = dstX - srcX;
+            leftShift = FB_UNIT - rightShift;
+        }
+        while (height--) {
+            src = srcLine;
+            srcLine += srcStride;
+            dst = dstLine;
+            dstLine += dstStride;
+
+            bits1 = 0;
+            if (reverse) {
+                if (srcX < dstX)
+                    bits1 = READ(--src);
+                if (endmask) {
+                    bits = FbScrRight(bits1, rightShift);
+                    if (FbScrRight(endmask, leftShift)) {
+                        bits1 = READ(--src);
+                        bits |= FbScrLeft(bits1, leftShift);
+                    }
+                    --dst;
+                    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
+                }
+                n = nmiddle;
+                if (destInvarient) {
+                    while (n--) {
+                        bits = FbScrRight(bits1, rightShift);
+                        bits1 = READ(--src);
+                        bits |= FbScrLeft(bits1, leftShift);
+                        --dst;
+                        WRITE(dst, FbDoDestInvarientMergeRop(bits));
+                    }
+                }
+                else {
+                    while (n--) {
+                        bits = FbScrRight(bits1, rightShift);
+                        bits1 = READ(--src);
+                        bits |= FbScrLeft(bits1, leftShift);
+                        --dst;
+                        WRITE(dst, FbDoMergeRop(bits, READ(dst)));
+                    }
+                }
+                if (startmask) {
+                    bits = FbScrRight(bits1, rightShift);
+                    if (FbScrRight(startmask, leftShift)) {
+                        bits1 = READ(--src);
+                        bits |= FbScrLeft(bits1, leftShift);
+                    }
+                    --dst;
+                    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
+                }
+            }
+            else {
+                if (srcX > dstX)
+                    bits1 = READ(src++);
+                if (startmask) {
+                    bits = FbScrLeft(bits1, leftShift);
+                    if (FbScrLeft(startmask, rightShift)) {
+                        bits1 = READ(src++);
+                        bits |= FbScrRight(bits1, rightShift);
+                    }
+                    FbDoLeftMaskByteMergeRop(dst, bits, startbyte, startmask);
+                    dst++;
+                }
+                n = nmiddle;
+                if (destInvarient) {
+                    while (n--) {
+                        bits = FbScrLeft(bits1, leftShift);
+                        bits1 = READ(src++);
+                        bits |= FbScrRight(bits1, rightShift);
+                        WRITE(dst, FbDoDestInvarientMergeRop(bits));
+                        dst++;
+                    }
+                }
+                else {
+                    while (n--) {
+                        bits = FbScrLeft(bits1, leftShift);
+                        bits1 = READ(src++);
+                        bits |= FbScrRight(bits1, rightShift);
+                        WRITE(dst, FbDoMergeRop(bits, READ(dst)));
+                        dst++;
+                    }
+                }
+                if (endmask) {
+                    bits = FbScrLeft(bits1, leftShift);
+                    if (FbScrLeft(endmask, rightShift)) {
+                        bits1 = READ(src);
+                        bits |= FbScrRight(bits1, rightShift);
+                    }
+                    FbDoRightMaskByteMergeRop(dst, bits, endbyte, endmask);
+                }
+            }
+        }
     }
 }
 
-
 #undef DEBUG_BLT24
 #ifdef DEBUG_BLT24
 
 static unsigned long
-getPixel (char *src, int x)
+getPixel(char *src, int x)
 {
-    unsigned long   l;
+    unsigned long l;
 
     l = 0;
-    memcpy (&l, src + x * 3, 3);
+    memcpy(&l, src + x * 3, 3);
     return l;
 }
 #endif
 
 static void
-fbBlt24Line (FbBits	    *src,
-	     int	    srcX,
-
-	     FbBits	    *dst,
-	     int	    dstX,
-
-	     int	    width,
-
-	     int	    alu,
-	     FbBits	    pm,
-	 
-	     Bool	    reverse)
+fbBlt24Line(FbBits * src,
+            int srcX,
+            FbBits * dst, int dstX, int width, int alu, FbBits pm, Bool reverse)
 {
 #ifdef DEBUG_BLT24
-    char    *origDst = (char *) dst;
-    FbBits  *origLine = dst + ((dstX >> FB_SHIFT) - 1);
-    int	    origNlw = ((width + FB_MASK) >> FB_SHIFT) + 3;
-    int	    origX = dstX / 24;
+    char *origDst = (char *) dst;
+    FbBits *origLine = dst + ((dstX >> FB_SHIFT) - 1);
+    int origNlw = ((width + FB_MASK) >> FB_SHIFT) + 3;
+    int origX = dstX / 24;
 #endif
-    
-    int	    leftShift, rightShift;
-    FbBits  startmask, endmask;
-    int	    n;
-    
-    FbBits  bits, bits1;
-    FbBits  mask;
-
-    int	    rot;
-    FbDeclareMergeRop ();
-    
-    FbInitializeMergeRop (alu, FB_ALLONES);
+
+    int leftShift, rightShift;
+    FbBits startmask, endmask;
+    int n;
+
+    FbBits bits, bits1;
+    FbBits mask;
+
+    int rot;
+
+    FbDeclareMergeRop();
+
+    FbInitializeMergeRop(alu, FB_ALLONES);
     FbMaskBits(dstX, width, startmask, n, endmask);
 #ifdef DEBUG_BLT24
-    ErrorF ("dstX %d width %d reverse %d\n", dstX, width, reverse);
+    ErrorF("dstX %d width %d reverse %d\n", dstX, width, reverse);
 #endif
-    if (reverse)
-    {
-	src += ((srcX + width - 1) >> FB_SHIFT) + 1;
-	dst += ((dstX + width - 1) >> FB_SHIFT) + 1;
-	rot = FbFirst24Rot (((dstX + width - 8) & FB_MASK));
-	rot = FbPrev24Rot(rot);
+    if (reverse) {
+        src += ((srcX + width - 1) >> FB_SHIFT) + 1;
+        dst += ((dstX + width - 1) >> FB_SHIFT) + 1;
+        rot = FbFirst24Rot(((dstX + width - 8) & FB_MASK));
+        rot = FbPrev24Rot(rot);
 #ifdef DEBUG_BLT24
-	ErrorF ("dstX + width - 8: %d rot: %d\n", (dstX + width - 8) & FB_MASK, rot);
+        ErrorF("dstX + width - 8: %d rot: %d\n", (dstX + width - 8) & FB_MASK,
+               rot);
 #endif
-	srcX = (srcX + width - 1) & FB_MASK;
-	dstX = (dstX + width - 1) & FB_MASK;
+        srcX = (srcX + width - 1) & FB_MASK;
+        dstX = (dstX + width - 1) & FB_MASK;
     }
-    else
-    {
-	src += srcX >> FB_SHIFT;
-	dst += dstX >> FB_SHIFT;
-	srcX &= FB_MASK;
-	dstX &= FB_MASK;
-	rot = FbFirst24Rot (dstX);
+    else {
+        src += srcX >> FB_SHIFT;
+        dst += dstX >> FB_SHIFT;
+        srcX &= FB_MASK;
+        dstX &= FB_MASK;
+        rot = FbFirst24Rot(dstX);
 #ifdef DEBUG_BLT24
-	ErrorF ("dstX: %d rot: %d\n", dstX, rot);
+        ErrorF("dstX: %d rot: %d\n", dstX, rot);
 #endif
     }
-    mask = FbRot24(pm,rot);
+    mask = FbRot24(pm, rot);
 #ifdef DEBUG_BLT24
-    ErrorF ("pm 0x%x mask 0x%x\n", pm, mask);
+    ErrorF("pm 0x%x mask 0x%x\n", pm, mask);
 #endif
-    if (srcX == dstX)
-    {
-	if (reverse)
-	{
-	    if (endmask)
-	    {
-		bits = READ(--src);
-		--dst;
-		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & endmask));
-		mask = FbPrev24Pix (mask);
-	    }
-	    while (n--)
-	    {
-		bits = READ(--src);
-		--dst;
-		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask));
-		mask = FbPrev24Pix (mask);
-	    }
-	    if (startmask)
-	    {
-		bits = READ(--src);
-		--dst;
-		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & startmask));
-	    }
-	}
-	else
-	{
-	    if (startmask)
-	    {
-		bits = READ(src++);
-		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & startmask));
-		dst++;
-		mask = FbNext24Pix(mask);
-	    }
-	    while (n--)
-	    {
-		bits = READ(src++);
-		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask));
-		dst++;
-		mask = FbNext24Pix(mask);
-	    }
-	    if (endmask)
-	    {
-		bits = READ(src);
-		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & endmask));
-	    }
-	}
+    if (srcX == dstX) {
+        if (reverse) {
+            if (endmask) {
+                bits = READ(--src);
+                --dst;
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & endmask));
+                mask = FbPrev24Pix(mask);
+            }
+            while (n--) {
+                bits = READ(--src);
+                --dst;
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask));
+                mask = FbPrev24Pix(mask);
+            }
+            if (startmask) {
+                bits = READ(--src);
+                --dst;
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & startmask));
+            }
+        }
+        else {
+            if (startmask) {
+                bits = READ(src++);
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & startmask));
+                dst++;
+                mask = FbNext24Pix(mask);
+            }
+            while (n--) {
+                bits = READ(src++);
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask));
+                dst++;
+                mask = FbNext24Pix(mask);
+            }
+            if (endmask) {
+                bits = READ(src);
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & endmask));
+            }
+        }
     }
-    else
-    {
-	if (srcX > dstX)
-	{
-	    leftShift = srcX - dstX;
-	    rightShift = FB_UNIT - leftShift;
-	}
-	else
-	{
-	    rightShift = dstX - srcX;
-	    leftShift = FB_UNIT - rightShift;
-	}
-	
-	bits1 = 0;
-	if (reverse)
-	{
-	    if (srcX < dstX)
-		bits1 = READ(--src);
-	    if (endmask)
-	    {
-		bits = FbScrRight(bits1, rightShift); 
-		if (FbScrRight(endmask, leftShift))
-		{
-		    bits1 = READ(--src);
-		    bits |= FbScrLeft(bits1, leftShift);
-		}
-		--dst;
-		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & endmask));
-		mask = FbPrev24Pix(mask);
-	    }
-	    while (n--)
-	    {
-		bits = FbScrRight(bits1, rightShift); 
-		bits1 = READ(--src);
-		bits |= FbScrLeft(bits1, leftShift);
-		--dst;
-		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask));
-		mask = FbPrev24Pix(mask);
-	    }
-	    if (startmask)
-	    {
-		bits = FbScrRight(bits1, rightShift); 
-		if (FbScrRight(startmask, leftShift))
-		{
-		    bits1 = READ(--src);
-		    bits |= FbScrLeft(bits1, leftShift);
-		}
-		--dst;
-		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & startmask));
-	    }
-	}
-	else
-	{
-	    if (srcX > dstX)
-		bits1 = READ(src++);
-	    if (startmask)
-	    {
-		bits = FbScrLeft(bits1, leftShift); 
-		bits1 = READ(src++);
-		bits |= FbScrRight(bits1, rightShift);
-		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & startmask));
-		dst++;
-		mask = FbNext24Pix(mask);
-	    }
-	    while (n--)
-	    {
-		bits = FbScrLeft(bits1, leftShift); 
-		bits1 = READ(src++);
-		bits |= FbScrRight(bits1, rightShift);
-		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask));
-		dst++;
-		mask = FbNext24Pix(mask);
-	    }
-	    if (endmask)
-	    {
-		bits = FbScrLeft(bits1, leftShift); 
-		if (FbScrLeft(endmask, rightShift))
-		{
-		    bits1 = READ(src);
-		    bits |= FbScrRight(bits1, rightShift);
-		}
-		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), mask & endmask));
-	    }
-	}
+    else {
+        if (srcX > dstX) {
+            leftShift = srcX - dstX;
+            rightShift = FB_UNIT - leftShift;
+        }
+        else {
+            rightShift = dstX - srcX;
+            leftShift = FB_UNIT - rightShift;
+        }
+
+        bits1 = 0;
+        if (reverse) {
+            if (srcX < dstX)
+                bits1 = READ(--src);
+            if (endmask) {
+                bits = FbScrRight(bits1, rightShift);
+                if (FbScrRight(endmask, leftShift)) {
+                    bits1 = READ(--src);
+                    bits |= FbScrLeft(bits1, leftShift);
+                }
+                --dst;
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & endmask));
+                mask = FbPrev24Pix(mask);
+            }
+            while (n--) {
+                bits = FbScrRight(bits1, rightShift);
+                bits1 = READ(--src);
+                bits |= FbScrLeft(bits1, leftShift);
+                --dst;
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask));
+                mask = FbPrev24Pix(mask);
+            }
+            if (startmask) {
+                bits = FbScrRight(bits1, rightShift);
+                if (FbScrRight(startmask, leftShift)) {
+                    bits1 = READ(--src);
+                    bits |= FbScrLeft(bits1, leftShift);
+                }
+                --dst;
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & startmask));
+            }
+        }
+        else {
+            if (srcX > dstX)
+                bits1 = READ(src++);
+            if (startmask) {
+                bits = FbScrLeft(bits1, leftShift);
+                bits1 = READ(src++);
+                bits |= FbScrRight(bits1, rightShift);
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & startmask));
+                dst++;
+                mask = FbNext24Pix(mask);
+            }
+            while (n--) {
+                bits = FbScrLeft(bits1, leftShift);
+                bits1 = READ(src++);
+                bits |= FbScrRight(bits1, rightShift);
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask));
+                dst++;
+                mask = FbNext24Pix(mask);
+            }
+            if (endmask) {
+                bits = FbScrLeft(bits1, leftShift);
+                if (FbScrLeft(endmask, rightShift)) {
+                    bits1 = READ(src);
+                    bits |= FbScrRight(bits1, rightShift);
+                }
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), mask & endmask));
+            }
+        }
     }
 #ifdef DEBUG_BLT24
     {
-	int firstx, lastx, x;
-
-	firstx = origX;
-	if (firstx)
-	    firstx--;
-	lastx = origX + width/24 + 1;
-	for (x = firstx; x <= lastx; x++)
-	    ErrorF ("%06x ", getPixel (origDst, x));
-	ErrorF ("\n");
-	while (origNlw--)
-	    ErrorF ("%08x ", *origLine++);
-	ErrorF ("\n");
+        int firstx, lastx, x;
+
+        firstx = origX;
+        if (firstx)
+            firstx--;
+        lastx = origX + width / 24 + 1;
+        for (x = firstx; x <= lastx; x++)
+            ErrorF("%06x ", getPixel(origDst, x));
+        ErrorF("\n");
+        while (origNlw--)
+            ErrorF("%08x ", *origLine++);
+        ErrorF("\n");
     }
 #endif
 }
 
 void
-fbBlt24 (FbBits	    *srcLine,
-	 FbStride   srcStride,
-	 int	    srcX,
-
-	 FbBits	    *dstLine,
-	 FbStride   dstStride,
-	 int	    dstX,
-
-	 int	    width, 
-	 int	    height,
-
-	 int	    alu,
-	 FbBits	    pm,
-
-	 Bool	    reverse,
-	 Bool	    upsidedown)
+fbBlt24(FbBits * srcLine,
+        FbStride srcStride,
+        int srcX,
+        FbBits * dstLine,
+        FbStride dstStride,
+        int dstX,
+        int width,
+        int height, int alu, FbBits pm, Bool reverse, Bool upsidedown)
 {
-    if (upsidedown)
-    {
-	srcLine += (height-1) * srcStride;
-	dstLine += (height-1) * dstStride;
-	srcStride = -srcStride;
-	dstStride = -dstStride;
+    if (upsidedown) {
+        srcLine += (height - 1) * srcStride;
+        dstLine += (height - 1) * dstStride;
+        srcStride = -srcStride;
+        dstStride = -dstStride;
     }
-    while (height--)
-    {
-	fbBlt24Line (srcLine, srcX, dstLine, dstX, width, alu, pm, reverse);
-	srcLine += srcStride;
-	dstLine += dstStride;
+    while (height--) {
+        fbBlt24Line(srcLine, srcX, dstLine, dstX, width, alu, pm, reverse);
+        srcLine += srcStride;
+        dstLine += dstStride;
     }
 #ifdef DEBUG_BLT24
-    ErrorF ("\n");
+    ErrorF("\n");
 #endif
 }
 
@@ -614,49 +522,42 @@ fbBlt24 (FbBits	    *srcLine,
  */
 
 void
-fbBltOdd (FbBits    *srcLine,
-	  FbStride  srcStrideEven,
-	  FbStride  srcStrideOdd,
-	  int	    srcXEven,
-	  int	    srcXOdd,
-
-	  FbBits    *dstLine,
-	  FbStride  dstStrideEven,
-	  FbStride  dstStrideOdd,
-	  int	    dstXEven,
-	  int	    dstXOdd,
-
-	  int	    width,
-	  int	    height,
-
-	  int	    alu,
-	  FbBits    pm,
-	  int	    bpp)
+fbBltOdd(FbBits * srcLine,
+         FbStride srcStrideEven,
+         FbStride srcStrideOdd,
+         int srcXEven,
+         int srcXOdd,
+         FbBits * dstLine,
+         FbStride dstStrideEven,
+         FbStride dstStrideOdd,
+         int dstXEven,
+         int dstXOdd, int width, int height, int alu, FbBits pm, int bpp)
 {
-    FbBits  *src;
-    int	    leftShiftEven, rightShiftEven;
-    FbBits  startmaskEven, endmaskEven;
-    int	    nmiddleEven;
-    
-    FbBits  *dst;
-    int	    leftShiftOdd, rightShiftOdd;
-    FbBits  startmaskOdd, endmaskOdd;
-    int	    nmiddleOdd;
-
-    int	    leftShift, rightShift;
-    FbBits  startmask, endmask;
-    int	    nmiddle;
-    
-    int	    srcX, dstX;
-    
-    FbBits  bits, bits1;
-    int	    n;
-    
-    Bool    destInvarient;
-    Bool    even;
-    FbDeclareMergeRop ();
-
-    FbInitializeMergeRop (alu, pm);
+    FbBits *src;
+    int leftShiftEven, rightShiftEven;
+    FbBits startmaskEven, endmaskEven;
+    int nmiddleEven;
+
+    FbBits *dst;
+    int leftShiftOdd, rightShiftOdd;
+    FbBits startmaskOdd, endmaskOdd;
+    int nmiddleOdd;
+
+    int leftShift, rightShift;
+    FbBits startmask, endmask;
+    int nmiddle;
+
+    int srcX, dstX;
+
+    FbBits bits, bits1;
+    int n;
+
+    Bool destInvarient;
+    Bool even;
+
+    FbDeclareMergeRop();
+
+    FbInitializeMergeRop(alu, pm);
     destInvarient = FbDestInvarientMergeRop();
 
     srcLine += srcXEven >> FB_SHIFT;
@@ -668,162 +569,133 @@ fbBltOdd (FbBits    *srcLine,
 
     FbMaskBits(dstXEven, width, startmaskEven, nmiddleEven, endmaskEven);
     FbMaskBits(dstXOdd, width, startmaskOdd, nmiddleOdd, endmaskOdd);
-    
+
     even = TRUE;
     InitializeShifts(srcXEven, dstXEven, leftShiftEven, rightShiftEven);
     InitializeShifts(srcXOdd, dstXOdd, leftShiftOdd, rightShiftOdd);
-    while (height--)
-    {
-	src = srcLine;
-	dst = dstLine;
-	if (even)
-	{
-	    srcX = srcXEven;
-	    dstX = dstXEven;
-	    startmask = startmaskEven;
-	    endmask = endmaskEven;
-	    nmiddle = nmiddleEven;
-	    leftShift = leftShiftEven;
-	    rightShift = rightShiftEven;
-	    srcLine += srcStrideEven;
-	    dstLine += dstStrideEven;
-	    even = FALSE;
-	}
-	else
-	{
-	    srcX = srcXOdd;
-	    dstX = dstXOdd;
-	    startmask = startmaskOdd;
-	    endmask = endmaskOdd;
-	    nmiddle = nmiddleOdd;
-	    leftShift = leftShiftOdd;
-	    rightShift = rightShiftOdd;
-	    srcLine += srcStrideOdd;
-	    dstLine += dstStrideOdd;
-	    even = TRUE;
-	}
-	if (srcX == dstX)
-	{
-	    if (startmask)
-	    {
-		bits = READ(src++);
-		WRITE(dst, FbDoMaskMergeRop (bits, READ(dst), startmask));
-		dst++;
-	    }
-	    n = nmiddle;
-	    if (destInvarient)
-	    {
-		while (n--)
-		{
-		    bits = READ(src++);
-		    WRITE(dst, FbDoDestInvarientMergeRop(bits));
-		    dst++;
-		}
-	    }
-	    else
-	    {
-		while (n--)
-		{
-		    bits = READ(src++);
-		    WRITE(dst, FbDoMergeRop (bits, READ(dst)));
-		    dst++;
-		}
-	    }
-	    if (endmask)
-	    {
-		bits = READ(src);
-		WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), endmask));
-	    }
-	}
-	else
-	{
-	    bits = 0;
-	    if (srcX > dstX)
-		bits = READ(src++);
-	    if (startmask)
-	    {
-		bits1 = FbScrLeft(bits, leftShift);
-		bits = READ(src++);
-		bits1 |= FbScrRight(bits, rightShift);
-		WRITE(dst, FbDoMaskMergeRop (bits1, READ(dst), startmask));
-		dst++;
-	    }
-	    n = nmiddle;
-	    if (destInvarient)
-	    {
-		while (n--)
-		{
-		    bits1 = FbScrLeft(bits, leftShift);
-		    bits = READ(src++);
-		    bits1 |= FbScrRight(bits, rightShift);
-		    WRITE(dst, FbDoDestInvarientMergeRop(bits1));
-		    dst++;
-		}
-	    }
-	    else
-	    {
-		while (n--)
-		{
-		    bits1 = FbScrLeft(bits, leftShift);
-		    bits = READ(src++);
-		    bits1 |= FbScrRight(bits, rightShift);
-		    WRITE(dst, FbDoMergeRop(bits1, READ(dst)));
-		    dst++;
-		}
-	    }
-	    if (endmask)
-	    {
-		bits1 = FbScrLeft(bits, leftShift);
-		if (FbScrLeft(endmask, rightShift))
-		{
-		    bits = READ(src);
-		    bits1 |= FbScrRight(bits, rightShift);
-		}
-		WRITE(dst, FbDoMaskMergeRop (bits1, READ(dst), endmask));
-	    }
-	}
+    while (height--) {
+        src = srcLine;
+        dst = dstLine;
+        if (even) {
+            srcX = srcXEven;
+            dstX = dstXEven;
+            startmask = startmaskEven;
+            endmask = endmaskEven;
+            nmiddle = nmiddleEven;
+            leftShift = leftShiftEven;
+            rightShift = rightShiftEven;
+            srcLine += srcStrideEven;
+            dstLine += dstStrideEven;
+            even = FALSE;
+        }
+        else {
+            srcX = srcXOdd;
+            dstX = dstXOdd;
+            startmask = startmaskOdd;
+            endmask = endmaskOdd;
+            nmiddle = nmiddleOdd;
+            leftShift = leftShiftOdd;
+            rightShift = rightShiftOdd;
+            srcLine += srcStrideOdd;
+            dstLine += dstStrideOdd;
+            even = TRUE;
+        }
+        if (srcX == dstX) {
+            if (startmask) {
+                bits = READ(src++);
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), startmask));
+                dst++;
+            }
+            n = nmiddle;
+            if (destInvarient) {
+                while (n--) {
+                    bits = READ(src++);
+                    WRITE(dst, FbDoDestInvarientMergeRop(bits));
+                    dst++;
+                }
+            }
+            else {
+                while (n--) {
+                    bits = READ(src++);
+                    WRITE(dst, FbDoMergeRop(bits, READ(dst)));
+                    dst++;
+                }
+            }
+            if (endmask) {
+                bits = READ(src);
+                WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), endmask));
+            }
+        }
+        else {
+            bits = 0;
+            if (srcX > dstX)
+                bits = READ(src++);
+            if (startmask) {
+                bits1 = FbScrLeft(bits, leftShift);
+                bits = READ(src++);
+                bits1 |= FbScrRight(bits, rightShift);
+                WRITE(dst, FbDoMaskMergeRop(bits1, READ(dst), startmask));
+                dst++;
+            }
+            n = nmiddle;
+            if (destInvarient) {
+                while (n--) {
+                    bits1 = FbScrLeft(bits, leftShift);
+                    bits = READ(src++);
+                    bits1 |= FbScrRight(bits, rightShift);
+                    WRITE(dst, FbDoDestInvarientMergeRop(bits1));
+                    dst++;
+                }
+            }
+            else {
+                while (n--) {
+                    bits1 = FbScrLeft(bits, leftShift);
+                    bits = READ(src++);
+                    bits1 |= FbScrRight(bits, rightShift);
+                    WRITE(dst, FbDoMergeRop(bits1, READ(dst)));
+                    dst++;
+                }
+            }
+            if (endmask) {
+                bits1 = FbScrLeft(bits, leftShift);
+                if (FbScrLeft(endmask, rightShift)) {
+                    bits = READ(src);
+                    bits1 |= FbScrRight(bits, rightShift);
+                }
+                WRITE(dst, FbDoMaskMergeRop(bits1, READ(dst), endmask));
+            }
+        }
     }
 }
 
 void
-fbBltOdd24 (FbBits	*srcLine,
-	    FbStride	srcStrideEven,
-	    FbStride	srcStrideOdd,
-	    int		srcXEven,
-	    int		srcXOdd,
-
-	    FbBits	*dstLine,
-	    FbStride	dstStrideEven,
-	    FbStride	dstStrideOdd,
-	    int		dstXEven,
-	    int		dstXOdd,
-
-	    int		width,
-	    int		height,
-
-	    int		alu,
-	    FbBits	pm)
+fbBltOdd24(FbBits * srcLine,
+           FbStride srcStrideEven,
+           FbStride srcStrideOdd,
+           int srcXEven,
+           int srcXOdd,
+           FbBits * dstLine,
+           FbStride dstStrideEven,
+           FbStride dstStrideOdd,
+           int dstXEven, int dstXOdd, int width, int height, int alu, FbBits pm)
 {
-    Bool    even = TRUE;
-    
-    while (height--)
-    {
-	if (even)
-	{
-	    fbBlt24Line (srcLine, srcXEven, dstLine, dstXEven,
-			 width, alu, pm, FALSE);
-	    srcLine += srcStrideEven;
-	    dstLine += dstStrideEven;
-	    even = FALSE;
-	}
-	else
-	{
-	    fbBlt24Line (srcLine, srcXOdd, dstLine, dstXOdd,
-			 width, alu, pm, FALSE);
-	    srcLine += srcStrideOdd;
-	    dstLine += dstStrideOdd;
-	    even = TRUE;
-	}
+    Bool even = TRUE;
+
+    while (height--) {
+        if (even) {
+            fbBlt24Line(srcLine, srcXEven, dstLine, dstXEven,
+                        width, alu, pm, FALSE);
+            srcLine += srcStrideEven;
+            dstLine += dstStrideEven;
+            even = FALSE;
+        }
+        else {
+            fbBlt24Line(srcLine, srcXOdd, dstLine, dstXOdd,
+                        width, alu, pm, FALSE);
+            srcLine += srcStrideOdd;
+            dstLine += dstStrideOdd;
+            even = TRUE;
+        }
     }
 }
 
@@ -831,17 +703,15 @@ fbBltOdd24 (FbBits	*srcLine,
 
 #if FB_STIP_SHIFT != FB_SHIFT
 void
-fbSetBltOdd (FbStip	*stip,
-	     FbStride	stipStride,
-	     int	srcX,
-	     FbBits	**bits,
-	     FbStride	*strideEven,
-	     FbStride	*strideOdd,
-	     int	*srcXEven,
-	     int	*srcXOdd)
+fbSetBltOdd(FbStip * stip,
+            FbStride stipStride,
+            int srcX,
+            FbBits ** bits,
+            FbStride * strideEven,
+            FbStride * strideOdd, int *srcXEven, int *srcXOdd)
 {
-    int	    srcAdjust;
-    int	    strideAdjust;
+    int srcAdjust;
+    int strideAdjust;
 
     /*
      * bytes needed to align source
@@ -853,96 +723,68 @@ fbSetBltOdd (FbStip	*stip,
     strideAdjust = stipStride & (FB_MASK >> FB_STIP_SHIFT);
 
     *bits = (FbBits *) ((char *) stip - srcAdjust);
-    if (srcAdjust)
-    {
-	*strideEven = FbStipStrideToBitsStride (stipStride + 1);
-	*strideOdd = FbStipStrideToBitsStride (stipStride);
+    if (srcAdjust) {
+        *strideEven = FbStipStrideToBitsStride(stipStride + 1);
+        *strideOdd = FbStipStrideToBitsStride(stipStride);
 
-	*srcXEven = srcX + (srcAdjust << 3);
-	*srcXOdd = srcX + (srcAdjust << 3) - (strideAdjust << FB_STIP_SHIFT);
+        *srcXEven = srcX + (srcAdjust << 3);
+        *srcXOdd = srcX + (srcAdjust << 3) - (strideAdjust << FB_STIP_SHIFT);
     }
-    else
-    {
-	*strideEven = FbStipStrideToBitsStride (stipStride);
-	*strideOdd = FbStipStrideToBitsStride (stipStride + 1);
-	
-	*srcXEven = srcX;
-	*srcXOdd = srcX + (strideAdjust << FB_STIP_SHIFT);
+    else {
+        *strideEven = FbStipStrideToBitsStride(stipStride);
+        *strideOdd = FbStipStrideToBitsStride(stipStride + 1);
+
+        *srcXEven = srcX;
+        *srcXOdd = srcX + (strideAdjust << FB_STIP_SHIFT);
     }
 }
 #endif
 
 void
-fbBltStip (FbStip   *src,
-	   FbStride srcStride,	    /* in FbStip units, not FbBits units */
-	   int	    srcX,
-	   
-	   FbStip   *dst,
-	   FbStride dstStride,	    /* in FbStip units, not FbBits units */
-	   int	    dstX,
-
-	   int	    width, 
-	   int	    height,
-
-	   int	    alu,
-	   FbBits   pm,
-	   int	    bpp)
+fbBltStip(FbStip * src, FbStride srcStride,     /* in FbStip units, not FbBits units */
+          int srcX, FbStip * dst, FbStride dstStride,   /* in FbStip units, not FbBits units */
+          int dstX, int width, int height, int alu, FbBits pm, int bpp)
 {
 #if FB_STIP_SHIFT != FB_SHIFT
     if (FB_STIP_ODDSTRIDE(srcStride) || FB_STIP_ODDPTR(src) ||
-	FB_STIP_ODDSTRIDE(dstStride) || FB_STIP_ODDPTR(dst))
-    {
-	FbStride    srcStrideEven, srcStrideOdd;
-	FbStride    dstStrideEven, dstStrideOdd;
-	int	    srcXEven, srcXOdd;
-	int	    dstXEven, dstXOdd;
-	FbBits	    *s, *d;
-	int	    sx, dx;
-	
-	src += srcX >> FB_STIP_SHIFT;
-	srcX &= FB_STIP_MASK;
-	dst += dstX >> FB_STIP_SHIFT;
-	dstX &= FB_STIP_MASK;
-	
-	fbSetBltOdd (src, srcStride, srcX,
-		     &s,
-		     &srcStrideEven, &srcStrideOdd,
-		     &srcXEven, &srcXOdd);
-		     
-	fbSetBltOdd (dst, dstStride, dstX,
-		     &d,
-		     &dstStrideEven, &dstStrideOdd,
-		     &dstXEven, &dstXOdd);
-		     
-	if (bpp == 24 && !FbCheck24Pix (pm))
-	{
-	    fbBltOdd24  (s, srcStrideEven, srcStrideOdd,
-			 srcXEven, srcXOdd,
-
-			 d, dstStrideEven, dstStrideOdd,
-			 dstXEven, dstXOdd,
-
-			 width, height, alu, pm);
-	}
-	else
-	{
-	    fbBltOdd (s, srcStrideEven, srcStrideOdd,
-		      srcXEven, srcXOdd,
-    
-		      d, dstStrideEven, dstStrideOdd,
-		      dstXEven, dstXOdd,
-    
-		      width, height, alu, pm, bpp);
-	}
+        FB_STIP_ODDSTRIDE(dstStride) || FB_STIP_ODDPTR(dst)) {
+        FbStride srcStrideEven, srcStrideOdd;
+        FbStride dstStrideEven, dstStrideOdd;
+        int srcXEven, srcXOdd;
+        int dstXEven, dstXOdd;
+        FbBits *s, *d;
+        int sx, dx;
+
+        src += srcX >> FB_STIP_SHIFT;
+        srcX &= FB_STIP_MASK;
+        dst += dstX >> FB_STIP_SHIFT;
+        dstX &= FB_STIP_MASK;
+
+        fbSetBltOdd(src, srcStride, srcX,
+                    &s, &srcStrideEven, &srcStrideOdd, &srcXEven, &srcXOdd);
+
+        fbSetBltOdd(dst, dstStride, dstX,
+                    &d, &dstStrideEven, &dstStrideOdd, &dstXEven, &dstXOdd);
+
+        if (bpp == 24 && !FbCheck24Pix(pm)) {
+            fbBltOdd24(s, srcStrideEven, srcStrideOdd,
+                       srcXEven, srcXOdd,
+                       d, dstStrideEven, dstStrideOdd,
+                       dstXEven, dstXOdd, width, height, alu, pm);
+        }
+        else {
+            fbBltOdd(s, srcStrideEven, srcStrideOdd,
+                     srcXEven, srcXOdd,
+                     d, dstStrideEven, dstStrideOdd,
+                     dstXEven, dstXOdd, width, height, alu, pm, bpp);
+        }
     }
     else
 #endif
     {
-	fbBlt ((FbBits *) src, FbStipStrideToBitsStride (srcStride), 
-	       srcX, 
-	       (FbBits *) dst, FbStipStrideToBitsStride (dstStride), 
-	       dstX, 
-	       width, height,
-	       alu, pm, bpp, FALSE, FALSE);
+        fbBlt((FbBits *) src, FbStipStrideToBitsStride(srcStride),
+              srcX,
+              (FbBits *) dst, FbStipStrideToBitsStride(dstStride),
+              dstX, width, height, alu, pm, bpp, FALSE, FALSE);
     }
 }