/*      $NetBSD: raster_op.c,v 1.19 2012/01/31 04:28:02 matt Exp $ */

/*-
 * Copyright (c) 1991, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to the Computer Systems
 * Engineering Group at Lawrence Berkeley Laboratory and to the University
 * of California at Berkeley by Jef Poskanzer.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *      @(#)raster_op.c 8.1 (Berkeley) 6/11/93
 */

/*
 * Bitblit routine for raster library.
 *
 * This raster-op is machined to exacting tolerances by skilled native
 * craftsmen with pride in their work.
 *
 * The various cases are broken down like this:
 *
 *   src required
 *       1-bit to 1-bit
 *       1-bit to 2-bits
 *       1-bit to 4-bits
 *       1-bit to 8-bits
 *       1-bit to 16-bits
 *       2-bits to 2-bits
 *       2-bits to 4-bits (not implemented)
 *       2-bits to 8-bits (not implemented)
 *       2-bits to 16-bits (not implemented)
 *       4-bits to 4-bits
 *       4-bits to 8-bits (not implemented)
 *       4-bits to 16-bits (not implemented)
 *       8-bits to 8-bits
 *       8-bits to 16-bits (not implemented)
 *       16-bits to 16-bits
 *   no src required
 *       1-bit no-src
 *       2-bits no-src
 *       8-bits no-src
 *       16-bits no-src
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: raster_op.c,v 1.19 2012/01/31 04:28:02 matt Exp $");

#include <sys/types.h>
#ifdef _KERNEL
#include "opt_rcons.h"
#include <dev/rcons/raster.h>
#else
#include "raster.h"
#endif

/* CONFIGURE: To save on executable size, you can configure out the seldom-used
** logical operations.  With this variable set, the only operations implemented
** are: RAS_SRC, RAS_CLEAR, RAS_SET, RAS_INVERT, RAS_XOR, RAS_INVERTSRC.
*/
#ifdef _KERNEL
#define PARTIAL_LOGICAL_OPS
#endif

/* CONFIGURE: bcopy() is supposed to be the ultimately fastest way to move
** bytes, overlapping or not, ignoring the startup cost.  Unfortunately
** this is not true on some systems.  For example, on a Sun 3 running
** SunOS 3.5, bcopy() is about five times slower than a simple for loop
** on overlapping copies.  And on a 4.1.1 SPARC, bcopy() is about 2/3rds
** as fast on backwards overlaps.  So, only define this if your bcopy is ok.
*/
#undef BCOPY_FASTER

/* End of configurable definitions. */


/* Definitions. */

/* Raster-op macros.  These encapsulate the switch statements and so make
** the source code 16 times smaller.  The pre and pst args are code
** fragments to put before and after the assignment in each case.  They
** can be the beginning and end of a loop.  If the pst fragment includes a
** masked assignment, for example to handle the left or right edge cases,
** a good optimizing compiler will simplify the boolean expressions very
** nicely - both cc and gcc on the SPARC will do this.
*/

#ifndef PARTIAL_LOGICAL_OPS

#define ROP_DST(op,pre,d,pst) \
    switch ( op ) \
        { \
        case RAS_CLEAR: \
        pre \
        (d) = 0; \
        pst \
        break; \
        case RAS_INVERT: \
        pre \
        (d) = ~(d); \
        pst \
        break; \
        case RAS_DST: \
        /* noop */ \
        break; \
        case RAS_SET: \
        pre \
        (d) = ~0; \
        pst \
        break; \
        default: \
        return -1; \
        }

#define ROP_DSTCOLOR(op,pre,d,c,pst) \
    switch ( op ) \
        { \
        case RAS_CLEAR: \
        pre \
        (d) = 0; \
        pst \
        break; \
        case RAS_INVERT: \
        pre \
        (d) = ~(d); \
        pst \
        break; \
        case RAS_DST: \
        /* noop */ \
        break; \
        case RAS_SET: \
        pre \
        (d) = (c); \
        pst \
        break; \
        default: \
        return -1; \
        }

#define ROP_SRCDST(op,pre,s,d,pst) \
    switch ( op ) \
        { \
        case RAS_NOTOR: \
        pre \
        (d) = ~( (s) | (d) ); \
        pst \
        break; \
        case RAS_NOTSRC_AND_DST: \
        pre \
        (d) = ~(s) & (d); \
        pst \
        break; \
        case RAS_INVERTSRC: \
        pre \
        (d) = ~(s); \
        pst \
        break; \
        case RAS_SRC_AND_NOTDST: \
        pre \
        (d) = (s) & ~(d); \
        pst \
        break; \
        case RAS_XOR: \
        pre \
        (d) = (s) ^ (d); \
        pst \
        break; \
        case RAS_NOTAND: \
        pre \
        (d) = ~( (s) & (d) ); \
        pst \
        break; \
        case RAS_AND: \
        pre \
        (d) = (s) & (d); \
        pst \
        break; \
        case RAS_NOTXOR: \
        pre \
        (d) = ~( (s) ^ (d) ); \
        pst \
        break; \
        case RAS_NOTSRC_OR_DST: \
        pre \
        (d) = ~(s) | (d); \
        pst \
        break; \
        case RAS_SRC: \
        pre \
        (d) = (s); \
        pst \
        break; \
        case RAS_SRC_OR_NOTDST: \
        pre \
        (d) = (s) | ~(d); \
        pst \
        break; \
        case RAS_OR: \
        pre \
        (d) = (s) | (d); \
        pst \
        break; \
        default: \
        return -1; \
        }

#define ROP_SRCDSTCOLOR(op,pre,s,d,c,pst) \
    switch ( op ) \
        { \
        case RAS_NOTOR: \
        pre \
        if ( s ) \
            (d) = ~( (c) | (d) ); \
        else \
            (d) = ~(d); \
        pst \
        break; \
        case RAS_NOTSRC_AND_DST: \
        pre \
        if ( s ) \
            (d) = ~(c) & (d); \
        pst \
        break; \
        case RAS_INVERTSRC: \
        pre \
        if ( s ) \
            (d) = ~(c); \
        else \
            (d) = ~0; \
        pst \
        break; \
        case RAS_SRC_AND_NOTDST: \
        pre \
        if ( s ) \
            (d) = (c) & ~(d); \
        else \
            (d) = 0; \
        pst \
        break; \
        case RAS_XOR: \
        pre \
        if ( s ) \
            (d) = (c) ^ (d); \
        pst \
        break; \
        case RAS_NOTAND: \
        pre \
        if ( s ) \
            (d) = ~( (c) & (d) ); \
        else \
            (d) = ~0; \
        pst \
        break; \
        case RAS_AND: \
        pre \
        if ( s ) \
            (d) = (c) & (d); \
        else \
            (d) = 0; \
        pst \
        break; \
        case RAS_NOTXOR: \
        pre \
        if ( s ) \
            (d) = ~( (c) ^ (d) ); \
        else \
            (d) = ~(d); \
        pst \
        break; \
        case RAS_NOTSRC_OR_DST: \
        pre \
        if ( s ) \
            (d) = ~(c) | (d); \
        else \
            (d) = ~0; \
        pst \
        break; \
        case RAS_SRC: \
        pre \
        if ( s ) \
            (d) = (c); \
        else \
            (d) = 0; \
        pst \
        break; \
        case RAS_SRC_OR_NOTDST: \
        pre \
        if ( s ) \
            (d) = (c) | ~(d); \
        else \
            (d) = ~(d); \
        pst \
        break; \
        case RAS_OR: \
        pre \
        if ( s ) \
            (d) = (c) | (d); \
        pst \
        break; \
        default: \
        return -1; \
        }

