e:/XFree86 for RH 8.0/XFree86-4.2.0/xc/programs/Xserver/fb/fbbltone.c

Go to the documentation of this file.

/*
 * Id: fbbltone.c,v 1.1 1999/11/02 03:54:45 keithp Exp $
 *
 * 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.
 */
/* $XFree86: xc/programs/Xserver/fb/fbbltone.c,v 1.11 2001/09/07 15:15:31 keithp Exp $ */

#include "fb.h"

/*
 *  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++; \
        bits = (FbStipLeft (bitsLeft, leftShift) | \
                FbStipRight(bitsRight, rightShift)); \
        bitsLeft = bitsRight; \
    } else \
        bits = *src++; \
}
    
#ifndef FBNOPIXADDR
    
#define LaneCases1(n,a)     case n: (void)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
};
#endif

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;
    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 */
#ifndef FBNOPIXADDR
    CARD8           *fbLane;
#endif
    int             startbyte, endbyte;

#ifdef FB_24BIT
    if (dstBpp == 24)
    {
        fbBltOne24 (src, srcStride, srcX,
                    dst, dstStride, dstX, dstBpp,
                    width, height,
                    fgand, fgxor, bgand, bgxor);
        return;
    }
#endif
    
    /*
     * 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];
#ifndef FBNOPIXADDR
    fbLane = 0;
    if (transparent && fgand == 0 && dstBpp >= 8)
        fbLane = fbLaneTable[dstBpp];
#endif
    
    /*
     * 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 = *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)];
#ifndef FBNOPIXADDR             
                if (fbLane)
                {
                    fbTransparentSpan (dst, mask & startmask, fgxor, 1);
                }
                else
#endif
                {
                    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)];
                        *dst = FbOpaqueStipple (mask, fgxor, bgxor);
                        dst++;
                        bits = FbStipLeft(bits, pixelsPerDst);
                    }
                }
                else
                {
#ifndef FBNOPIXADDR
                    if (fbLane)
                    {
                        while (bits && n)
                        {
                            switch (fbLane[FbLeftStipBits(bits,pixelsPerDst)]) {
                                LaneCases((CARD8 *) dst);
                            }
                            bits = FbStipLeft(bits,pixelsPerDst);
                            dst++;
                            n--;
                        }
                        dst += n;
                    }
                    else
#endif
                    {
                        while (n--)
                        {
                            left = FbLeftStipBits(bits,pixelsPerDst);
                            if (left || !transparent)
                            {
                                mask = fbBits[left];
                                *dst = FbStippleRRop (*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)];
#ifndef FBNOPIXADDR
            if (fbLane)
            {
                fbTransparentSpan (dst, mask & endmask, fgxor, 1);
            }
            else
#endif
            {
                if (mask || !transparent)
                    FbDoRightMaskByteStippleRRop (dst, mask, 
                                                  fgand, fgxor, bgand, bgxor,
                                                  endbyte, endmask);
            }
        }
        dst += dstStride;
        src += srcStride;
    }
}

#ifdef FB_24BIT

/*
 * 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 ? \
                      0xffffff >> Mask24Neg (x,r) : \
                      0xffffff << 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) (((left) >> (new)) | \
                                             (right) << (FbStip24Len - (new)))
#else
#define FbMergeStip24Bits(left, right, new) (((left << new) & \
                                              ((1 << FbStip24Len) - 1)) | \
                                             right)
#endif

#define fbFirstStipBits(len,stip) {\
    int __len = (len); \
    if (len <= remain) { \
        stip = FbLeftStipBits(bits, len); \
    } else { \
        stip = FbLeftStipBits(bits, remain); \
        bits = *src++; \
        __len = (len) - remain; \
        stip |= FbStipRight(FbLeftStipBits(bits, __len), remain); \
        remain = FB_STIP_UNIT; \
    } \
    bits = FbStipLeft (bits, __len); \
    remain -= __len; \
}

#define fbInitStipBits(offset,len,stip) {\
    bits = FbStipLeft (*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;
    FbBits      leftMask, rightMask, mask;
    int         nlMiddle, nl;
    FbStip      stip, bits;
    int         remain;
    int         dstS;
    int         firstlen;
    int         rot0, rot;
    int         nDst;
    
    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];
                *dst = (*dst & ~leftMask) | (FbOpaqueStipple (mask,
                                                              FbRot24(fgxor, rot),
                                                              FbRot24(bgxor, rot))
                                             & leftMask);
                dst++;
                fbNextStipBits(rot,stip);
            }
            nl = nlMiddle;
            while (nl--)
            {
                mask = fbStipple24Bits[rot>>3][stip];
                *dst = FbOpaqueStipple (mask, 
                                        FbRot24(fgxor, rot),
                                        FbRot24(bgxor, rot));
                dst++;
                fbNextStipBits(rot,stip);
            }
            if (rightMask)
            {
                mask = fbStipple24Bits[rot >> 3][stip];
                *dst = (*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;
                    *dst = (*dst & ~mask) | (FbRot24(fgxor, rot) & mask);
                }
                dst++;
                fbNextStipBits (rot, stip);
            }
            nl = nlMiddle;
            while (nl--)
            {
                if (stip)
                {
                    mask = fbStipple24Bits[rot>>3][stip];
                    *dst = (*dst & ~mask) | (FbRot24(fgxor,rot) & mask);
                }
                dst++;
                fbNextStipBits (rot, stip);
            }
            if (rightMask)
            {
                if (stip)
                {
                    mask = fbStipple24Bits[rot >> 3][stip] & rightMask;
                    *dst = (*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];
                *dst = FbStippleRRopMask (*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];
                *dst = FbStippleRRop (*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];
                *dst = FbStippleRRopMask (*dst, mask,
                                          FbRot24(fgand, rot),
                                          FbRot24(fgxor, rot),
                                          FbRot24(bgand, rot),
                                          FbRot24(bgxor, rot),
                                          rightMask);
            }
            dst += dstStride;
        }
    }
}
#endif

/*
 * 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);
#ifdef FB_24BIT
    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
#endif
    {
        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;
#ifdef FB_24BIT
        if (srcBpp == 24)
            srcMask0 = FbRot24(pm,rot0) & FbBitsMask(0, srcBpp);
#endif
        srcBits = *s++;

        dstMask = dstMaskFirst;
        dstUnion = 0;
        dstBits = 0;
        
        wt = w;
        
        while (wt--)
        {
            if (!srcMask)
            {
                srcBits = *s++;
#ifdef FB_24BIT
                if (srcBpp == 24)
                    srcMask0 = FbNext24Pix(srcMask0) & FbBitsMask(0,24);
#endif
                srcMask = srcMask0;
            }
            if (!dstMask)
            {
                *d = FbStippleRRopMask(*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)
            *d = FbStippleRRopMask(*d,dstBits,
                                   fgand, fgxor, bgand, bgxor,
                                   dstUnion);
    }
}

---