Synchronised line endinge with release branch

1 files changed, 862 insertions, 862 deletions

diff --git a/xorg-server/fb/fbbltone.c b/xorg-server/fb/fbbltone.c
index e429b1b35..67e7853c6 100644
--- a/xorg-server/fb/fbbltone.c
+++ b/xorg-server/fb/fbbltone.c
@@ -1,862 +1,862 @@
-/*

- * Copyright © 1998 Keith Packard

- *

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

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

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

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of Keith Packard not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  Keith Packard makes no

- * representations about the suitability of this software for any purpose.  It

- * is provided "as is" without express or implied warranty.

- *

- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR

- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

- * PERFORMANCE OF THIS SOFTWARE.

- */

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include "fb.h"

-

-#ifdef __clang__

-/* shift overflow is intentional */

-#pragma clang diagnostic ignored "-Wshift-overflow"

-#endif

-

-/*

- *  Example: srcX = 13 dstX = 8	(FB unit 32 dstBpp 8)

- *

- *	**** **** **** **** **** **** **** ****

- *			^

- *	********  ********  ********  ********

- *		  ^

- *  leftShift = 12

- *  rightShift = 20

- *

- *  Example: srcX = 0 dstX = 8 (FB unit 32 dstBpp 8)

- *

- *	**** **** **** **** **** **** **** ****

- *	^		

- *	********  ********  ********  ********

- *		  ^

- *

- *  leftShift = 24

- *  rightShift = 8

- */

-

-#define LoadBits {\

-    if (leftShift) { \

-	bitsRight = (src < srcEnd ? READ(src++) : 0); \

-	bits = (FbStipLeft (bitsLeft, leftShift) | \

-		FbStipRight(bitsRight, rightShift)); \

-	bitsLeft = bitsRight; \

-    } else \

-	bits = (src < srcEnd ? READ(src++) : 0); \

-}

-    

-    

-#define LaneCases1(n,a)	    case n: FbLaneCase(n,a); break

-#define LaneCases2(n,a)	    LaneCases1(n,a); LaneCases1(n+1,a)

-#define LaneCases4(n,a)	    LaneCases2(n,a); LaneCases2(n+2,a)

-#define LaneCases8(n,a)	    LaneCases4(n,a); LaneCases4(n+4,a)

-#define LaneCases16(n,a)    LaneCases8(n,a); LaneCases8(n+8,a)

-#define LaneCases32(n,a)    LaneCases16(n,a); LaneCases16(n+16,a)

-#define LaneCases64(n,a)    LaneCases32(n,a); LaneCases32(n+32,a)

-#define LaneCases128(n,a)   LaneCases64(n,a); LaneCases64(n+64,a)

-#define LaneCases256(n,a)   LaneCases128(n,a); LaneCases128(n+128,a)

-    

-#if FB_SHIFT == 6

-#define LaneCases(a)	    LaneCases256(0,a)

-#endif

-    

-#if FB_SHIFT == 5

-#define LaneCases(a)	    LaneCases16(0,a)

-#endif

-							   

-#if FB_SHIFT == 6

-CARD8	fb8Lane[256] = {

-0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,

-22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,

-41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,

-60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,

-79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,

-98, 99, 100, 101, 102,103,104,105,106,107,108,109,110,111,112,113,114,115,

-116, 117, 118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,

-134, 135, 136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,

-152, 153, 154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,

-170, 171, 172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,

-188, 189, 190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,

-206, 207, 208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,

-224, 225, 226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,

-242, 243, 244,245,246,247,248,249,250,251,252,253,254,255,

-};

-

-CARD8	fb16Lane[256] = {

-    0x00, 0x03, 0x0c, 0x0f,

-    0x30, 0x33, 0x3c, 0x3f,

-    0xc0, 0xc3, 0xcc, 0xcf,

-    0xf0, 0xf3, 0xfc, 0xff,

-};

-

-CARD8	fb32Lane[16] = {

-    0x00, 0x0f, 0xf0, 0xff,

-};

-#endif

-

-#if FB_SHIFT == 5

-CARD8	fb8Lane[16] = {

-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

-};

-

-CARD8	fb16Lane[16] = {

-    0, 3, 12, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 

-};

-

-CARD8	fb32Lane[16] = {

-    0, 15,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

-};

-#endif

-

-CARD8	*fbLaneTable[33] = {

-    0, 0, 0, 0, 0, 0, 0, 0,

-    fb8Lane,  0, 0, 0, 0, 0, 0, 0, 

-    fb16Lane, 0, 0, 0, 0, 0, 0, 0,

-    0, 0, 0, 0, 0, 0, 0, 0,

-    fb32Lane

-};

-

-void

-fbBltOne (FbStip    *src,

-	  FbStride  srcStride,	    /* FbStip units per scanline */

-	  int	    srcX,	    /* bit position of source */

-	  FbBits    *dst,

-	  FbStride  dstStride,	    /* FbBits units per scanline */

-	  int	    dstX,	    /* bit position of dest */

-	  int	    dstBpp,	    /* bits per destination unit */

-

-	  int	    width,	    /* width in bits of destination */

-	  int	    height,	    /* height in scanlines */

-

-	  FbBits    fgand,	    /* rrop values */

-	  FbBits    fgxor,

-	  FbBits    bgand,

-	  FbBits    bgxor)