#else /*PARTIAL_LOGICAL_OPS*/

#define ROP_DST(op,pre,d,pst) \
    switch ( op ) \
        { \
        case RAS_CLEAR: \
        pre \
        (d) = 0; \
        pst \
        break; \
        case RAS_INVERT: \
        pre \
        (d) = ~(d); \
        pst \
        break; \
        case RAS_SET: \
        pre \
        (d) = ~0; \
        pst \
        break; \
        default: \
        return -1; \
        }

#define ROP_DSTCOLOR(op,pre,d,c,pst) \
    switch ( op ) \
        { \
        case RAS_CLEAR: \
        pre \
        (d) = 0; \
        pst \
        break; \
        case RAS_INVERT: \
        pre \
        (d) = ~(d); \
        pst \
        break; \
        case RAS_SET: \
        pre \
        (d) = (c); \
        pst \
        break; \
        default: \
        return -1; \
        }

#define ROP_SRCDST(op,pre,s,d,pst) \
    switch ( op ) \
        { \
        case RAS_INVERTSRC: \
        pre \
        (d) = ~(s); \
        pst \
        break; \
        case RAS_XOR: \
        pre \
        (d) = (s) ^ (d); \
        pst \
        break; \
        case RAS_SRC: \
        pre \
        (d) = (s); \
        pst \
        break; \
        default: \
        return -1; \
        }

#define ROP_SRCDSTCOLOR(op,pre,s,d,c,pst) \
    switch ( op ) \
        { \
        case RAS_INVERTSRC: \
        pre \
        if ( s ) \
            (d) = ~(c); \
        else \
            (d) = ~0; \
        pst \
        break; \
        case RAS_XOR: \
        pre \
        if ( s ) \
            (d) = (c) ^ (d); \
        pst \
        break; \
        case RAS_SRC: \
        pre \
        if ( s ) \
            (d) = (c); \
        else \
            (d) = 0; \
        pst \
        break; \
        default: \
        return -1; \
        }

#endif /*PARTIAL_LOGICAL_OPS*/


/* Variables. */

static int needsrc[16] = { 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0 };
/*                       CLEAR          INVERT          DST            SET */

#ifdef MSBIT_FIRST

u_int32_t raster_bitmask[32] = {
    0x80000000, 0x40000000, 0x20000000, 0x10000000,
    0x08000000, 0x04000000, 0x02000000, 0x01000000,
    0x00800000, 0x00400000, 0x00200000, 0x00100000,
    0x00080000, 0x00040000, 0x00020000, 0x00010000,
    0x00008000, 0x00004000, 0x00002000, 0x00001000,
    0x00000800, 0x00000400, 0x00000200, 0x00000100,
    0x00000080, 0x00000040, 0x00000020, 0x00000010,
    0x00000008, 0x00000004, 0x00000002, 0x00000001 };

#ifdef MSBYTE_FIRST
static u_int32_t leftmask[32] = {
    0x00000000, 0x80000000, 0xc0000000, 0xe0000000,
    0xf0000000, 0xf8000000, 0xfc000000, 0xfe000000,
    0xff000000, 0xff800000, 0xffc00000, 0xffe00000,
    0xfff00000, 0xfff80000, 0xfffc0000, 0xfffe0000,
    0xffff0000, 0xffff8000, 0xffffc000, 0xffffe000,
    0xfffff000, 0xfffff800, 0xfffffc00, 0xfffffe00,
    0xffffff00, 0xffffff80, 0xffffffc0, 0xffffffe0,
    0xfffffff0, 0xfffffff8, 0xfffffffc, 0xfffffffe };
static u_int32_t rightmask[32] = {
    0x00000000, 0x00000001, 0x00000003, 0x00000007,
    0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
    0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
    0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
    0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
    0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
    0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
    0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff };

#define LSOP <<
#define RSOP >>
#endif /*MSBYTE_FIRST*/

#else /*MSBIT_FIRST*/

u_int32_t raster_bitmask[32] = {
    0x00000001, 0x00000002, 0x00000004, 0x00000008,
    0x00000010, 0x00000020, 0x00000040, 0x00000080,
    0x00000100, 0x00000200, 0x00000400, 0x00000800,
    0x00001000, 0x00002000, 0x00004000, 0x00008000,
    0x00010000, 0x00020000, 0x00040000, 0x00080000,
    0x00100000, 0x00200000, 0x00400000, 0x00800000,
    0x01000000, 0x02000000, 0x04000000, 0x08000000,
    0x10000000, 0x20000000, 0x40000000, 0x80000000 };

#ifndef MSBYTE_FIRST
static u_int32_t leftmask[32] = {
    0x00000000, 0x00000001, 0x00000003, 0x00000007,
    0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
    0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
    0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
    0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
    0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
    0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
    0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff };
static u_int32_t rightmask[32] = {
    0x00000000, 0x80000000, 0xc0000000, 0xe0000000,
    0xf0000000, 0xf8000000, 0xfc000000, 0xfe000000,
    0xff000000, 0xff800000, 0xffc00000, 0xffe00000,
    0xfff00000, 0xfff80000, 0xfffc0000, 0xfffe0000,
    0xffff0000, 0xffff8000, 0xffffc000, 0xffffe000,
    0xfffff000, 0xfffff800, 0xfffffc00, 0xfffffe00,
    0xffffff00, 0xffffff80, 0xffffffc0, 0xffffffe0,
    0xfffffff0, 0xfffffff8, 0xfffffffc, 0xfffffffe };
#define LSOP >>
#define RSOP <<
#endif /*not MSBYTE_FIRST*/

#endif /*MSBIT_FIRST*/

/* (The odd combinations MSBIT+~MSBYTE and ~MSBIT+MSBYTE could be added.) */

#ifdef MSBYTE_FIRST
static u_int32_t bytemask[4] = { 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff };
#ifdef RCONS_2BPP
static u_int32_t twobitmask[16] = {
  0xc0000000, 0x30000000, 0x0c000000, 0x03000000,
  0x00c00000, 0x00300000, 0x000c0000, 0x00030000,
  0x0000c000, 0x00003000, 0x00000c00, 0x00000300,
  0x000000c0, 0x00000030, 0x0000000c, 0x00000003 };
#endif /* RCONS_2BPP */
#ifdef RCONS_4BPP
static u_int32_t fourbitmask[8] = {
  0xf0000000, 0x0f000000,
  0x00f00000, 0x000f0000,
  0x0000f000, 0x00000f00,
  0x000000f0, 0x0000000f };
