1987 lines
46 KiB
C
1987 lines
46 KiB
C
/* $NetBSD: raster_op.c,v 1.12 2003/08/07 16:31:20 agc 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.12 2003/08/07 16:31:20 agc 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 __P((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( dst, dx, dy, w, h, rop, src, sx, sy )
|
|
struct raster* dst;
|
|
int dx, dy, w, h, rop;
|
|
struct raster* src;
|
|
int sx, 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( dst, dx, dy, w, h, rop, src, sx, sy )
|
|
struct raster* dst;
|
|
int dx, dy, w, h, rop;
|
|
struct raster* src;
|
|
int sx, 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( dst, dx, dy, w, h, rop )
|
|
struct raster* dst;
|
|
int dx, dy, w, h, 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 )
|
|
{
|
|
bzero( (char*) dstlin1, 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 )
|
|
{
|
|
bzero( (char*) dstlin1, 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 )
|
|
{
|
|
bzero( (char*) dstlin1, 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 )
|
|
{
|
|
bzero( (char*) dstlin1, 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 )
|
|
{
|
|
bzero( (char*) dstlin1, 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( src, srclin1, srcleftignore, srcrightignore, srclongs, dst, dstlin1, dstleftignore, dstrightignore, dstlongs, h, op )
|
|
struct raster* src;
|
|
u_int32_t* srclin1;
|
|
int srcleftignore, srcrightignore, srclongs;
|
|
struct raster* dst;
|
|
u_int32_t* dstlin1;
|
|
int dstleftignore, dstrightignore, dstlongs;
|
|
int h, 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;
|
|
}
|