-{

-    const FbBits    *fbBits;

-    FbBits	    *srcEnd;

-    int		    pixelsPerDst;		/* dst pixels per FbBits */

-    int		    unitsPerSrc;		/* src patterns per FbStip */

-    int		    leftShift, rightShift;	/* align source with dest */

-    FbBits	    startmask, endmask;		/* dest scanline masks */

-    FbStip	    bits=0, bitsLeft, bitsRight;/* source bits */

-    FbStip	    left;

-    FbBits	    mask;

-    int		    nDst;			/* dest longwords (w.o. end) */

-    int		    w;

-    int		    n, nmiddle;

-    int		    dstS;			/* stipple-relative dst X coordinate */

-    Bool	    copy;			/* accelerate dest-invariant */

-    Bool	    transparent;		/* accelerate 0 nop */

-    int		    srcinc;			/* source units consumed */

-    Bool	    endNeedsLoad = FALSE;	/* need load for endmask */

-    CARD8	    *fbLane;

-    int		    startbyte, endbyte;

-

-    if (dstBpp == 24)

-    {

-	fbBltOne24 (src, srcStride, srcX,

-		    dst, dstStride, dstX, dstBpp,

-		    width, height,

-		    fgand, fgxor, bgand, bgxor);

-	return;

-    }

-

-    /*

-     * Do not read past the end of the buffer!

-     */

-    srcEnd = src + height * srcStride;

-

-    /*

-     * Number of destination units in FbBits == number of stipple pixels

-     * used each time

-     */

-    pixelsPerDst = FB_UNIT / dstBpp;

-

-    /*

-     * Number of source stipple patterns in FbStip 

-     */

-    unitsPerSrc = FB_STIP_UNIT / pixelsPerDst;

-    

-    copy = FALSE;

-    transparent = FALSE;

-    if (bgand == 0 && fgand == 0)

-	copy = TRUE;

-    else if (bgand == FB_ALLONES && bgxor == 0)

-	transparent = TRUE;

-

-    /*

-     * Adjust source and dest to nearest FbBits boundary

-     */

-    src += srcX >> FB_STIP_SHIFT;

-    dst += dstX >> FB_SHIFT;

-    srcX &= FB_STIP_MASK;

-    dstX &= FB_MASK;

-

-    FbMaskBitsBytes(dstX, width, copy, 

-		    startmask, startbyte, nmiddle, endmask, endbyte);

-

-    /*

-     * Compute effective dest alignment requirement for

-     * source -- must align source to dest unit boundary

-     */

-    dstS = dstX / dstBpp;

-    /*

-     * Compute shift constants for effective alignement

-     */

-    if (srcX >= dstS)

-    {

-	leftShift = srcX - dstS;

-	rightShift = FB_STIP_UNIT - leftShift;

-    }

-    else

-    {

-	rightShift = dstS - srcX;

-	leftShift = FB_STIP_UNIT - rightShift;

-    }

-    /*

-     * Get pointer to stipple mask array for this depth

-     */

-    fbBits = 0;	/* unused */

-    if (pixelsPerDst <= 8)

-	fbBits = fbStippleTable[pixelsPerDst];

-    fbLane = 0;

-    if (transparent && fgand == 0 && dstBpp >= 8)

-	fbLane = fbLaneTable[dstBpp];

-    

-    /*

-     * Compute total number of destination words written, but 

-     * don't count endmask 

-     */

-    nDst = nmiddle;

-    if (startmask)

-	nDst++;

-    

-    dstStride -= nDst;

-

-    /*

-     * Compute total number of source words consumed

-     */

-    

-    srcinc = (nDst + unitsPerSrc - 1) / unitsPerSrc;

-    

-    if (srcX > dstS)

-	srcinc++;

-    if (endmask)

-    {

-	endNeedsLoad = nDst % unitsPerSrc == 0;

-	if (endNeedsLoad)

-	    srcinc++;

-    }

-

-    srcStride -= srcinc;

-    

-    /*

-     * Copy rectangle

-     */

-    while (height--)

-    {

-	w = nDst;	    /* total units across scanline */

-	n = unitsPerSrc;    /* units avail in single stipple */

-	if (n > w)

-	    n = w;

-	

-	bitsLeft = 0;

-	if (srcX > dstS)

-	    bitsLeft = READ(src++);

-	if (n)

-	{

-	    /*

-	     * Load first set of stipple bits

-	     */

-	    LoadBits;

-

-	    /*

-	     * Consume stipple bits for startmask

-	     */

-	    if (startmask)

-	    {

-#if FB_UNIT > 32

-		if (pixelsPerDst == 16)

-		    mask = FbStipple16Bits(FbLeftStipBits(bits,16));

-		else

-#endif

-		    mask = fbBits[FbLeftStipBits(bits,pixelsPerDst)];

-		if (fbLane)

-		{

-		    fbTransparentSpan (dst, mask & startmask, fgxor, 1);

-		}

-		else

-		{

-		    if (mask || !transparent)

-			FbDoLeftMaskByteStippleRRop (dst, mask,

-						     fgand, fgxor, bgand, bgxor,

-						     startbyte, startmask);

-		}

-		bits = FbStipLeft (bits, pixelsPerDst);

-		dst++;

-		n--;

-		w--;

-	    }

-	    /*

-	     * Consume stipple bits across scanline

-	     */

-	    for (;;)

-	    {

-		w -= n;

-		if (copy)

-		{

-		    while (n--)

-		    {

-#if FB_UNIT > 32

-			if (pixelsPerDst == 16)

-			    mask = FbStipple16Bits(FbLeftStipBits(bits,16));

-			else

-#endif

-			    mask = fbBits[FbLeftStipBits(bits,pixelsPerDst)];

-			WRITE(dst, FbOpaqueStipple (mask, fgxor, bgxor));

-			dst++;

-			bits = FbStipLeft(bits, pixelsPerDst);

-		    }

-		}

-		else

-		{

-		    if (fbLane)

-		    {

-			while (bits && n)

-			{

-			    switch (fbLane[FbLeftStipBits(bits,pixelsPerDst)]) {

-				LaneCases((CARD8 *) dst);

-			    }

-			    bits = FbStipLeft(bits,pixelsPerDst);

-			    dst++;

-			    n--;

-			}

-			dst += n;

-		    }

-		    else

-		    {

-			while (n--)

-			{

-			    left = FbLeftStipBits(bits,pixelsPerDst);

-			    if (left || !transparent)

-			    {

-				mask = fbBits[left];

-				WRITE(dst, FbStippleRRop (READ(dst), mask,

-						          fgand, fgxor, bgand, bgxor));

-			    }

-			    dst++;

-			    bits = FbStipLeft(bits, pixelsPerDst);

-			}

-		    }

-		}

-		if (!w)

-		    break;

-		/*

-		 * Load another set and reset number of available units

-		 */

-		LoadBits;

-		n = unitsPerSrc;

-		if (n > w)

-		    n = w;

-	    }

-	}

-	/*

-	 * Consume stipple bits for endmask

-	 */

-	if (endmask)

-	{

-	    if (endNeedsLoad)

-	    {

-		LoadBits;

-	    }

-#if FB_UNIT > 32

-	    if (pixelsPerDst == 16)

-		mask = FbStipple16Bits(FbLeftStipBits(bits,16));

-	    else

-#endif

-		mask = fbBits[FbLeftStipBits(bits,pixelsPerDst)];

-	    if (fbLane)

-	    {

-		fbTransparentSpan (dst, mask & endmask, fgxor, 1);

-	    }

-	    else

-	    {

-		if (mask || !transparent)

-		    FbDoRightMaskByteStippleRRop (dst, mask, 

-						  fgand, fgxor, bgand, bgxor,

-						  endbyte, endmask);

-	    }

-	}

-	dst += dstStride;

-	src += srcStride;

-    }

-}

-

-

-/*

- * Crufty macros to initialize the mask array, most of this

- * is to avoid compile-time warnings about shift overflow

- */

-

-#if BITMAP_BIT_ORDER == MSBFirst

-#define Mask24Pos(x,r) ((x)*24-(r))

-#else

-#define Mask24Pos(x,r) ((x)*24-((r) ? 24 - (r) : 0))

-#endif

-

-#define Mask24Neg(x,r)	(Mask24Pos(x,r) < 0 ? -Mask24Pos(x,r) : 0)

-#define Mask24Check(x,r)    (Mask24Pos(x,r) < 0 ? 0 : \

-			     Mask24Pos(x,r) >= FB_UNIT ? 0 : Mask24Pos(x,r))

-

-#define Mask24(x,r) (Mask24Pos(x,r) < FB_UNIT ? \

-		     (Mask24Pos(x,r) < 0 ? \

-		      0xffffffU >> Mask24Neg (x,r) : \

-		      0xffffffU << Mask24Check(x,r)) : 0)

-

-#define SelMask24(b,n,r)	((((b) >> n) & 1) * Mask24(n,r))

-

-/*

- * Untested for MSBFirst or FB_UNIT == 32

- */

-

-#if FB_UNIT == 64

-#define C4_24(b,r) \