#endif /* RCONS_4BPP */
#ifdef RCONS_16BPP
static u_int32_t twobytemask[2] = { 0xffff0000, 0x0000ffff };
#endif /* RCONS_16BPP */
#else /*MSBYTE_FIRST*/
static u_int32_t bytemask[4] = { 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
#ifdef RCONS_2BPP
static u_int32_t twobitmask[16] = {
  0x00000003, 0x0000000c, 0x00000030, 0x000000c0,
  0x00000300, 0x00000c00, 0x00003000, 0x0000c000,
  0x00030000, 0x000c0000, 0x00300000, 0x00c00000,
  0x03000000, 0x0c000000, 0x30000000, 0xc0000000 };
#endif /* RCONS_2BPP */
#ifdef RCONS_4BPP
static u_int32_t fourbitmask[16] = {
  0x0000000f, 0x000000f0,
  0x00000f00, 0x0000f000,
  0x000f0000, 0x00f00000,
  0x0f000000, 0xf0000000 };
#endif /* RCONS_4BPP */
#ifdef RCONS_16BPP
static u_int32_t twobytemask[2] = { 0x0000ffff, 0xffff0000 };
#endif /* RCONS_16BPP */
#endif /*MSBYTE_FIRST*/


/* Forward routines. */

static int raster_blit(struct raster *, u_int32_t *, int, int, int,
                        struct raster *, u_int32_t *, int, int, int,
                        int, int);

/* Raster operations.  */

/* Performs a bitblit.  Returns 0 on success, -1 on failure. */
int
raster_op(struct raster* dst, int dx, int dy, int w, int h, int rop,
    struct raster* src, int sx, int sy)
    {
    if ( dst == (struct raster*) 0 )
        return -1;                      /* no destination */

    if ( needsrc[RAS_GETOP( rop )] )
        {
        /* Two-operand blit. */
        if ( src == (struct raster*) 0 )
            return -1;                  /* no source */

        /* Clip against source. */
        if ( sx < 0 )
            {
            w += sx;
            sx = 0;
            }
        if ( sy < 0 )
            {
            h += sy;
            sy = 0;
            }
        if ( sx + w > src->width )
            w = src->width - sx;
        if ( sy + h > src->height )
            h = src->height - sy;

        /* Clip against dest. */
        if ( dx < 0 )
            {
            w += dx;
            sx -= dx;
            dx = 0;
            }
        if ( dy < 0 )
            {
            h += dy;
            sy -= dy;
            dy = 0;
            }
        if ( dx + w > dst->width )
            w = dst->width - dx;
        if ( dy + h > dst->height )
            h = dst->height - dy;

        if ( w <= 0 || h <= 0 )
            return 0;                   /* nothing to do */

        return raster_op_noclip( dst, dx, dy, w, h, rop, src, sx, sy );
        }

    /* No source necessary - one-operand blit. */
    if ( src != (struct raster*) 0 )
        return -1;                      /* unwanted source */

    /* Clip against dest. */
    if ( dx < 0 )
        {
        w += dx;
        dx = 0;
        }
    if ( dy < 0 )
        {
        h += dy;
        dy = 0;
        }
    if ( dx + w > dst->width )
        w = dst->width - dx;
    if ( dy + h > dst->height )
        h = dst->height - dy;

    if ( w <= 0 || h <= 0 )
        return 0;                       /* nothing to do */

    return raster_op_nosrc_noclip( dst, dx, dy, w, h, rop );
    }

/* Semi-public routine to do a bitblit without clipping.  Returns 0 on
** success, -1 on failure.
*/
int
raster_op_noclip(struct raster* dst, int dx, int dy, int w, int h, int rop,
    struct raster* src, int sx, int sy)
    {
    int op;

    op = RAS_GETOP( rop );

    if ( src->depth == 1 )
        {
        /* One-bit to ? blit. */
        if ( dst->depth == 1 )
            {
            /* One to one blit. */
            u_int32_t* srclin1;
            u_int32_t* dstlin1;
            int srcleftignore, srcrightignore, srclongs;
            int dstleftignore, dstrightignore, dstlongs;

            srclin1 = RAS_ADDR( src, sx, sy );
            dstlin1 = RAS_ADDR( dst, dx, dy );

#ifdef BCOPY_FASTER
            /* Special-case full-width to full-width copies. */
            if ( op == RAS_SRC && src->width == w && dst->width == w &&
                 src->linelongs == dst->linelongs && src->linelongs == w >> 5 )
                {
                bcopy(
                    (char*) srclin1, (char*) dstlin1,
                    h * src->linelongs * sizeof(u_int32_t) );
                return 0;
                }
#endif /*BCOPY_FASTER*/

            srcleftignore = ( sx & 31 );
            srclongs = ( srcleftignore + w + 31 ) >> 5;
            srcrightignore = ( srclongs * 32 - w - srcleftignore ) & 31;
            dstleftignore = ( dx & 31 );
            dstlongs = ( dstleftignore + w + 31 ) >> 5;
            dstrightignore = ( dstlongs * 32 - w - dstleftignore ) & 31;

            return raster_blit(
                src, srclin1, srcleftignore, srcrightignore, srclongs,
                dst, dstlin1, dstleftignore, dstrightignore, dstlongs, h, op );
            }

#ifdef RCONS_2BPP
        else if ( dst->depth == 2 )
          {
            /* One to two, using the color in the rop.  */
            u_int32_t* srclin1;
            u_int32_t* dstlin1;
            u_int32_t* srclin2;
            u_int32_t* srclin;
            u_int32_t* dstlin;
            u_int32_t* srclong;
            u_int32_t* dstlong;
            u_int32_t color, dl;
            int srcbit, dstbyte, i;

            color = RAS_GETCOLOR( rop );
            if ( color == 0 )
              color = 3;

            /* Make 32 bits of color so we can do the ROP without shifting. */
            color |= (( color << 30 ) | ( color << 28 ) | ( color << 26 )
                      | ( color << 24 ) | ( color << 22 ) | ( color << 20 )
                      | ( color << 18 ) | ( color << 16 ) | ( color << 14 )
                      | ( color << 12 ) | ( color << 10 ) | ( color << 8 )
                      | ( color << 6 ) | ( color << 4 ) | ( color << 2 ));

            /* Don't have to worry about overlapping blits here. */
            srclin1 = RAS_ADDR( src, sx, sy );
            srclin2 = srclin1 + h * src->linelongs;
            dstlin1 = RAS_ADDR( dst, dx, dy );
            srclin = srclin1;
            dstlin = dstlin1;

            while ( srclin != srclin2 )
                {
                srclong = srclin;
                srcbit = sx & 31;
                dstlong = dstlin;
                dstbyte = dx & 15;
                i = w;

                /* WARNING: this code is KNOWN TO FAIL on Sun 3's / CG2's. */
                ROP_SRCDSTCOLOR(
                /*op*/  op,
                /*pre*/ while ( i > 0 )
                            {
                            dl = *dstlong;,
                /*s*/       *srclong & raster_bitmask[srcbit],
                /*d*/       dl,
                /*c*/       color,
                /*pst*/     *dstlong = ( *dstlong & ~twobitmask[dstbyte] ) |
                                       ( dl & twobitmask[dstbyte] );
                            if ( srcbit == 31 )
                                {
                                srcbit = 0;
                                ++srclong;
                                }
                            else
                                ++srcbit;
                            if ( dstbyte == 15 )
                                {
                                dstbyte = 0;
                                ++dstlong;
                                }
                            else
                                ++dstbyte;
                            --i;
                            } )

                srclin += src->linelongs;
                dstlin += dst->linelongs;
                }
          }
#endif /* RCONS_2BPP */
#ifdef RCONS_4BPP
        else if ( dst->depth == 4 )
          {
            /* One to four, using the color in the rop.  */
            u_int32_t* srclin1;
            u_int32_t* dstlin1;
            u_int32_t* srclin2;
            u_int32_t* srclin;
            u_int32_t* dstlin;
            u_int32_t* srclong;
            u_int32_t* dstlong;
            u_int32_t color, dl;
            int srcbit, dstbyte, i;

            color = RAS_GETCOLOR( rop );
            if ( color == 0 )
              color = 15;

            /* Make 32 bits of color so we can do the ROP without shifting. */
            color |= (( color << 28 ) | ( color << 24 )
                      | ( color << 20 ) | ( color << 16 )
                      | ( color << 12 ) | ( color << 8 )
                      | ( color << 4 ));

            /* Don't have to worry about overlapping blits here. */
            srclin1 = RAS_ADDR( src, sx, sy );
            srclin2 = srclin1 + h * src->linelongs;
            dstlin1 = RAS_ADDR( dst, dx, dy );
            srclin = srclin1;
            dstlin = dstlin1;

            while ( srclin != srclin2 )
                {
                srclong = srclin;
                srcbit = sx & 31;
                dstlong = dstlin;
                dstbyte = dx & 7;
                i = w;

                /* WARNING: this code is KNOWN TO FAIL on Sun 3's / CG2's. */
                ROP_SRCDSTCOLOR(
                /*op*/  op,
                /*pre*/ while ( i > 0 )
                            {
                            dl = *dstlong;,
                /*s*/       *srclong & raster_bitmask[srcbit],
                /*d*/       dl,
                /*c*/       color,
                /*pst*/     *dstlong = ( *dstlong & ~fourbitmask[dstbyte] ) |
                                       ( dl & fourbitmask[dstbyte] );
                            if ( srcbit == 31 )
                                {
                                srcbit = 0;
                                ++srclong;
                                }
                            else
                                ++srcbit;
                            if ( dstbyte == 7 )
                                {
                                dstbyte = 0;
                                ++dstlong;
                                }
                            else
                                ++dstbyte;
                            --i;
                            } )

                srclin += src->linelongs;
                dstlin += dst->linelongs;
                }
          }
#endif /* RCONS_4BPP */
        else if ( dst->depth == 8 )
            {
            /* One to eight, using the color in the rop.  This could
            ** probably be sped up by handling each four-bit source nybble
            ** as a group, indexing into a 16-element runtime-constructed
            ** table of longwords.
            */
            u_int32_t* srclin1;
            u_int32_t* dstlin1;
            u_int32_t* srclin2;
            u_int32_t* srclin;
            u_int32_t* dstlin;
            u_int32_t* srclong;
            u_int32_t* dstlong;
            u_int32_t color, dl;
            int srcbit, dstbyte, i;

            color = RAS_GETCOLOR( rop );
            if ( color == 0 )
                color = 255;

            /* Make 32 bits of color so we can do the ROP without shifting. */
            color |= ( color << 24 ) | ( color << 16 ) | ( color << 8 );

            /* Don't have to worry about overlapping blits here. */
            srclin1 = RAS_ADDR( src, sx, sy );
            srclin2 = srclin1 + h * src->linelongs;
            dstlin1 = RAS_ADDR( dst, dx, dy );
            srclin = srclin1;
            dstlin = dstlin1;
            while ( srclin != srclin2 )
                {
                srclong = srclin;
                srcbit = sx & 31;
                dstlong = dstlin;
                dstbyte = dx & 3;
                i = w;

                /* WARNING: this code is KNOWN TO FAIL on Sun 3's / CG2's. */
                ROP_SRCDSTCOLOR(
                /*op*/  op,
                /*pre*/ while ( i > 0 )
                            {
                            dl = *dstlong;,
                /*s*/       *srclong & raster_bitmask[srcbit],
                /*d*/       dl,
                /*c*/       color,
                /*pst*/     *dstlong = ( *dstlong & ~bytemask[dstbyte] ) |
                                       ( dl & bytemask[dstbyte] );
                            if ( srcbit == 31 )
                                {
                                srcbit = 0;
                                ++srclong;
                                }
                            else
                                ++srcbit;
                            if ( dstbyte == 3 )
                                {
                                dstbyte = 0;
                                ++dstlong;
                                }
                            else
                                ++dstbyte;
                            --i;
                            } )

                srclin += src->linelongs;
                dstlin += dst->linelongs;
                }
            }
#ifdef RCONS_16BPP
        else
            {
            /* One to sixteen, using the color in the rop.  This could
            ** probably be sped up by handling each four-bit source nybble
            ** as a group, indexing into a 16-element runtime-constructed
            ** table of longwords.
            */
            u_int32_t* srclin1;
            u_int32_t* dstlin1;
            u_int32_t* srclin2;
            u_int32_t* srclin;
            u_int32_t* dstlin;
            u_int32_t* srclong;
            u_int32_t* dstlong;
            u_int32_t color, dl;
            int srcbit, dstbyte, i;

            color = RAS_GETCOLOR( rop );
            if ( color == 0 )
                color = 0xffff;

            /* Make 32 bits of color so we can do the ROP without shifting. */
            color |= ( color << 16 );

            /* Don't have to worry about overlapping blits here. */
            srclin1 = RAS_ADDR( src, sx, sy );
            srclin2 = srclin1 + h * src->linelongs;
            dstlin1 = RAS_ADDR( dst, dx, dy );
            srclin = srclin1;
            dstlin = dstlin1;
            while ( srclin != srclin2 )
                {
                srclong = srclin;
                srcbit = sx & 31;
                dstlong = dstlin;
                dstbyte = dx & 1;
                i = w;

                /* WARNING: this code is KNOWN TO FAIL on Sun 3's / CG2's. */
                ROP_SRCDSTCOLOR(
                /*op*/  op,
                /*pre*/ while ( i > 0 )
                            {
                            dl = *dstlong;,
                /*s*/       *srclong & raster_bitmask[srcbit],
                /*d*/       dl,
                /*c*/       color,
                /*pst*/     *dstlong = ( *dstlong & ~twobytemask[dstbyte] ) |
                                       ( dl & twobytemask[dstbyte] );
                            if ( srcbit == 31 )
                                {
                                srcbit = 0;
                                ++srclong;
                                }
                            else
                                ++srcbit;
                            if ( dstbyte == 1 )
                                {
                                dstbyte = 0;
                                ++dstlong;
                                }
                            else
                                ++dstbyte;
                            --i;
                            } )

                srclin += src->linelongs;
                dstlin += dst->linelongs;
                }
            }
#endif /* RCONS_16BPP */
        }
#ifdef RCONS_2BPP
    else if ( src->depth == 2 )
      {
        /* Two to two blit. */
            u_int32_t* srclin1;
            u_int32_t* dstlin1;
            int srcleftignore, srcrightignore, srclongs;
            int dstleftignore, dstrightignore, dstlongs;

            srclin1 = RAS_ADDR( src, sx, sy );
            dstlin1 = RAS_ADDR( dst, dx, dy );

            srcleftignore = ( sx & 15 ) * 2;
            srclongs = ( srcleftignore + w * 2 + 31 ) >> 5;
            srcrightignore = ( srclongs * 32 - w * 2 - srcleftignore ) & 31;
            dstleftignore = ( dx & 15 ) * 2;
            dstlongs = ( dstleftignore + w * 2 + 31 ) >> 5;
            dstrightignore = ( dstlongs * 32 - w * 2 - dstleftignore ) & 31;

            return raster_blit(
                src, srclin1, srcleftignore, srcrightignore, srclongs,
                dst, dstlin1, dstleftignore, dstrightignore, dstlongs, h, op );
            }
#endif /* RCONS_2BPP */
#ifdef RCONS_4BPP
    else if ( src->depth == 4 )
      {
        /* Four to four blit. */
            u_int32_t* srclin1;
            u_int32_t* dstlin1;
            int srcleftignore, srcrightignore, srclongs;
            int dstleftignore, dstrightignore, dstlongs;

            srclin1 = RAS_ADDR( src, sx, sy );
            dstlin1 = RAS_ADDR( dst, dx, dy );

            srcleftignore = ( sx & 7 ) * 4;
            srclongs = ( srcleftignore + w * 4 + 31 ) >> 5;
            srcrightignore = ( srclongs * 32 - w * 4 - srcleftignore ) & 31;
            dstleftignore = ( dx & 7 ) * 4;
            dstlongs = ( dstleftignore + w * 4 + 31 ) >> 5;
            dstrightignore = ( dstlongs * 32 - w * 4 - dstleftignore ) & 31;

            return raster_blit(
                src, srclin1, srcleftignore, srcrightignore, srclongs,
                dst, dstlin1, dstleftignore, dstrightignore, dstlongs, h, op );
            }
#endif /* RCONS_4BPP */

    else if ( src->depth == 8 )
        {
        /* Eight to eight blit. */
        u_int32_t* srclin1;
        u_int32_t* dstlin1;
        int srcleftignore, srcrightignore, srclongs;
        int dstleftignore, dstrightignore, dstlongs;

        if ( dst->depth != 8 )
            return -1;          /* depth mismatch */

        srclin1 = RAS_ADDR( src, sx, sy );
        dstlin1 = RAS_ADDR( dst, dx, dy );

#ifdef BCOPY_FASTER
        /* Special-case full-width to full-width copies. */
        if ( op == RAS_SRC && src->width == w && dst->width == w &&
             src->linelongs == dst->linelongs && src->linelongs == w >> 2 )
            {
            bcopy( (char*) srclin1, (char*) dstlin1,
                   h * src->linelongs * sizeof(u_int32_t) );
            return 0;
            }
#endif /*BCOPY_FASTER*/

        srcleftignore = ( sx & 3 ) * 8;
        srclongs = ( srcleftignore + w * 8 + 31 ) >> 5;
        srcrightignore = ( srclongs * 32 - w * 8 - srcleftignore ) & 31;
        dstleftignore = ( dx & 3 ) * 8;
        dstlongs = ( dstleftignore + w * 8 + 31 ) >> 5;
        dstrightignore = ( dstlongs * 32 - w * 8 - dstleftignore ) & 31;

        return raster_blit(
            src, srclin1, srcleftignore, srcrightignore, srclongs,
            dst, dstlin1, dstleftignore, dstrightignore, dstlongs, h, op );
        }
#ifdef RCONS_16BPP
    else
        {
        /* Sixteen to sixteen blit. */
            u_int32_t* srclin1;
            u_int32_t* dstlin1;
            int srcleftignore, srcrightignore, srclongs;
            int dstleftignore, dstrightignore, dstlongs;

            srclin1 = RAS_ADDR( src, sx, sy );
            dstlin1 = RAS_ADDR( dst, dx, dy );

            srcleftignore = ( sx & 1 ) * 16;
            srclongs = ( srcleftignore + w * 16 + 31 ) >> 5;
            srcrightignore = ( srclongs * 32 - w * 16 - srcleftignore ) & 31;
            dstleftignore = ( dx & 1 ) * 16;
            dstlongs = ( dstleftignore + w * 16 + 31 ) >> 5;
            dstrightignore = ( dstlongs * 32 - w * 16 - dstleftignore ) & 31;

            return raster_blit(
                src, srclin1, srcleftignore, srcrightignore, srclongs,
                dst, dstlin1, dstleftignore, dstrightignore, dstlongs, h, op );
        }
#endif /* RCONS_16BPP */
    return 0;
    }

/* Semi-public routine to do a no-src bitblit without clipping.  Returns 0
** on success, -1 on failure.
*/
int
raster_op_nosrc_noclip(struct raster* dst,
    int dx, int dy, int w, int h, int rop)
    {
    int op;

    op = RAS_GETOP( rop );

    if ( dst->depth == 1 )
        {
        /* One-bit no-src blit. */
        u_int32_t* dstlin1;
        u_int32_t* dstlin2;
        u_int32_t* dstlin;
        int dstleftignore, dstrightignore, dstlongs;
        u_int32_t dl, lm, nlm, rm, nrm;
        u_int32_t* dstlong2;
        u_int32_t* dstlong;

        dstlin1 = RAS_ADDR( dst, dx, dy );

#ifdef BCOPY_FASTER
        /* Special-case full-width clears. */
        if ( op == RAS_CLEAR && dst->width == w && dst->linelongs == w >> 5 )
            {
            memset( (char*) dstlin1, 0, h * dst->linelongs * sizeof(u_int32_t) );
            return 0;
            }
#endif /*BCOPY_FASTER*/

        dstleftignore = ( dx & 31 );
        dstlongs = ( dstleftignore + w + 31 ) >> 5;
        dstrightignore = ( dstlongs * 32 - w - dstleftignore ) & 31;

        dstlin2 = dstlin1 + h * dst->linelongs;
        dstlin = dstlin1;

        if ( dstlongs == 1 )
            {
            /* It fits into a single longword. */
            lm = leftmask[dstleftignore] | rightmask[dstrightignore];
            nlm = ~lm;
            while ( dstlin != dstlin2 )
                {
                ROP_DST(
                /*op*/  op,
                /*pre*/ dl = *dstlin;,
                /*d*/   dl,
                /*pst*/ *dstlin = ( *dstlin & lm ) | ( dl & nlm ); )

                dstlin += dst->linelongs;
                }
            }
        else
            {
            lm = leftmask[dstleftignore];
            rm = rightmask[dstrightignore];
            nrm = ~rm;
            nlm = ~lm;

            while ( dstlin != dstlin2 )
                {
                dstlong = dstlin;
                dstlong2 = dstlong + dstlongs;
                if ( dstrightignore != 0 )
                    --dstlong2;

                /* Leading edge. */
                if ( dstleftignore != 0 )
                    {
                    ROP_DST(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*pst*/ *dstlong = ( *dstlong & lm ) | ( dl & nlm ); )
                    ++dstlong;
                    }

                /* Main rop. */
                ROP_DST(
                /*op*/  op,
                /*pre*/ while ( dstlong != dstlong2 )
                            {,
                /*d*/       *dstlong,
                /*pst*/     ++dstlong;
                            } )

                /* Trailing edge. */
                if ( dstrightignore != 0 )
                    {
                    ROP_DST(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*pst*/ *dstlong = ( dl & nrm ) | ( *dstlong & rm ); )
                    }

                dstlin += dst->linelongs;
                }
            }
        }

#ifdef RCONS_2BPP
    else if ( dst->depth == 2 )
        {
        /* Two-bit no-src blit. */
        u_int32_t color;
        u_int32_t* dstlin1;
        u_int32_t* dstlin2;
        u_int32_t* dstlin;
        int dstleftignore, dstrightignore, dstlongs;
        u_int32_t dl, lm, nlm, rm, nrm;
        u_int32_t* dstlong2;
        u_int32_t* dstlong;

        dstlin1 = RAS_ADDR( dst, dx, dy );

#ifdef BCOPY_FASTER
        /* Special-case full-width clears. */
        if ( op == RAS_CLEAR && dst->width == w && dst->linelongs == w >> 4 )
            {
            memset( (char*) dstlin1, 0, h * dst->linelongs * sizeof(u_int32_t) );
            return 0;
            }
#endif /*BCOPY_FASTER*/

        color = RAS_GETCOLOR( rop );
        if ( color == 0 )
            color = 3;

        /* Make 32 bits of color so we can do the ROP without shifting. */
        color |= (( color << 30 ) | ( color << 28 ) | ( color << 26 )
                  | ( color << 24 ) | ( color << 22 ) | ( color << 20 )
                  | ( color << 18 ) | ( color << 16 ) | ( color << 14 )
                  | ( color << 12 ) | ( color << 10 ) | ( color << 8 )
                  | ( color << 6 ) | ( color << 4 ) | ( color << 2 ));

        dstleftignore = ( dx & 15 ) * 2;
        dstlongs = ( dstleftignore + w * 2 + 31 ) >> 5;
        dstrightignore = ( dstlongs * 32 - w * 2 - dstleftignore ) & 31;

        dstlin2 = dstlin1 + h * dst->linelongs;
        dstlin = dstlin1;

        if ( dstlongs == 1 )
            {
            /* It fits into a single longword. */
            lm = leftmask[dstleftignore] | rightmask[dstrightignore];
            nlm = ~lm;
            while ( dstlin != dstlin2 )
                {
                ROP_DST(
                /*op*/  op,
                /*pre*/ dl = *dstlin;,
                /*d*/   dl,
                /*pst*/ *dstlin = ( *dstlin & lm ) | ( dl & nlm ); )

                dstlin += dst->linelongs;
                }
            }
        else
            {
            lm = leftmask[dstleftignore];
            rm = rightmask[dstrightignore];
            nrm = ~rm;
            nlm = ~lm;

            while ( dstlin != dstlin2 )
                {
                dstlong = dstlin;
                dstlong2 = dstlong + dstlongs;
                if ( dstrightignore != 0 )
                    --dstlong2;

                /* Leading edge. */
                if ( dstleftignore != 0 )
                    {
                    ROP_DST(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*pst*/ *dstlong = ( *dstlong & lm ) | ( dl & nlm ); )
                    ++dstlong;
                    }

                /* Main rop. */
                ROP_DST(
                /*op*/  op,
                /*pre*/ while ( dstlong != dstlong2 )
                            {,
                /*d*/       *dstlong,
                /*pst*/     ++dstlong;
                            } )

                /* Trailing edge. */
                if ( dstrightignore != 0 )
                    {
                    ROP_DST(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*pst*/ *dstlong = ( dl & nrm ) | ( *dstlong & rm ); )
                    }

                dstlin += dst->linelongs;
                }
            }
        }
#endif /* RCONS_2BPP */
#ifdef RCONS_4BPP
    else if ( dst->depth == 4 )
        {
        /* Two-bit no-src blit. */
        u_int32_t color;
        u_int32_t* dstlin1;
        u_int32_t* dstlin2;
        u_int32_t* dstlin;
        int dstleftignore, dstrightignore, dstlongs;
        u_int32_t dl, lm, nlm, rm, nrm;
        u_int32_t* dstlong2;
        u_int32_t* dstlong;

        dstlin1 = RAS_ADDR( dst, dx, dy );

#ifdef BCOPY_FASTER
        /* Special-case full-width clears. */
        if ( op == RAS_CLEAR && dst->width == w && dst->linelongs == w >> 3 )
            {
            memset( (char*) dstlin1, 0, h * dst->linelongs * sizeof(u_int32_t) );
            return 0;
            }
#endif /*BCOPY_FASTER*/

        color = RAS_GETCOLOR( rop );
        if ( color == 0 )
            color = 15;

        /* Make 32 bits of color so we can do the ROP without shifting. */
        color |= (( color << 28 ) | ( color << 24 )
                  | ( color << 20 ) | ( color << 16 )
                  | ( color << 12 ) | ( color << 8 )
                  | ( color << 4 ));

        dstleftignore = ( dx & 7 ) * 4;
        dstlongs = ( dstleftignore + w * 4 + 31 ) >> 5;
        dstrightignore = ( dstlongs * 32 - w * 4 - dstleftignore ) & 31;

        dstlin2 = dstlin1 + h * dst->linelongs;
        dstlin = dstlin1;

        if ( dstlongs == 1 )
            {
            /* It fits into a single longword. */
            lm = leftmask[dstleftignore] | rightmask[dstrightignore];
            nlm = ~lm;
            while ( dstlin != dstlin2 )
                {
                ROP_DST(
                /*op*/  op,
                /*pre*/ dl = *dstlin;,
                /*d*/   dl,
                /*pst*/ *dstlin = ( *dstlin & lm ) | ( dl & nlm ); )

                dstlin += dst->linelongs;
                }
            }
        else
            {
            lm = leftmask[dstleftignore];
            rm = rightmask[dstrightignore];
            nrm = ~rm;
            nlm = ~lm;

            while ( dstlin != dstlin2 )
                {
                dstlong = dstlin;
                dstlong2 = dstlong + dstlongs;
                if ( dstrightignore != 0 )
                    --dstlong2;

                /* Leading edge. */
                if ( dstleftignore != 0 )
                    {
                    ROP_DST(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*pst*/ *dstlong = ( *dstlong & lm ) | ( dl & nlm ); )
                    ++dstlong;
                    }

                /* Main rop. */
                ROP_DST(
                /*op*/  op,
                /*pre*/ while ( dstlong != dstlong2 )
                            {,
                /*d*/       *dstlong,
                /*pst*/     ++dstlong;
                            } )

                /* Trailing edge. */
                if ( dstrightignore != 0 )
                    {
                    ROP_DST(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*pst*/ *dstlong = ( dl & nrm ) | ( *dstlong & rm ); )
                    }

                dstlin += dst->linelongs;
                }
            }
        }
#endif /* RCONS_4BPP */
    else if ( dst->depth == 8)
        {
        /* Eight-bit no-src blit. */
        u_int32_t color;
        u_int32_t* dstlin1;
        u_int32_t* dstlin2;
        u_int32_t* dstlin;
        int dstleftignore, dstrightignore, dstlongs;
        u_int32_t dl, lm, nlm, rm, nrm;
        u_int32_t* dstlong2;
        u_int32_t* dstlong;

        dstlin1 = RAS_ADDR( dst, dx, dy );

#ifdef BCOPY_FASTER
        /* Special-case full-width clears. */
        if ( op == RAS_CLEAR && dst->width == w && dst->linelongs == w >> 2 )
            {
            memset( (char*) dstlin1, 0, h * dst->linelongs * sizeof(u_int32_t) );
            return 0;
            }
#endif /*BCOPY_FASTER*/

        color = RAS_GETCOLOR( rop );
        if ( color == 0 )
            color = 255;

        /* Make 32 bits of color so we can do the ROP without shifting. */
        color |= ( color << 24 ) | ( color << 16 ) | ( color << 8 );

        dstleftignore = ( dx & 3 ) * 8;
        dstlongs = ( dstleftignore + w * 8 + 31 ) >> 5;
        dstrightignore = ( dstlongs * 32 - w * 8 - dstleftignore ) & 31;

        dstlin2 = dstlin1 + h * dst->linelongs;
        dstlin = dstlin1;

        if ( dstlongs == 1 )
            {
            /* It fits into a single longword. */
            lm = leftmask[dstleftignore] | rightmask[dstrightignore];
            nlm = ~lm;
            while ( dstlin != dstlin2 )
                {
                ROP_DSTCOLOR(
                /*op*/  op,
                /*pre*/ dl = *dstlin;,
                /*d*/   dl,
                /*c*/   color,
                /*pst*/ *dstlin = ( *dstlin & lm ) | ( dl & nlm ); )

                dstlin += dst->linelongs;
                }
            }
        else
            {
            lm = leftmask[dstleftignore];
            rm = rightmask[dstrightignore];
            nrm = ~rm;
            nlm = ~lm;
            while ( dstlin != dstlin2 )
                {
                dstlong = dstlin;
                dstlong2 = dstlong + dstlongs;
                if ( dstrightignore != 0 )
                    --dstlong2;

                /* Leading edge. */
                if ( dstleftignore != 0 )
                    {
                    ROP_DSTCOLOR(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*c*/   color,
                    /*pst*/ *dstlong = ( *dstlong & lm ) | ( dl & nlm ); )
                    ++dstlong;
                    }

                /* Main rop. */
                ROP_DSTCOLOR(
                /*op*/  op,
                /*pre*/ while ( dstlong != dstlong2 )
                            {,
                /*d*/       *dstlong,
                /*c*/       color,
                /*pst*/     ++dstlong;
                            } )

                /* Trailing edge. */
                if ( dstrightignore != 0 )
                    {
                    ROP_DSTCOLOR(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*c*/   color,
                    /*pst*/ *dstlong = ( dl & nrm ) | ( *dstlong & rm ); )
                    }

                dstlin += dst->linelongs;
                }
            }
        }
#ifdef RCONS_16BPP
    else
        {
        /* Sixteen-bit no-src blit. */
        u_int32_t color;
        u_int32_t* dstlin1;
        u_int32_t* dstlin2;
        u_int32_t* dstlin;
        int dstleftignore, dstrightignore, dstlongs;
        u_int32_t dl, lm, nlm, rm, nrm;
        u_int32_t* dstlong2;
        u_int32_t* dstlong;

        dstlin1 = RAS_ADDR( dst, dx, dy );

#ifdef BCOPY_FASTER
        /* Special-case full-width clears. */
        if ( op == RAS_CLEAR && dst->width == w && dst->linelongs == w >> 1 )
            {
            memset( (char*) dstlin1, 0, h * dst->linelongs * sizeof(u_int32_t) );
            return 0;
            }
#endif /*BCOPY_FASTER*/

        color = RAS_GETCOLOR( rop );
        if ( color == 0 )
                color = 0xffff; /* XXX */

        /* Make 32 bits of color so we can do the ROP without shifting. */
        color |= ( color << 16 );

        dstleftignore = ( dx & 1 ) * 16;
        dstlongs = ( dstleftignore + w * 16 + 31 ) >> 5;
        dstrightignore = ( dstlongs * 32 - w * 8 - dstleftignore ) & 31;

        dstlin2 = dstlin1 + h * dst->linelongs;
        dstlin = dstlin1;

        if ( dstlongs == 1 )
            {
            /* It fits into a single longword. */
            lm = leftmask[dstleftignore] | rightmask[dstrightignore];
            nlm = ~lm;
            while ( dstlin != dstlin2 )
                {
                ROP_DSTCOLOR(
                /*op*/  op,
                /*pre*/ dl = *dstlin;,
                /*d*/   dl,
                /*c*/   color,
                /*pst*/ *dstlin = ( *dstlin & lm ) | ( dl & nlm ); )

                dstlin += dst->linelongs;
                }
            }
        else
            {
            lm = leftmask[dstleftignore];
            rm = rightmask[dstrightignore];
            nrm = ~rm;
            nlm = ~lm;
            while ( dstlin != dstlin2 )
                {
                dstlong = dstlin;
                dstlong2 = dstlong + dstlongs;
                if ( dstrightignore != 0 )
                    --dstlong2;

                /* Leading edge. */
                if ( dstleftignore != 0 )
                    {
                    ROP_DSTCOLOR(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*c*/   color,
                    /*pst*/ *dstlong = ( *dstlong & lm ) | ( dl & nlm ); )
                    ++dstlong;
                    }

                /* Main rop. */
                ROP_DSTCOLOR(
                /*op*/  op,
                /*pre*/ while ( dstlong != dstlong2 )
                            {,
                /*d*/       *dstlong,
                /*c*/       color,
                /*pst*/     ++dstlong;
                            } )

                /* Trailing edge. */
                if ( dstrightignore != 0 )
                    {
                    ROP_DSTCOLOR(
                    /*op*/  op,
                    /*pre*/ dl = *dstlong;,
                    /*d*/   dl,
                    /*c*/   color,
                    /*pst*/ *dstlong = ( dl & nrm ) | ( *dstlong & rm ); )
                    }

                dstlin += dst->linelongs;
                }
            }
        }
#endif /* RCONS_16BPP */

    return 0;
    }

/* This is a general bitblit routine, handling overlapping source and
** destination.  It's used for both the 1-to-1 and 8-to-8 cases.
*/
static int
raster_blit(
    struct raster* src, uint32_t* srclin1,
    int srcleftignore, int srcrightignore, int srclongs,
    struct raster* dst,
    uint32_t* dstlin1,
    int dstleftignore, int dstrightignore, int dstlongs,
    int h, int op)
    {
    u_int32_t* srclin2;
    u_int32_t* dstlin2;
    int srclininc, dstlininc;
    u_int32_t* srclin;
    u_int32_t* dstlin;
    int prevleftshift, currrightshift;
    int longinc;
    u_int32_t* srclong;
    u_int32_t* dstlong;
    u_int32_t* dstlong2;
    u_int32_t dl, lm, nlm, rm, nrm;

    prevleftshift = ( srcleftignore - dstleftignore ) & 31;

    srclin2 = srclin1 + h * src->linelongs;
    dstlin2 = dstlin1 + h * dst->linelongs;
    srclininc = src->linelongs;
    dstlininc = dst->linelongs;
    longinc = 1;

    /* Check for overlaps. */
    if ( ( dstlin1 >= srclin1 && dstlin1 < srclin1 + srclongs ) ||
         ( srclin1 >= dstlin1 && srclin1 < dstlin1 + dstlongs ) )
        {
        /* Horizontal overlap.  Should we reverse? */
        if ( srclin1 < dstlin1 )
            {
            longinc = -1;
            srclin1 += srclongs - 1;
            srclin2 += srclongs - 1;
            dstlin1 += dstlongs - 1;
            }
        }
    else if ( ( dstlin1 >= srclin1 && dstlin1 < srclin2 ) ||
              ( srclin1 >= dstlin1 && srclin1 < dstlin2 ) )
        {
        /* Vertical overlap.  Should we reverse? */
        if ( srclin1 < dstlin1 )
            {
            srclin2 = srclin1 - srclininc;
            srclin1 += ( h - 1 ) * srclininc;
            dstlin1 += ( h - 1 ) * dstlininc;
            srclininc = -srclininc;
            dstlininc = -dstlininc;
            }
        }
    srclin = srclin1;
    dstlin = dstlin1;

    if ( prevleftshift == 0 )
        {
        /* The bits line up, no shifting necessary. */
        if ( dstlongs == 1 )
            {
            /* It all fits into a single longword. */
            lm = leftmask[dstleftignore] | rightmask[dstrightignore];
            nlm = ~lm;
            while ( srclin != srclin2 )
                {
                ROP_SRCDST(
                /*op*/  op,
                /*pre*/ dl = *dstlin;,
                /*s*/   *srclin,
                /*d*/   dl,
                /*pst*/ *dstlin = ( *dstlin & lm ) | ( dl & nlm ); )

                srclin += srclininc;
                dstlin += dstlininc;
                }
            }
        else
            {
            /* Multiple longwords. */
            lm = leftmask[dstleftignore];
            rm = rightmask[dstrightignore];
            nrm = ~rm;
            nlm = ~lm;
            if ( longinc == 1 )
                {
                /* Left to right. */
                while ( srclin != srclin2 )
                    {
                    srclong = srclin;
                    dstlong = dstlin;
                    dstlong2 = dstlong + dstlongs;
                    if ( dstrightignore != 0 )
                        --dstlong2;

                    /* Leading edge. */
                    if ( dstleftignore != 0 )
                        {
                        ROP_SRCDST(
                        /*op*/  op,
                        /*pre*/ dl = *dstlong;,
                        /*s*/   *srclong,
                        /*d*/   dl,
                        /*pst*/ *dstlong = ( *dstlong & lm ) | ( dl & nlm ); )
                        ++srclong;
                        ++dstlong;
                        }

                    /* Main rop. */
                    ROP_SRCDST(
                    /*op*/  op,
                    /*pre*/ while ( dstlong != dstlong2 )
                                {,
                    /*s*/       *srclong,
                    /*d*/       *dstlong,
                    /*pst*/     ++srclong;
                                ++dstlong;
                                } )

                    /* Trailing edge. */
                    if ( dstrightignore != 0 )
                        {
                        ROP_SRCDST(
                        /*op*/  op,
                        /*pre*/ dl = *dstlong;,
                        /*s*/   *srclong,
                        /*d*/   dl,
                        /*pst*/ *dstlong = ( dl & nrm ) | ( *dstlong & rm ); )
                        }

                    srclin += srclininc;
                    dstlin += dstlininc;
                    }
                }
            else
                {
                /* Right to left. */
                while ( srclin != srclin2 )
                    {
                    srclong = srclin;
                    dstlong = dstlin;
                    dstlong2 = dstlong - dstlongs;
                    if ( dstleftignore != 0 )
                        ++dstlong2;

                    /* Leading edge. */
                    if ( dstrightignore != 0 )
                        {
                        ROP_SRCDST(
                        /*op*/  op,
                        /*pre*/ dl = *dstlong;,
                        /*s*/   *srclong,
                        /*d*/   dl,
                        /*pst*/ *dstlong = ( dl & nrm ) | ( *dstlong & rm ); )
                        --srclong;
                        --dstlong;
                        }

                    /* Main rop. */
                    ROP_SRCDST(
                    /*op*/  op,
                    /*pre*/ while ( dstlong != dstlong2 )
                                {,
                    /*s*/       *srclong,
                    /*d*/       *dstlong,
                    /*pst*/     --srclong;
                                --dstlong;
                                } )

                    /* Trailing edge. */
                    if ( dstleftignore != 0 )
                        {
                        ROP_SRCDST(
                        /*op*/  op,
                        /*pre*/ dl = *dstlong;,
                        /*s*/   *srclong,
                        /*d*/   dl,
                        /*pst*/ *dstlong = ( *dstlong & lm ) | ( dl & nlm ); )
                        }

                    srclin += srclininc;
                    dstlin += dstlininc;
                    }
                }
            }
        }

    else
        {
        /* General case, with shifting and everything. */
        u_int32_t sl, prevsl;

        currrightshift = 32 - prevleftshift;
        if ( srclongs == 1 && dstlongs == 1 )
            {
            /* It fits into a single longword, with a shift. */
            lm = leftmask[dstleftignore] | rightmask[dstrightignore];
            nlm = ~lm;
            if ( srcleftignore > dstleftignore )
                {
                while ( srclin != srclin2 )
                    {
                    ROP_SRCDST(
                    /*op*/  op,
                    /*pre*/ dl = *dstlin;,
                    /*s*/   *srclin LSOP prevleftshift,
                    /*d*/   dl,
                    /*pst*/ *dstlin = ( *dstlin & lm ) | ( dl & nlm ); )

                    srclin += srclininc;
                    dstlin += dstlininc;
                    }
                }
            else
                {
                while ( srclin != srclin2 )
                    {
                    ROP_SRCDST(
                    /*op*/  op,
                    /*pre*/ dl = *dstlin;,
                    /*s*/   *srclin RSOP currrightshift,
                    /*d*/   dl,
                    /*pst*/ *dstlin = ( *dstlin & lm ) | ( dl & nlm ); )

                    srclin += srclininc;
                    dstlin += dstlininc;
                    }
                }
            }
        else
            {
            /* Multiple longwords. */
            lm = leftmask[dstleftignore];
            rm = rightmask[dstrightignore];
            nrm = ~rm;
            nlm = ~lm;
            if ( longinc == 1 )
                {
                /* Left to right. */
                while ( srclin != srclin2 )
                    {
                    srclong = srclin;
                    dstlong = dstlin;
                    dstlong2 = dstlong + dstlongs;
                    if ( srcleftignore > dstleftignore )
                        prevsl = *srclong++ LSOP prevleftshift;
                    else
                        prevsl = 0;
                    if ( dstrightignore != 0 )
                        --dstlong2;

                    /* Leading edge. */
                    if ( dstleftignore != 0 )
                        {
                        ROP_SRCDST(
                        /*op*/  op,
                        /*pre*/ sl = *srclong;
                                dl = *dstlong;,
                        /*s*/   prevsl | ( sl RSOP currrightshift ),
                        /*d*/   dl,
                        /*pst*/ *dstlong = ( *dstlong & lm ) | ( dl & nlm ); )
                        prevsl = sl LSOP prevleftshift;
                        ++srclong;
                        ++dstlong;
                        }

                    /* Main rop. */
                    ROP_SRCDST(
                    /*op*/  op,
                    /*pre*/ while ( dstlong != dstlong2 )
                                {
                                sl = *srclong;,
                    /*s*/       prevsl | ( sl RSOP currrightshift ),
                    /*d*/       *dstlong,
                    /*pst*/     prevsl = sl LSOP prevleftshift;
                                ++srclong;
                                ++dstlong;
                                } )

                    /* Trailing edge. */
                    if ( dstrightignore != 0 )
                        {
                        ROP_SRCDST(
                        /*op*/  op,
                        /*pre*/ dl = *dstlong;,
                        /*s*/   prevsl | ( *srclong RSOP currrightshift ),
                        /*d*/   dl,
                        /*pst*/ *dstlong = ( dl & nrm ) | ( *dstlong & rm ); )
                        }

                    srclin += srclininc;
                    dstlin += dstlininc;
                    }
                }
            else
                {
                /* Right to left. */
                while ( srclin != srclin2 )
                    {
                    srclong = srclin;
                    dstlong = dstlin;
                    dstlong2 = dstlong - dstlongs;
                    if ( srcrightignore > dstrightignore )
                        prevsl = *srclong-- RSOP currrightshift;
                    else
                        prevsl = 0;
                    if ( dstleftignore != 0 )
                        ++dstlong2;

                    /* Leading edge. */
                    if ( dstrightignore != 0 )
                        {
                        ROP_SRCDST(
                        /*op*/  op,
                        /*pre*/ sl = *srclong;
                                dl = *dstlong;,
                        /*s*/   prevsl | ( sl LSOP prevleftshift ),
                        /*d*/   dl,
                        /*pst*/ *dstlong = ( dl & nrm ) | ( *dstlong & rm ); )
                        prevsl = sl RSOP currrightshift;
                        --srclong;
                        --dstlong;
                        }

                    /* Main rop. */
                    ROP_SRCDST(
                    /*op*/  op,
                    /*pre*/ while ( dstlong != dstlong2 )
                                {
                                sl = *srclong;,
                    /*s*/       prevsl | ( sl LSOP prevleftshift ),
                    /*d*/       *dstlong,
                    /*pst*/     prevsl = sl RSOP currrightshift;
                                --srclong;
                                --dstlong;
                                } )

                    /* Trailing edge. */
                    if ( dstleftignore != 0 )
                        {
                        ROP_SRCDST(
                        /*op*/  op,
                        /*pre*/ dl = *dstlong;,
                        /*s*/   prevsl | ( *srclong LSOP prevleftshift ),
                        /*d*/   dl,
                        /*pst*/ *dstlong = ( *dstlong & lm ) | ( dl & nlm ); )
                        }

                    srclin += srclininc;
                    dstlin += dstlininc;
                    }
                }
            }
        }

    return 0;
    }