-    (SelMask24(b,0,r) | \

-     SelMask24(b,1,r) | \

-     SelMask24(b,2,r) | \

-     SelMask24(b,3,r))

-

-#define FbStip24New(rot)    (2 + (rot != 0))

-#define FbStip24Len	    4

-

-const FbBits	fbStipple24Bits[3][1 << FbStip24Len] = {

-    /* rotate 0 */

-    {

-	C4_24( 0, 0), C4_24( 1, 0), C4_24( 2, 0), C4_24( 3, 0),

-	C4_24( 4, 0), C4_24( 5, 0), C4_24( 6, 0), C4_24( 7, 0),

-	C4_24( 8, 0), C4_24( 9, 0), C4_24(10, 0), C4_24(11, 0),

-	C4_24(12, 0), C4_24(13, 0), C4_24(14, 0), C4_24(15, 0),

-    },

-    /* rotate 8 */

-    {

-	C4_24( 0, 8), C4_24( 1, 8), C4_24( 2, 8), C4_24( 3, 8),

-	C4_24( 4, 8), C4_24( 5, 8), C4_24( 6, 8), C4_24( 7, 8),

-	C4_24( 8, 8), C4_24( 9, 8), C4_24(10, 8), C4_24(11, 8),

-	C4_24(12, 8), C4_24(13, 8), C4_24(14, 8), C4_24(15, 8),

-    },

-    /* rotate 16 */

-    {

-	C4_24( 0,16), C4_24( 1,16), C4_24( 2,16), C4_24( 3,16),

-	C4_24( 4,16), C4_24( 5,16), C4_24( 6,16), C4_24( 7,16),

-	C4_24( 8,16), C4_24( 9,16), C4_24(10,16), C4_24(11,16),

-	C4_24(12,16), C4_24(13,16), C4_24(14,16), C4_24(15,16),

-    }

-};

-

-#endif

-

-#if FB_UNIT == 32

-#define C2_24(b,r)  \

-    (SelMask24(b,0,r) | \

-     SelMask24(b,1,r))

-

-#define FbStip24Len	    2

-#if BITMAP_BIT_ORDER == MSBFirst

-#define FbStip24New(rot)    (1 + (rot == 0))

-#else

-#define FbStip24New(rot)    (1 + (rot == 8))

-#endif

-

-const FbBits	fbStipple24Bits[3][1 << FbStip24Len] = {

-    /* rotate 0 */

-    {

-	C2_24( 0, 0), C2_24 ( 1, 0), C2_24 ( 2, 0), C2_24 ( 3, 0),

-    },

-    /* rotate 8 */

-    {

-	C2_24( 0, 8), C2_24 ( 1, 8), C2_24 ( 2, 8), C2_24 ( 3, 8),

-    },

-    /* rotate 16 */

-    {

-	C2_24( 0,16), C2_24 ( 1,16), C2_24 ( 2,16), C2_24 ( 3,16),

-    }

-};

-#endif

-

-#if BITMAP_BIT_ORDER == LSBFirst

-

-#define FbMergeStip24Bits(left, right, new) \

-	(FbStipLeft (left, new) | FbStipRight ((right), (FbStip24Len - (new))))

-

-#define FbMergePartStip24Bits(left, right, llen, rlen) \

-	(left | FbStipRight(right, llen))

-

-#else

-

-#define FbMergeStip24Bits(left, right, new) \

-	((FbStipLeft (left, new) & ((1 << FbStip24Len) - 1)) | right)

-

-#define FbMergePartStip24Bits(left, right, llen, rlen) \

-	(FbStipLeft(left, rlen) | right)

-

-#endif

-

-#define fbFirstStipBits(len,stip) {\

-    int	__len = (len); \

-    if (len <= remain) { \

-	stip = FbLeftStipBits(bits, len); \

-    } else { \

-	stip = FbLeftStipBits(bits, remain); \

-	bits = (src < srcEnd ? READ(src++) : 0); \

-	__len = (len) - remain; \

-	stip = FbMergePartStip24Bits(stip, FbLeftStipBits(bits, __len), \

-				     remain, __len); \

-	remain = FB_STIP_UNIT; \

-    } \

-    bits = FbStipLeft (bits, __len); \

-    remain -= __len; \

-}

-

-#define fbInitStipBits(offset,len,stip) {\

-    bits = FbStipLeft (READ(src++),offset); \

-    remain = FB_STIP_UNIT - offset; \

-    fbFirstStipBits(len,stip); \

-    stip = FbMergeStip24Bits (0, stip, len); \

-}

-    

-#define fbNextStipBits(rot,stip) {\

-    int	    __new = FbStip24New(rot); \

-    FbStip  __right; \

-    fbFirstStipBits(__new, __right); \

-    stip = FbMergeStip24Bits (stip, __right, __new); \

-    rot = FbNext24Rot (rot); \

-}

-

-/*

- * Use deep mask tables that incorporate rotation, pull

- * a variable number of bits out of the stipple and

- * reuse the right bits as needed for the next write

- *

- * Yes, this is probably too much code, but most 24-bpp screens

- * have no acceleration so this code is used for stipples, copyplane

- * and text

- */

-void

-fbBltOne24 (FbStip	*srcLine,

-	    FbStride	srcStride,  /* FbStip units per scanline */

-	    int		srcX,	    /* bit position of source */

-	    FbBits	*dst,

-	    FbStride	dstStride,  /* FbBits units per scanline */

-	    int		dstX,	    /* bit position of dest */

-	    int		dstBpp,	    /* bits per destination unit */

-

-	    int		width,	    /* width in bits of destination */

-	    int		height,	    /* height in scanlines */

-

-	    FbBits	fgand,	    /* rrop values */

-	    FbBits	fgxor,

-	    FbBits	bgand,

-	    FbBits	bgxor)

-{

-    FbStip	*src, *srcEnd;

-    FbBits	leftMask, rightMask, mask;

-    int		nlMiddle, nl;

-    FbStip	stip, bits;

-    int		remain;

-    int		dstS;

-    int		firstlen;

-    int		rot0, rot;

-    int		nDst;

-    

-    /*

-     * Do not read past the end of the buffer!

-     */

-    srcEnd = srcLine + height * srcStride;

-

-    srcLine += srcX >> FB_STIP_SHIFT;

-    dst += dstX >> FB_SHIFT;

-    srcX &= FB_STIP_MASK;

-    dstX &= FB_MASK;

-    rot0 = FbFirst24Rot (dstX);

-    

-    FbMaskBits (dstX, width, leftMask, nlMiddle, rightMask);

-    

-    dstS = (dstX + 23) / 24;

-    firstlen = FbStip24Len - dstS;

-    

-    nDst = nlMiddle;

-    if (leftMask)

-	nDst++;

-    dstStride -= nDst;

-    

-    /* opaque copy */

-    if (bgand == 0 && fgand == 0)

-    {

-	while (height--)

-	{

-	    rot = rot0;

-	    src = srcLine;

-	    srcLine += srcStride;

-	    fbInitStipBits (srcX,firstlen, stip);

-	    if (leftMask)

-	    {

-		mask = fbStipple24Bits[rot >> 3][stip];

-		WRITE(dst, (READ(dst) & ~leftMask) |

-			    (FbOpaqueStipple (mask,

-					      FbRot24(fgxor, rot),

-					      FbRot24(bgxor, rot))

-			     & leftMask));

-		dst++;

-		fbNextStipBits(rot,stip);

-	    }

-	    nl = nlMiddle;

-	    while (nl--)

-	    {

-		mask = fbStipple24Bits[rot>>3][stip];

-		WRITE(dst, FbOpaqueStipple (mask,

-					    FbRot24(fgxor, rot),

-					    FbRot24(bgxor, rot)));

-		dst++;

-		fbNextStipBits(rot,stip);

-	    }

-	    if (rightMask)

-	    {

-		mask = fbStipple24Bits[rot >> 3][stip];

-		WRITE(dst, (READ(dst) & ~rightMask) |

-			    (FbOpaqueStipple (mask,

-					      FbRot24(fgxor, rot),

-					      FbRot24(bgxor, rot))

-			     & rightMask));

-	    }

-	    dst += dstStride;

-	    src += srcStride;

-	}

-    }

-    /* transparent copy */

-    else if (bgand == FB_ALLONES && bgxor == 0 && fgand == 0)

-    {

-	while (height--)

-	{

-	    rot = rot0;

-	    src = srcLine;

-	    srcLine += srcStride;

-	    fbInitStipBits (srcX, firstlen, stip);

-	    if (leftMask)

-	    {

-		if (stip)

-		{

-		    mask = fbStipple24Bits[rot >> 3][stip] & leftMask;

-		    WRITE(dst, (READ(dst) & ~mask) | (FbRot24(fgxor, rot) & mask));

-		}

-		dst++;

-		fbNextStipBits (rot, stip);

-	    }

-	    nl = nlMiddle;

-	    while (nl--)

-	    {

-		if (stip)

-		{

-		    mask = fbStipple24Bits[rot>>3][stip];

-		    WRITE(dst, (READ(dst) & ~mask) | (FbRot24(fgxor,rot) & mask));

-		}

-		dst++;

-		fbNextStipBits (rot, stip);

-	    }

-	    if (rightMask)

-	    {

-		if (stip)

-		{

-		    mask = fbStipple24Bits[rot >> 3][stip] & rightMask;

-		    WRITE(dst, (READ(dst) & ~mask) | (FbRot24(fgxor, rot) & mask));

-		}

-	    }

-	    dst += dstStride;

-	}

-    }

-    else

-    {

-	while (height--)

-	{

-	    rot = rot0;

-	    src = srcLine;

-	    srcLine += srcStride;

-	    fbInitStipBits (srcX, firstlen, stip);

-	    if (leftMask)

-	    {

-		mask = fbStipple24Bits[rot >> 3][stip];

-		WRITE(dst, FbStippleRRopMask (READ(dst), mask,

-					      FbRot24(fgand, rot),

-					      FbRot24(fgxor, rot),

-					      FbRot24(bgand, rot),

-					      FbRot24(bgxor, rot),

-					      leftMask));

-		dst++;

-		fbNextStipBits(rot,stip);

-	    }

-	    nl = nlMiddle;

-	    while (nl--)

-	    {

-		mask = fbStipple24Bits[rot >> 3][stip];

-		WRITE(dst, FbStippleRRop (READ(dst), mask,

-					  FbRot24(fgand, rot),

-					  FbRot24(fgxor, rot),

-					  FbRot24(bgand, rot),

-					  FbRot24(bgxor, rot)));

-		dst++;

-		fbNextStipBits(rot,stip);

-	    }

-	    if (rightMask)

-	    {

-		mask = fbStipple24Bits[rot >> 3][stip];

-		WRITE(dst, FbStippleRRopMask (READ(dst), mask,

-					      FbRot24(fgand, rot),

-					      FbRot24(fgxor, rot),

-					      FbRot24(bgand, rot),

-					      FbRot24(bgxor, rot),

-					      rightMask));

-	    }

-	    dst += dstStride;

-	}

-    }

-}

-

-/*

- * Not very efficient, but simple -- copy a single plane

- * from an N bit image to a 1 bit image

- */

- 

-void

-fbBltPlane (FbBits	    *src,

-	    FbStride	    srcStride,

-	    int		    srcX,

-	    int		    srcBpp,

-

-	    FbStip	    *dst,

-	    FbStride	    dstStride,

-	    int		    dstX,

-	    

-	    int		    width,

-	    int		    height,

-	    

-	    FbStip	    fgand,

-	    FbStip	    fgxor,

-	    FbStip	    bgand,

-	    FbStip	    bgxor,

-	    Pixel	    planeMask)

-{

-    FbBits	*s;

-    FbBits	pm;

-    FbBits	srcMask;

-    FbBits	srcMaskFirst;

-    FbBits	srcMask0 = 0;

-    FbBits	srcBits;

-    

-    FbStip	dstBits;

-    FbStip	*d;

-    FbStip	dstMask;

-    FbStip	dstMaskFirst;

-    FbStip	dstUnion;

-    int		w;

-    int		wt;

-    int		rot0;

-

-    if (!width)

-	return;

-    

-    src += srcX >> FB_SHIFT;

-    srcX &= FB_MASK;

-

-    dst += dstX >> FB_STIP_SHIFT;

-    dstX &= FB_STIP_MASK;

-    

-    w = width / srcBpp;

-

-    pm = fbReplicatePixel (planeMask, srcBpp);

-    if (srcBpp == 24)

-    {

-	int w = 24;

-

-	rot0 = FbFirst24Rot (srcX);

-	if (srcX + w > FB_UNIT)

-	    w = FB_UNIT - srcX;

-	srcMaskFirst = FbRot24(pm,rot0) & FbBitsMask(srcX,w);

-    }

-    else

-    {

-	rot0 = 0;

-	srcMaskFirst = pm & FbBitsMask(srcX, srcBpp);

-	srcMask0 = pm & FbBitsMask(0, srcBpp);

-    }

-    

-    dstMaskFirst = FbStipMask(dstX,1); 

-    while (height--)

-    {

-	d = dst;

-	dst += dstStride;

-	s = src;

-	src += srcStride;

-	

-	srcMask = srcMaskFirst;

-	if (srcBpp == 24)

-	    srcMask0 = FbRot24(pm,rot0) & FbBitsMask(0, srcBpp);

-    	srcBits = READ(s++);

-

-	dstMask = dstMaskFirst;

-	dstUnion = 0;

-	dstBits = 0;

-	

-	wt = w;

-	

-	while (wt--)

-	{

-	    if (!srcMask)

-	    {

-		srcBits = READ(s++);

-		if (srcBpp == 24)

-		    srcMask0 = FbNext24Pix(srcMask0) & FbBitsMask(0,24);

-		srcMask = srcMask0;

-	    }

-	    if (!dstMask)

-	    {

-		WRITE(d, FbStippleRRopMask(READ(d), dstBits,

-					   fgand, fgxor, bgand, bgxor,

-					   dstUnion));

-		d++;

-		dstMask = FbStipMask(0,1);

-		dstUnion = 0;

-		dstBits = 0;

-	    }

-	    if (srcBits & srcMask)

-		dstBits |= dstMask;

-	    dstUnion |= dstMask;

-	    if (srcBpp == FB_UNIT)

-		srcMask = 0;

-	    else

-		srcMask = FbScrRight(srcMask,srcBpp);

-	    dstMask = FbStipRight(dstMask,1);

-	}

-	if (dstUnion)

-	    WRITE(d, FbStippleRRopMask(READ(d),dstBits,

-				       fgand, fgxor, bgand, bgxor,

-				       dstUnion));

-    }

-}

-

+/*
+ * Copyright © 1998 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "fb.h"
+
+#ifdef __clang__
+/* shift overflow is intentional */
+#pragma clang diagnostic ignored "-Wshift-overflow"
+#endif
+
+/*
+ *  Example: srcX = 13 dstX = 8	(FB unit 32 dstBpp 8)
+ *
+ *	**** **** **** **** **** **** **** ****
+ *			^
+ *	********  ********  ********  ********
+ *		  ^
+ *  leftShift = 12
+ *  rightShift = 20
+ *
+ *  Example: srcX = 0 dstX = 8 (FB unit 32 dstBpp 8)
+ *
+ *	**** **** **** **** **** **** **** ****
+ *	^		
+ *	********  ********  ********  ********
+ *		  ^
+ *
+ *  leftShift = 24
+ *  rightShift = 8
+ */
+
+#define LoadBits {\
+    if (leftShift) { \
+	bitsRight = (src < srcEnd ? READ(src++) : 0); \
+	bits = (FbStipLeft (bitsLeft, leftShift) | \
+		FbStipRight(bitsRight, rightShift)); \
+	bitsLeft = bitsRight; \
+    } else \
+	bits = (src < srcEnd ? READ(src++) : 0); \
+}
+    
+    
+#define LaneCases1(n,a)	    case n: FbLaneCase(n,a); break
+#define LaneCases2(n,a)	    LaneCases1(n,a); LaneCases1(n+1,a)
+#define LaneCases4(n,a)	    LaneCases2(n,a); LaneCases2(n+2,a)
+#define LaneCases8(n,a)	    LaneCases4(n,a); LaneCases4(n+4,a)
+#define LaneCases16(n,a)    LaneCases8(n,a); LaneCases8(n+8,a)
+#define LaneCases32(n,a)    LaneCases16(n,a); LaneCases16(n+16,a)
+#define LaneCases64(n,a)    LaneCases32(n,a); LaneCases32(n+32,a)
+#define LaneCases128(n,a)   LaneCases64(n,a); LaneCases64(n+64,a)
+#define LaneCases256(n,a)   LaneCases128(n,a); LaneCases128(n+128,a)
+    
+#if FB_SHIFT == 6
+#define LaneCases(a)	    LaneCases256(0,a)
+#endif
+    
+#if FB_SHIFT == 5
+#define LaneCases(a)	    LaneCases16(0,a)
+#endif
+							   
+#if FB_SHIFT == 6
+CARD8	fb8Lane[256] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
+98, 99, 100, 101, 102,103,104,105,106,107,108,109,110,111,112,113,114,115,
+116, 117, 118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,
+134, 135, 136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,
+152, 153, 154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,
+170, 171, 172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,
+188, 189, 190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,
+206, 207, 208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
+224, 225, 226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,
+242, 243, 244,245,246,247,248,249,250,251,252,253,254,255,
+};
+
+CARD8	fb16Lane[256] = {
+    0x00, 0x03, 0x0c, 0x0f,
+    0x30, 0x33, 0x3c, 0x3f,
+    0xc0, 0xc3, 0xcc, 0xcf,
+    0xf0, 0xf3, 0xfc, 0xff,
+};
+
+CARD8	fb32Lane[16] = {
+    0x00, 0x0f, 0xf0, 0xff,
+};
+#endif
+
+#if FB_SHIFT == 5
+CARD8	fb8Lane[16] = {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+};
+
+CARD8	fb16Lane[16] = {
+    0, 3, 12, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+};
+
+CARD8	fb32Lane[16] = {
+    0, 15,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+#endif
+
+CARD8	*fbLaneTable[33] = {
+    0, 0, 0, 0, 0, 0, 0, 0,
+    fb8Lane,  0, 0, 0, 0, 0, 0, 0, 
+    fb16Lane, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0,
+    fb32Lane
+};
+
+void
+fbBltOne (FbStip    *src,
+	  FbStride  srcStride,	    /* FbStip units per scanline */
+	  int	    srcX,	    /* bit position of source */
+	  FbBits    *dst,
+	  FbStride  dstStride,	    /* FbBits units per scanline */
+	  int	    dstX,	    /* bit position of dest */
+	  int	    dstBpp,	    /* bits per destination unit */
+
+	  int	    width,	    /* width in bits of destination */
+	  int	    height,	    /* height in scanlines */
+
+	  FbBits    fgand,	    /* rrop values */
+	  FbBits    fgxor,
+	  FbBits    bgand,
+	  FbBits    bgxor)
+{
+    const FbBits    *fbBits;
+    FbBits	    *srcEnd;
+    int		    pixelsPerDst;		/* dst pixels per FbBits */
+    int		    unitsPerSrc;		/* src patterns per FbStip */
+    int		    leftShift, rightShift;	/* align source with dest */
+    FbBits	    startmask, endmask;		/* dest scanline masks */
+    FbStip	    bits=0, bitsLeft, bitsRight;/* source bits */
+    FbStip	    left;
+    FbBits	    mask;
+    int		    nDst;			/* dest longwords (w.o. end) */
+    int		    w;
+    int		    n, nmiddle;
+    int		    dstS;			/* stipple-relative dst X coordinate */
+    Bool	    copy;			/* accelerate dest-invariant */
+    Bool	    transparent;		/* accelerate 0 nop */
+    int		    srcinc;			/* source units consumed */
+    Bool	    endNeedsLoad = FALSE;	/* need load for endmask */
+    CARD8	    *fbLane;
+    int		    startbyte, endbyte;
+
+    if (dstBpp == 24)
+    {
+	fbBltOne24 (src, srcStride, srcX,
+		    dst, dstStride, dstX, dstBpp,
+		    width, height,
+		    fgand, fgxor, bgand, bgxor);
+	return;
+    }
+
+    /*
+     * Do not read past the end of the buffer!
+     */
+    srcEnd = src + height * srcStride;
+
+    /*
+     * Number of destination units in FbBits == number of stipple pixels
+     * used each time
+     */
+    pixelsPerDst = FB_UNIT / dstBpp;
+
+    /*
+     * Number of source stipple patterns in FbStip 
+     */
+    unitsPerSrc = FB_STIP_UNIT / pixelsPerDst;
+    
+    copy = FALSE;
+    transparent = FALSE;
+    if (bgand == 0 && fgand == 0)
+	copy = TRUE;
+    else if (bgand == FB_ALLONES && bgxor == 0)
+	transparent = TRUE;
+
+    /*
+     * Adjust source and dest to nearest FbBits boundary
+     */
+    src += srcX >> FB_STIP_SHIFT;
+    dst += dstX >> FB_SHIFT;
+    srcX &= FB_STIP_MASK;
+    dstX &= FB_MASK;
+
+    FbMaskBitsBytes(dstX, width, copy, 
+		    startmask, startbyte, nmiddle, endmask, endbyte);
+
+    /*
+     * Compute effective dest alignment requirement for
+     * source -- must align source to dest unit boundary
+     */
+    dstS = dstX / dstBpp;
+    /*
+     * Compute shift constants for effective alignement
+     */
+    if (srcX >= dstS)
+    {
+	leftShift = srcX - dstS;
+	rightShift = FB_STIP_UNIT - leftShift;
+    }
+    else
+    {
+	rightShift = dstS - srcX;
+	leftShift = FB_STIP_UNIT - rightShift;
+    }
+    /*
+     * Get pointer to stipple mask array for this depth
+     */
+    fbBits = 0;	/* unused */
+    if (pixelsPerDst <= 8)
+	fbBits = fbStippleTable[pixelsPerDst];
+    fbLane = 0;
+    if (transparent && fgand == 0 && dstBpp >= 8)
+	fbLane = fbLaneTable[dstBpp];
+    
+    /*
+     * Compute total number of destination words written, but 
+     * don't count endmask 
+     */
+    nDst = nmiddle;
+    if (startmask)
+	nDst++;
+    
+    dstStride -= nDst;
+
+    /*
+     * Compute total number of source words consumed
+     */
+    
+    srcinc = (nDst + unitsPerSrc - 1) / unitsPerSrc;
+    
+    if (srcX > dstS)
+	srcinc++;
+    if (endmask)
+    {
+	endNeedsLoad = nDst % unitsPerSrc == 0;
+	if (endNeedsLoad)
+	    srcinc++;
+    }
+
+    srcStride -= srcinc;
+    
+    /*
+     * Copy rectangle
+     */
+    while (height--)
+    {
+	w = nDst;	    /* total units across scanline */
+	n = unitsPerSrc;    /* units avail in single stipple */
+	if (n > w)
+	    n = w;
+	
+	bitsLeft = 0;
+	if (srcX > dstS)
+	    bitsLeft = READ(src++);
+	if (n)
+	{
+	    /*
+	     * Load first set of stipple bits
+	     */
+	    LoadBits;
+
+	    /*
+	     * Consume stipple bits for startmask
+	     */
+	    if (startmask)
+	    {
+#if FB_UNIT > 32
+		if (pixelsPerDst == 16)
+		    mask = FbStipple16Bits(FbLeftStipBits(bits,16));
+		else
+#endif
+		    mask = fbBits[FbLeftStipBits(bits,pixelsPerDst)];
+		if (fbLane)
+		{
+		    fbTransparentSpan (dst, mask & startmask, fgxor, 1);
+		}
+		else
+		{
+		    if (mask || !transparent)
+			FbDoLeftMaskByteStippleRRop (dst, mask,
+						     fgand, fgxor, bgand, bgxor,
+						     startbyte, startmask);
+		}
+		bits = FbStipLeft (bits, pixelsPerDst);
+		dst++;
+		n--;
+		w--;
+	    }
+	    /*
+	     * Consume stipple bits across scanline
+	     */
+	    for (;;)
+	    {
+		w -= n;
+		if (copy)
+		{
+		    while (n--)
+		    {
+#if FB_UNIT > 32
+			if (pixelsPerDst == 16)
+			    mask = FbStipple16Bits(FbLeftStipBits(bits,16));
+			else
+#endif
+			    mask = fbBits[FbLeftStipBits(bits,pixelsPerDst)];
+			WRITE(dst, FbOpaqueStipple (mask, fgxor, bgxor));
+			dst++;
+			bits = FbStipLeft(bits, pixelsPerDst);
+		    }
+		}
+		else
+		{
+		    if (fbLane)
+		    {
+			while (bits && n)
+			{
+			    switch (fbLane[FbLeftStipBits(bits,pixelsPerDst)]) {
+				LaneCases((CARD8 *) dst);
+			    }
+			    bits = FbStipLeft(bits,pixelsPerDst);
+			    dst++;
+			    n--;
+			}
+			dst += n;
+		    }
+		    else
+		    {
+			while (n--)
+			{
+			    left = FbLeftStipBits(bits,pixelsPerDst);
+			    if (left || !transparent)
+			    {
+				mask = fbBits[left];
+				WRITE(dst, FbStippleRRop (READ(dst), mask,
+						          fgand, fgxor, bgand, bgxor));
+			    }
+			    dst++;
+			    bits = FbStipLeft(bits, pixelsPerDst);
+			}
+		    }
+		}
+		if (!w)
+		    break;
+		/*
+		 * Load another set and reset number of available units
+		 */
+		LoadBits;
+		n = unitsPerSrc;
+		if (n > w)
+		    n = w;
+	    }
+	}
+	/*
+	 * Consume stipple bits for endmask
+	 */
+	if (endmask)
+	{
+	    if (endNeedsLoad)
+	    {
+		LoadBits;
+	    }
+#if FB_UNIT > 32
+	    if (pixelsPerDst == 16)
+		mask = FbStipple16Bits(FbLeftStipBits(bits,16));
+	    else
+#endif
+		mask = fbBits[FbLeftStipBits(bits,pixelsPerDst)];
+	    if (fbLane)
+	    {
+		fbTransparentSpan (dst, mask & endmask, fgxor, 1);
+	    }
+	    else
+	    {
+		if (mask || !transparent)
+		    FbDoRightMaskByteStippleRRop (dst, mask, 
+						  fgand, fgxor, bgand, bgxor,
+						  endbyte, endmask);
+	    }
+	}
+	dst += dstStride;
+	src += srcStride;
+    }
+}
+
+
+/*
+ * Crufty macros to initialize the mask array, most of this
+ * is to avoid compile-time warnings about shift overflow
+ */
+
+#if BITMAP_BIT_ORDER == MSBFirst
+#define Mask24Pos(x,r) ((x)*24-(r))
+#else
+#define Mask24Pos(x,r) ((x)*24-((r) ? 24 - (r) : 0))
+#endif
+
+#define Mask24Neg(x,r)	(Mask24Pos(x,r) < 0 ? -Mask24Pos(x,r) : 0)
+#define Mask24Check(x,r)    (Mask24Pos(x,r) < 0 ? 0 : \
+			     Mask24Pos(x,r) >= FB_UNIT ? 0 : Mask24Pos(x,r))
+
+#define Mask24(x,r) (Mask24Pos(x,r) < FB_UNIT ? \
+		     (Mask24Pos(x,r) < 0 ? \
+		      0xffffffU >> Mask24Neg (x,r) : \
+		      0xffffffU << Mask24Check(x,r)) : 0)
+
+#define SelMask24(b,n,r)	((((b) >> n) & 1) * Mask24(n,r))
+
+/*
+ * Untested for MSBFirst or FB_UNIT == 32
+ */
+
+#if FB_UNIT == 64
+#define C4_24(b,r) \
+    (SelMask24(b,0,r) | \
+     SelMask24(b,1,r) | \
+     SelMask24(b,2,r) | \
+     SelMask24(b,3,r))
+
+#define FbStip24New(rot)    (2 + (rot != 0))
+#define FbStip24Len	    4
+
+const FbBits	fbStipple24Bits[3][1 << FbStip24Len] = {
+    /* rotate 0 */
+    {
+	C4_24( 0, 0), C4_24( 1, 0), C4_24( 2, 0), C4_24( 3, 0),
+	C4_24( 4, 0), C4_24( 5, 0), C4_24( 6, 0), C4_24( 7, 0),
+	C4_24( 8, 0), C4_24( 9, 0), C4_24(10, 0), C4_24(11, 0),
+	C4_24(12, 0), C4_24(13, 0), C4_24(14, 0), C4_24(15, 0),
+    },
+    /* rotate 8 */
+    {
+	C4_24( 0, 8), C4_24( 1, 8), C4_24( 2, 8), C4_24( 3, 8),
+	C4_24( 4, 8), C4_24( 5, 8), C4_24( 6, 8), C4_24( 7, 8),
+	C4_24( 8, 8), C4_24( 9, 8), C4_24(10, 8), C4_24(11, 8),
+	C4_24(12, 8), C4_24(13, 8), C4_24(14, 8), C4_24(15, 8),
+    },
+    /* rotate 16 */
+    {
+	C4_24( 0,16), C4_24( 1,16), C4_24( 2,16), C4_24( 3,16),
+	C4_24( 4,16), C4_24( 5,16), C4_24( 6,16), C4_24( 7,16),
+	C4_24( 8,16), C4_24( 9,16), C4_24(10,16), C4_24(11,16),
+	C4_24(12,16), C4_24(13,16), C4_24(14,16), C4_24(15,16),
+    }
+};
+
+#endif
+
+#if FB_UNIT == 32
+#define C2_24(b,r)  \
+    (SelMask24(b,0,r) | \
+     SelMask24(b,1,r))
+
+#define FbStip24Len	    2
+#if BITMAP_BIT_ORDER == MSBFirst
+#define FbStip24New(rot)    (1 + (rot == 0))
+#else
+#define FbStip24New(rot)    (1 + (rot == 8))
+#endif
+
+const FbBits	fbStipple24Bits[3][1 << FbStip24Len] = {
+    /* rotate 0 */
+    {
+	C2_24( 0, 0), C2_24 ( 1, 0), C2_24 ( 2, 0), C2_24 ( 3, 0),
+    },
+    /* rotate 8 */
+    {
+	C2_24( 0, 8), C2_24 ( 1, 8), C2_24 ( 2, 8), C2_24 ( 3, 8),
+    },
+    /* rotate 16 */
+    {
+	C2_24( 0,16), C2_24 ( 1,16), C2_24 ( 2,16), C2_24 ( 3,16),
+    }
+};
+#endif
+
+#if BITMAP_BIT_ORDER == LSBFirst
+
+#define FbMergeStip24Bits(left, right, new) \
+	(FbStipLeft (left, new) | FbStipRight ((right), (FbStip24Len - (new))))
+
+#define FbMergePartStip24Bits(left, right, llen, rlen) \
+	(left | FbStipRight(right, llen))
+
+#else
+
+#define FbMergeStip24Bits(left, right, new) \
+	((FbStipLeft (left, new) & ((1 << FbStip24Len) - 1)) | right)
+
+#define FbMergePartStip24Bits(left, right, llen, rlen) \
+	(FbStipLeft(left, rlen) | right)
+
+#endif
+
+#define fbFirstStipBits(len,stip) {\
+    int	__len = (len); \
+    if (len <= remain) { \
+	stip = FbLeftStipBits(bits, len); \
+    } else { \
+	stip = FbLeftStipBits(bits, remain); \
+	bits = (src < srcEnd ? READ(src++) : 0); \
+	__len = (len) - remain; \
+	stip = FbMergePartStip24Bits(stip, FbLeftStipBits(bits, __len), \
+				     remain, __len); \
+	remain = FB_STIP_UNIT; \
+    } \
+    bits = FbStipLeft (bits, __len); \
+    remain -= __len; \
+}
+
+#define fbInitStipBits(offset,len,stip) {\
+    bits = FbStipLeft (READ(src++),offset); \
+    remain = FB_STIP_UNIT - offset; \
+    fbFirstStipBits(len,stip); \
+    stip = FbMergeStip24Bits (0, stip, len); \
+}
+    
+#define fbNextStipBits(rot,stip) {\
+    int	    __new = FbStip24New(rot); \
+    FbStip  __right; \
+    fbFirstStipBits(__new, __right); \
+    stip = FbMergeStip24Bits (stip, __right, __new); \
+    rot = FbNext24Rot (rot); \
+}
+
+/*
+ * Use deep mask tables that incorporate rotation, pull
+ * a variable number of bits out of the stipple and
+ * reuse the right bits as needed for the next write
+ *
+ * Yes, this is probably too much code, but most 24-bpp screens
+ * have no acceleration so this code is used for stipples, copyplane
+ * and text
+ */
+void
+fbBltOne24 (FbStip	*srcLine,
+	    FbStride	srcStride,  /* FbStip units per scanline */
+	    int		srcX,	    /* bit position of source */
+	    FbBits	*dst,
+	    FbStride	dstStride,  /* FbBits units per scanline */
+	    int		dstX,	    /* bit position of dest */
+	    int		dstBpp,	    /* bits per destination unit */
+
+	    int		width,	    /* width in bits of destination */
+	    int		height,	    /* height in scanlines */
+
+	    FbBits	fgand,	    /* rrop values */
+	    FbBits	fgxor,
+	    FbBits	bgand,
+	    FbBits	bgxor)
+{
+    FbStip	*src, *srcEnd;
+    FbBits	leftMask, rightMask, mask;
+    int		nlMiddle, nl;
+    FbStip	stip, bits;
+    int		remain;
+    int		dstS;
+    int		firstlen;
+    int		rot0, rot;
+    int		nDst;
+    
+    /*
+     * Do not read past the end of the buffer!
+     */
+    srcEnd = srcLine + height * srcStride;
+
+    srcLine += srcX >> FB_STIP_SHIFT;
+    dst += dstX >> FB_SHIFT;
+    srcX &= FB_STIP_MASK;
+    dstX &= FB_MASK;
+    rot0 = FbFirst24Rot (dstX);
+    
+    FbMaskBits (dstX, width, leftMask, nlMiddle, rightMask);
+    
+    dstS = (dstX + 23) / 24;
+    firstlen = FbStip24Len - dstS;
+    
+    nDst = nlMiddle;
+    if (leftMask)
+	nDst++;
+    dstStride -= nDst;
+    
+    /* opaque copy */
+    if (bgand == 0 && fgand == 0)
+    {
+	while (height--)
+	{
+	    rot = rot0;
+	    src = srcLine;
+	    srcLine += srcStride;
+	    fbInitStipBits (srcX,firstlen, stip);
+	    if (leftMask)
+	    {
+		mask = fbStipple24Bits[rot >> 3][stip];
+		WRITE(dst, (READ(dst) & ~leftMask) |
+			    (FbOpaqueStipple (mask,
+					      FbRot24(fgxor, rot),
+					      FbRot24(bgxor, rot))
+			     & leftMask));
+		dst++;
+		fbNextStipBits(rot,stip);
+	    }
+	    nl = nlMiddle;
+	    while (nl--)
+	    {
+		mask = fbStipple24Bits[rot>>3][stip];
+		WRITE(dst, FbOpaqueStipple (mask,
+					    FbRot24(fgxor, rot),
+					    FbRot24(bgxor, rot)));
+		dst++;
+		fbNextStipBits(rot,stip);
+	    }
+	    if (rightMask)
+	    {
+		mask = fbStipple24Bits[rot >> 3][stip];
+		WRITE(dst, (READ(dst) & ~rightMask) |
+			    (FbOpaqueStipple (mask,
+					      FbRot24(fgxor, rot),
+					      FbRot24(bgxor, rot))
+			     & rightMask));
+	    }
+	    dst += dstStride;
+	    src += srcStride;
+	}
+    }
+    /* transparent copy */
+    else if (bgand == FB_ALLONES && bgxor == 0 && fgand == 0)
+    {
+	while (height--)
+	{
+	    rot = rot0;
+	    src = srcLine;
+	    srcLine += srcStride;
+	    fbInitStipBits (srcX, firstlen, stip);
+	    if (leftMask)
+	    {
+		if (stip)
+		{
+		    mask = fbStipple24Bits[rot >> 3][stip] & leftMask;
+		    WRITE(dst, (READ(dst) & ~mask) | (FbRot24(fgxor, rot) & mask));
+		}
+		dst++;
+		fbNextStipBits (rot, stip);
+	    }
+	    nl = nlMiddle;
+	    while (nl--)
+	    {
+		if (stip)
+		{
+		    mask = fbStipple24Bits[rot>>3][stip];
+		    WRITE(dst, (READ(dst) & ~mask) | (FbRot24(fgxor,rot) & mask));
+		}
+		dst++;
+		fbNextStipBits (rot, stip);
+	    }
+	    if (rightMask)
+	    {
+		if (stip)
+		{
+		    mask = fbStipple24Bits[rot >> 3][stip] & rightMask;
+		    WRITE(dst, (READ(dst) & ~mask) | (FbRot24(fgxor, rot) & mask));
+		}
+	    }
+	    dst += dstStride;
+	}
+    }
+    else
+    {
+	while (height--)
+	{
+	    rot = rot0;
+	    src = srcLine;
+	    srcLine += srcStride;
+	    fbInitStipBits (srcX, firstlen, stip);
+	    if (leftMask)
+	    {
+		mask = fbStipple24Bits[rot >> 3][stip];
+		WRITE(dst, FbStippleRRopMask (READ(dst), mask,
+					      FbRot24(fgand, rot),
+					      FbRot24(fgxor, rot),
+					      FbRot24(bgand, rot),
+					      FbRot24(bgxor, rot),
+					      leftMask));
+		dst++;
+		fbNextStipBits(rot,stip);
+	    }
+	    nl = nlMiddle;
+	    while (nl--)
+	    {
+		mask = fbStipple24Bits[rot >> 3][stip];
+		WRITE(dst, FbStippleRRop (READ(dst), mask,
+					  FbRot24(fgand, rot),
+					  FbRot24(fgxor, rot),
+					  FbRot24(bgand, rot),
+					  FbRot24(bgxor, rot)));
+		dst++;
+		fbNextStipBits(rot,stip);
+	    }
+	    if (rightMask)
+	    {
+		mask = fbStipple24Bits[rot >> 3][stip];
+		WRITE(dst, FbStippleRRopMask (READ(dst), mask,
+					      FbRot24(fgand, rot),
+					      FbRot24(fgxor, rot),
+					      FbRot24(bgand, rot),
+					      FbRot24(bgxor, rot),
+					      rightMask));
+	    }
+	    dst += dstStride;
+	}
+    }
+}
+
+/*
+ * Not very efficient, but simple -- copy a single plane
+ * from an N bit image to a 1 bit image
+ */
+ 
+void
+fbBltPlane (FbBits	    *src,
+	    FbStride	    srcStride,
+	    int		    srcX,
+	    int		    srcBpp,
+
+	    FbStip	    *dst,
+	    FbStride	    dstStride,
+	    int		    dstX,
+	    
+	    int		    width,
+	    int		    height,
+	    
+	    FbStip	    fgand,
+	    FbStip	    fgxor,
+	    FbStip	    bgand,
+	    FbStip	    bgxor,
+	    Pixel	    planeMask)
+{
+    FbBits	*s;
+    FbBits	pm;
+    FbBits	srcMask;
+    FbBits	srcMaskFirst;
+    FbBits	srcMask0 = 0;
+    FbBits	srcBits;
+    
+    FbStip	dstBits;
+    FbStip	*d;
+    FbStip	dstMask;
+    FbStip	dstMaskFirst;
+    FbStip	dstUnion;
+    int		w;
+    int		wt;
+    int		rot0;
+
+    if (!width)
+	return;
+    
+    src += srcX >> FB_SHIFT;
+    srcX &= FB_MASK;
+
+    dst += dstX >> FB_STIP_SHIFT;
+    dstX &= FB_STIP_MASK;
+    
+    w = width / srcBpp;
+
+    pm = fbReplicatePixel (planeMask, srcBpp);
+    if (srcBpp == 24)
+    {
+	int w = 24;
+
+	rot0 = FbFirst24Rot (srcX);
+	if (srcX + w > FB_UNIT)
+	    w = FB_UNIT - srcX;
+	srcMaskFirst = FbRot24(pm,rot0) & FbBitsMask(srcX,w);
+    }
+    else
+    {
+	rot0 = 0;
+	srcMaskFirst = pm & FbBitsMask(srcX, srcBpp);
+	srcMask0 = pm & FbBitsMask(0, srcBpp);
+    }
+    
+    dstMaskFirst = FbStipMask(dstX,1); 
+    while (height--)
+    {
+	d = dst;
+	dst += dstStride;
+	s = src;
+	src += srcStride;
+	
+	srcMask = srcMaskFirst;
+	if (srcBpp == 24)
+	    srcMask0 = FbRot24(pm,rot0) & FbBitsMask(0, srcBpp);
+    	srcBits = READ(s++);
+
+	dstMask = dstMaskFirst;
+	dstUnion = 0;
+	dstBits = 0;
+	
+	wt = w;
+	
+	while (wt--)
+	{
+	    if (!srcMask)
+	    {
+		srcBits = READ(s++);
+		if (srcBpp == 24)
+		    srcMask0 = FbNext24Pix(srcMask0) & FbBitsMask(0,24);
+		srcMask = srcMask0;
+	    }
+	    if (!dstMask)
+	    {
+		WRITE(d, FbStippleRRopMask(READ(d), dstBits,
+					   fgand, fgxor, bgand, bgxor,
+					   dstUnion));
+		d++;
+		dstMask = FbStipMask(0,1);
+		dstUnion = 0;
+		dstBits = 0;
+	    }
+	    if (srcBits & srcMask)
+		dstBits |= dstMask;
+	    dstUnion |= dstMask;
+	    if (srcBpp == FB_UNIT)
+		srcMask = 0;
+	    else
+		srcMask = FbScrRight(srcMask,srcBpp);
+	    dstMask = FbStipRight(dstMask,1);
+	}
+	if (dstUnion)
+	    WRITE(d, FbStippleRRopMask(READ(d),dstBits,
+				       fgand, fgxor, bgand, bgxor,
+				       dstUnion));
+    }
+}
+