andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
cdf5bcd420
xserver-multidpi/hw/xfree86/xaa/xaaStipple.c
Keith Packard 9838b7032e Introduce a consistent coding style 
This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
2012-03-21 13:54:42 -07:00

916 lines
26 KiB
C
Raw Blame History

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include "xaa.h"
#include "xaalocal.h"
#include "xaacexp.h"
#include "xf86.h"
static CARD32 *StipplePowerOfTwo(CARD32 *, CARD32 *, int, int, int);
static CARD32 *StipplePowerOfTwo_Inverted(CARD32 *, CARD32 *, int, int, int);
static CARD32 *StippleUpTo32(CARD32 *, CARD32 *, int, int, int);
static CARD32 *StippleUpTo32_Inverted(CARD32 *, CARD32 *, int, int, int);
static CARD32 *StippleOver32(CARD32 *, CARD32 *, int, int, int);
static CARD32 *StippleOver32_Inverted(CARD32 *, CARD32 *, int, int, int);
#ifdef TRIPLE_BITS
#define stipple_scanline_func EXPNAME(XAAStippleScanlineFunc3)
#define stipple_get_scanline_func EXPNAME(XAAGetStippleScanlineFunc3)
#else
#define stipple_scanline_func EXPNAME(XAAStippleScanlineFunc)
#define stipple_get_scanline_func EXPNAME(XAAGetStippleScanlineFunc)
#endif
StippleScanlineProcPtr stipple_scanline_func[6] = {
StipplePowerOfTwo,
StippleUpTo32,
StippleOver32,
StipplePowerOfTwo_Inverted,
StippleUpTo32_Inverted,
StippleOver32_Inverted
};
StippleScanlineProcPtr *
stipple_get_scanline_func(void)
{
return stipple_scanline_func;
}
#ifdef FIXEDBASE
#define DEST(i) *dest
#define RETURN(i) return(dest)
#else
#define DEST(i) dest[i]
#define RETURN(i) return(dest + i)
#endif
/* TRIPLE_BITS pattern expansion */
#ifdef TRIPLE_BITS
#define EXPAND_PAT \
CARD32 pat1 = byte_expand3[pat & 0xFF], \
pat2 = byte_expand3[(pat & 0xFF00) >> 8], \
pat3 = byte_expand3[(pat & 0xFF0000) >> 16], \
pat4 = byte_expand3[(pat & 0xFF000000) >> 24], \
patA = pat1 | (pat2 << 24), \
patB = (pat2 >> 8) | (pat3 << 16), \
patC = (pat3 >> 16) | (pat4 << 8)
#ifdef FIXED_BASE
#define WRITE_PAT1 { \
*dest = patA; }
#define WRITE_PAT2 { \
*dest = patA; \
*dest = patB; }
#define WRITE_PAT3 { \
*dest = patA; \
*dest = patB; \
*dest = patC; }
#else
#define WRITE_PAT1 { \
*(dest++) = patA; }
#define WRITE_PAT2 { \
*(dest) = patA; \
*(dest + 1) = patB; \
dest += 2; }
#define WRITE_PAT3 { \
*(dest) = patA; \
*(dest + 1) = patB; \
*(dest + 2) = patC; \
dest += 3; }
#endif
#endif
#if !defined(FIXEDBASE) && !defined(MSBFIRST) && !defined(TRIPLE_BITS)
unsigned int XAAShiftMasks[32] = {
/* gcc is rather pedantic about SHIFT_R(0xFFFFFFFF,32) */
0x00000000, SHIFT_R(0xFFFFFFFF, 31),
SHIFT_R(0xFFFFFFFF, 30), SHIFT_R(0xFFFFFFFF, 29),
SHIFT_R(0xFFFFFFFF, 28), SHIFT_R(0xFFFFFFFF, 27),
SHIFT_R(0xFFFFFFFF, 26), SHIFT_R(0xFFFFFFFF, 25),
SHIFT_R(0xFFFFFFFF, 24), SHIFT_R(0xFFFFFFFF, 23),
SHIFT_R(0xFFFFFFFF, 22), SHIFT_R(0xFFFFFFFF, 21),
SHIFT_R(0xFFFFFFFF, 20), SHIFT_R(0xFFFFFFFF, 19),
SHIFT_R(0xFFFFFFFF, 18), SHIFT_R(0xFFFFFFFF, 17),
SHIFT_R(0xFFFFFFFF, 16), SHIFT_R(0xFFFFFFFF, 15),
SHIFT_R(0xFFFFFFFF, 14), SHIFT_R(0xFFFFFFFF, 13),
SHIFT_R(0xFFFFFFFF, 12), SHIFT_R(0xFFFFFFFF, 11),
SHIFT_R(0xFFFFFFFF, 10), SHIFT_R(0xFFFFFFFF, 9),
SHIFT_R(0xFFFFFFFF, 8), SHIFT_R(0xFFFFFFFF, 7),
SHIFT_R(0xFFFFFFFF, 6), SHIFT_R(0xFFFFFFFF, 5),
SHIFT_R(0xFFFFFFFF, 4), SHIFT_R(0xFFFFFFFF, 3),
SHIFT_R(0xFFFFFFFF, 2), SHIFT_R(0xFFFFFFFF, 1)
};
#endif
void
#ifdef TRIPLE_BITS
EXPNAME(XAAFillColorExpandRects3) (
#else
EXPNAME(XAAFillColorExpandRects) (
#endif
ScrnInfoPtr pScrn,
int fg, int bg, int rop,
unsigned int planemask,
int nBox,
BoxPtr pBox,
int xorg, int yorg, PixmapPtr pPix) {
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
CARD32 *base;
Bool TwoPass = FALSE, FirstPass = TRUE;
StippleScanlineProcPtr StippleFunc, FirstFunc, SecondFunc;
int stipplewidth = pPix->drawable.width;
int stippleheight = pPix->drawable.height;
int srcwidth = pPix->devKind;
int dwords, srcy, srcx, funcNo = 2, h;
unsigned char *src = (unsigned char *) pPix->devPrivate.ptr;
unsigned char *srcp;
int flag;
if (stipplewidth <= 32) {
if (stipplewidth & (stipplewidth - 1))
funcNo = 1;
else
funcNo = 0;
}
StippleFunc = stipple_scanline_func[funcNo];
SecondFunc = stipple_scanline_func[funcNo];
FirstFunc = stipple_scanline_func[funcNo + 3];
#ifdef TRIPLE_BITS
if ((bg == -1) ||
(!(infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY) &&
(!(infoRec->CPUToScreenColorExpandFillFlags & RGB_EQUAL) ||
(CHECK_RGB_EQUAL(bg))))) {
#else
if ((bg == -1) ||
!(infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
#endif
/* one pass */
}
else if ((rop == GXcopy) && infoRec->FillSolidRects) {
/* one pass but we fill background rects first */
(*infoRec->FillSolidRects) (pScrn, bg, rop, planemask, nBox, pBox);
bg = -1;
}
else {
/* gotta do two passes */
TwoPass = TRUE;
}
if (!TwoPass)
(*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
planemask);
while (nBox--) {
#ifdef TRIPLE_BITS
dwords = (3 * (pBox->x2 - pBox->x1) + 31) >> 5;
#else
dwords = (pBox->x2 - pBox->x1 + 31) >> 5;
#endif
SECOND_PASS:
if (TwoPass) {
(*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn,
(FirstPass) ? bg :
fg, -1, rop,
planemask);
StippleFunc = (FirstPass) ? FirstFunc : SecondFunc;
}
h = pBox->y2 - pBox->y1;
flag = (infoRec->CPUToScreenColorExpandFillFlags
& CPU_TRANSFER_PAD_QWORD) && ((dwords * h) & 0x01);
(*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, pBox->x1,
pBox->y1,
pBox->x2 - pBox->x1,
h, 0);
base = (CARD32 *) infoRec->ColorExpandBase;
srcy = (pBox->y1 - yorg) % stippleheight;
if (srcy < 0)
srcy += stippleheight;
srcx = (pBox->x1 - xorg) % stipplewidth;
if (srcx < 0)
srcx += stipplewidth;
srcp = (srcwidth * srcy) + src;
#ifndef FIXEDBASE
if ((dwords * h) <= infoRec->ColorExpandRange) {
while (h--) {
base =
(*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth,
dwords);
srcy++;
srcp += srcwidth;
if (srcy >= stippleheight) {
srcy = 0;
srcp = src;
}
}
}
else
#endif
while (h--) {
(*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth,
dwords);
srcy++;
srcp += srcwidth;
if (srcy >= stippleheight) {
srcy = 0;
srcp = src;
}
}
if (flag) {
base = (CARD32 *) infoRec->ColorExpandBase;
base[0] = 0x00000000;
}
if (TwoPass) {
if (FirstPass) {
FirstPass = FALSE;
goto SECOND_PASS;
}
else
FirstPass = TRUE;
}
pBox++;
}
if (infoRec->CPUToScreenColorExpandFillFlags & SYNC_AFTER_COLOR_EXPAND)
(*infoRec->Sync) (pScrn);
else
SET_SYNC_FLAG(infoRec);
}
void
#ifdef TRIPLE_BITS
EXPNAME(XAAFillColorExpandSpans3) (
#else
EXPNAME(XAAFillColorExpandSpans) (
#endif
ScrnInfoPtr pScrn,
int fg, int bg, int rop,
unsigned int planemask,
int n,
DDXPointPtr ppt,
int *pwidth,
int fSorted,
int xorg, int yorg, PixmapPtr pPix) {
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
CARD32 *base;
Bool TwoPass = FALSE, FirstPass = TRUE;
StippleScanlineProcPtr StippleFunc, FirstFunc, SecondFunc;
int stipplewidth = pPix->drawable.width;
int stippleheight = pPix->drawable.height;
int dwords, srcy, srcx, funcNo = 2;
unsigned char *srcp;
if (stipplewidth <= 32) {
if (stipplewidth & (stipplewidth - 1))
funcNo = 1;
else
funcNo = 0;
}
StippleFunc = stipple_scanline_func[funcNo];
SecondFunc = stipple_scanline_func[funcNo];
FirstFunc = stipple_scanline_func[funcNo + 3];
#ifdef TRIPLE_BITS
if ((bg == -1) ||
(!(infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY) &&
(!(infoRec->CPUToScreenColorExpandFillFlags & RGB_EQUAL) ||
(CHECK_RGB_EQUAL(bg))))) {
#else
if ((bg == -1) ||
!(infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
#endif
/* one pass */
}
else if ((rop == GXcopy) && infoRec->FillSolidSpans) {
/* one pass but we fill background rects first */
(*infoRec->FillSolidSpans) (pScrn, bg, rop, planemask, n, ppt, pwidth,
fSorted);
bg = -1;
}
else {
/* gotta do two passes */
TwoPass = TRUE;
}
if (!TwoPass)
(*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
planemask);
while (n--) {
#ifdef TRIPLE_BITS
dwords = (3 * *pwidth + 31) >> 5;
#else
dwords = (*pwidth + 31) >> 5;
#endif
srcy = (ppt->y - yorg) % stippleheight;
if (srcy < 0)
srcy += stippleheight;
srcx = (ppt->x - xorg) % stipplewidth;
if (srcx < 0)
srcx += stipplewidth;
srcp = (pPix->devKind * srcy) + (unsigned char *) pPix->devPrivate.ptr;
SECOND_PASS:
if (TwoPass) {
(*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn,
(FirstPass) ? bg :
fg, -1, rop,
planemask);
StippleFunc = (FirstPass) ? FirstFunc : SecondFunc;
}
(*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, ppt->x, ppt->y,
*pwidth, 1, 0);
base = (CARD32 *) infoRec->ColorExpandBase;
(*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth, dwords);
if ((infoRec->CPUToScreenColorExpandFillFlags & CPU_TRANSFER_PAD_QWORD)
&& (dwords & 0x01)) {
base = (CARD32 *) infoRec->ColorExpandBase;
base[0] = 0x00000000;
}
if (TwoPass) {
if (FirstPass) {
FirstPass = FALSE;
goto SECOND_PASS;
}
else
FirstPass = TRUE;
}
ppt++;
pwidth++;
}
if (infoRec->CPUToScreenColorExpandFillFlags & SYNC_AFTER_COLOR_EXPAND)
(*infoRec->Sync) (pScrn);
else
SET_SYNC_FLAG(infoRec);
}
#ifndef FIXEDBASE
void
#ifdef TRIPLE_BITS
EXPNAME(XAAFillScanlineColorExpandRects3) (
#else
EXPNAME(XAAFillScanlineColorExpandRects) (
#endif
ScrnInfoPtr pScrn,
int fg, int bg, int rop,
unsigned int planemask,
int nBox,
BoxPtr pBox,
int xorg, int yorg,
PixmapPtr pPix) {
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
CARD32 *base;
Bool TwoPass = FALSE, FirstPass = TRUE;
StippleScanlineProcPtr StippleFunc, FirstFunc, SecondFunc;
int stipplewidth = pPix->drawable.width;
int stippleheight = pPix->drawable.height;
int srcwidth = pPix->devKind;
int dwords, srcy, srcx, funcNo = 2, bufferNo, h;
unsigned char *src = pPix->devPrivate.ptr;
unsigned char *srcp;
if (stipplewidth <= 32) {
if (stipplewidth & (stipplewidth - 1))
funcNo = 1;
else
funcNo = 0;
}
StippleFunc = stipple_scanline_func[funcNo];
SecondFunc = stipple_scanline_func[funcNo];
FirstFunc = stipple_scanline_func[funcNo + 3];
#ifdef TRIPLE_BITS
if ((bg == -1) ||
(!(infoRec->ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)
&& (!(infoRec->ScanlineCPUToScreenColorExpandFillFlags & RGB_EQUAL) ||
(CHECK_RGB_EQUAL(bg))))) {
#else
if ((bg == -1) ||
!(infoRec->
ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
#endif
/* one pass */
}
else if ((rop == GXcopy) && infoRec->FillSolidRects) {
/* one pass but we fill background rects first */
(*infoRec->FillSolidRects) (pScrn, bg, rop, planemask, nBox, pBox);
bg = -1;
}
else {
/* gotta do two passes */
TwoPass = TRUE;
}
if (!TwoPass)
(*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg,
rop, planemask);
while (nBox--) {
#ifdef TRIPLE_BITS
dwords = (3 * (pBox->x2 - pBox->x1) + 31) >> 5;
#else
dwords = (pBox->x2 - pBox->x1 + 31) >> 5;
#endif
SECOND_PASS:
if (TwoPass) {
(*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn,
(FirstPass)
? bg : fg,
-1, rop,
planemask);
StippleFunc = (FirstPass) ? FirstFunc : SecondFunc;
}
h = pBox->y2 - pBox->y1;
(*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn,
pBox->x1,
pBox->y1,
pBox->x2 -
pBox->x1, h,
0);
bufferNo = 0;
srcy = (pBox->y1 - yorg) % stippleheight;
if (srcy < 0)
srcy += stippleheight;
srcx = (pBox->x1 - xorg) % stipplewidth;
if (srcx < 0)
srcx += stipplewidth;
srcp = (srcwidth * srcy) + src;
while (h--) {
base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
(*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth, dwords);
(*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
bufferNo = 0;
srcy++;
srcp += srcwidth;
if (srcy >= stippleheight) {
srcy = 0;
srcp = src;
}
}
if (TwoPass) {
if (FirstPass) {
FirstPass = FALSE;
goto SECOND_PASS;
}
else
FirstPass = TRUE;
}
pBox++;
}
SET_SYNC_FLAG(infoRec);
}
void
#ifdef TRIPLE_BITS
EXPNAME(XAAFillScanlineColorExpandSpans3) (
#else
EXPNAME(XAAFillScanlineColorExpandSpans) (
#endif
ScrnInfoPtr pScrn,
int fg, int bg, int rop,
unsigned int planemask,
int n,
DDXPointPtr ppt,
int *pwidth,
int fSorted,
int xorg, int yorg,
PixmapPtr pPix) {
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
CARD32 *base;
Bool TwoPass = FALSE, FirstPass = TRUE;
StippleScanlineProcPtr StippleFunc, FirstFunc, SecondFunc;
int stipplewidth = pPix->drawable.width;
int stippleheight = pPix->drawable.height;
int dwords, srcy, srcx, funcNo = 2;
unsigned char *srcp;
if (stipplewidth <= 32) {
if (stipplewidth & (stipplewidth - 1))
funcNo = 1;
else
funcNo = 0;
}
StippleFunc = stipple_scanline_func[funcNo];
SecondFunc = stipple_scanline_func[funcNo];
FirstFunc = stipple_scanline_func[funcNo + 3];
#ifdef TRIPLE_BITS
if ((bg == -1) ||
(!(infoRec->ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)
&& (!(infoRec->ScanlineCPUToScreenColorExpandFillFlags & RGB_EQUAL) ||
(CHECK_RGB_EQUAL(bg))))) {
#else
if ((bg == -1) ||
!(infoRec->
ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
#endif
/* one pass */
}
else if ((rop == GXcopy) && infoRec->FillSolidSpans) {
/* one pass but we fill background rects first */
(*infoRec->FillSolidSpans) (pScrn, bg, rop, planemask, n, ppt, pwidth,
fSorted);
bg = -1;
}
else {
/* gotta do two passes */
TwoPass = TRUE;
}
if (!TwoPass)
(*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg,
rop, planemask);
while (n--) {
#ifdef TRIPLE_BITS
dwords = (3 * *pwidth + 31) >> 5;
#else
dwords = (*pwidth + 31) >> 5;
#endif
srcy = (ppt->y - yorg) % stippleheight;
if (srcy < 0)
srcy += stippleheight;
srcx = (ppt->x - xorg) % stipplewidth;
if (srcx < 0)
srcx += stipplewidth;
srcp = (pPix->devKind * srcy) + (unsigned char *) pPix->devPrivate.ptr;
SECOND_PASS:
if (TwoPass) {
(*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn,
(FirstPass)
? bg : fg,
-1, rop,
planemask);
StippleFunc = (FirstPass) ? FirstFunc : SecondFunc;
}
(*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, ppt->x,
ppt->y,
*pwidth, 1,
0);
base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[0];
(*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth, dwords);
(*infoRec->SubsequentColorExpandScanline) (pScrn, 0);
if (TwoPass) {
if (FirstPass) {
FirstPass = FALSE;
goto SECOND_PASS;
}
else
FirstPass = TRUE;
}
ppt++;
pwidth++;
}
SET_SYNC_FLAG(infoRec);
}
#endif
static CARD32 *
StipplePowerOfTwo(CARD32 *dest, CARD32 *src, int shift, int width, int dwords)
{
CARD32 pat = *src;
if (width < 32) {
pat &= XAAShiftMasks[width];
while (width < 32) {
pat |= SHIFT_L(pat, width);
width <<= 1;
}
}
if (shift)
pat = SHIFT_R(pat, shift) | SHIFT_L(pat, 32 - shift);
#ifdef MSBFIRST
pat = SWAP_BITS_IN_BYTES(pat);
#endif
#ifdef TRIPLE_BITS
{
EXPAND_PAT;
while (dwords >= 3) {
WRITE_PAT3;
dwords -= 3;
}
if (dwords == 2) {
WRITE_PAT2;
}
else if (dwords == 1) {
WRITE_PAT1;
}
return dest;
}
#else /* TRIPLE_BITS */
while (dwords >= 4) {
DEST(0) = pat;
DEST(1) = pat;
DEST(2) = pat;
DEST(3) = pat;
dwords -= 4;
#ifndef FIXEDBASE
dest += 4;
#endif
}
if (!dwords)
return dest;
DEST(0) = pat;
if (dwords == 1)
RETURN(1);
DEST(1) = pat;
if (dwords == 2)
RETURN(2);
DEST(2) = pat;
RETURN(3);
#endif /* TRIPLE_BITS */
}
static CARD32 *
StipplePowerOfTwo_Inverted(CARD32 *dest, CARD32 *src,
int shift, int width, int dwords)
{
CARD32 pat = *src;
if (width < 32) {
pat &= XAAShiftMasks[width];
while (width < 32) {
pat |= SHIFT_L(pat, width);
width <<= 1;
}
}
if (shift)
pat = SHIFT_R(pat, shift) | SHIFT_L(pat, 32 - shift);
#ifdef MSBFIRST
pat = SWAP_BITS_IN_BYTES(pat);
#endif
pat = ~pat;
#ifdef TRIPLE_BITS
{
EXPAND_PAT;
while (dwords >= 3) {
WRITE_PAT3;
dwords -= 3;
}
if (dwords == 2) {
WRITE_PAT2;
}
else if (dwords == 1) {
WRITE_PAT1;
}
return dest;
}
#else /* TRIPLE_BITS */
while (dwords >= 4) {
DEST(0) = pat;
DEST(1) = pat;
DEST(2) = pat;
DEST(3) = pat;
dwords -= 4;
#ifndef FIXEDBASE
dest += 4;
#endif
}
if (!dwords)
return dest;
DEST(0) = pat;
if (dwords == 1)
RETURN(1);
DEST(1) = pat;
if (dwords == 2)
RETURN(2);
DEST(2) = pat;
RETURN(3);
#endif /* TRIPLE_BITS */
}
static CARD32 *
StippleUpTo32(CARD32 *base, CARD32 *src, int shift, int width, int dwords)
{
CARD32 pat = *src & XAAShiftMasks[width];
while (width <= 15) {
pat |= SHIFT_L(pat, width);
width <<= 1;
}
pat |= SHIFT_L(pat, width);
while (dwords--) {
CARD32 bits = SHIFT_R(pat, shift) | SHIFT_L(pat, width - shift);
#ifdef TRIPLE_BITS
if (dwords >= 2) {
WRITE_BITS3(bits);
dwords -= 2;
}
else if (dwords > 0) {
WRITE_BITS2(bits);
dwords--;
}
else {
WRITE_BITS1(bits);
}
#else
WRITE_BITS(bits);
#endif
shift += 32;
shift %= width;
}
return base;
}
static CARD32 *
StippleUpTo32_Inverted(CARD32 *base, CARD32 *src,
int shift, int width, int dwords)
{
CARD32 pat = *src & XAAShiftMasks[width];
while (width <= 15) {
pat |= SHIFT_L(pat, width);
width <<= 1;
}
pat |= SHIFT_L(pat, width);
while (dwords--) {
CARD32 bits = ~(SHIFT_R(pat, shift) | SHIFT_L(pat, width - shift));
#ifdef TRIPLE_BITS
if (dwords >= 2) {
WRITE_BITS3(bits);
dwords -= 2;
}
else if (dwords > 0) {
WRITE_BITS2(bits);
dwords--;
}
else {
WRITE_BITS1(bits);
}
#else
WRITE_BITS(bits);
#endif
shift += 32;
shift %= width;
}
return base;
}
static CARD32 *
StippleOver32(CARD32 *base, CARD32 *src, int offset, int width, int dwords)
{
CARD32 *srcp;
CARD32 bits;
int bitsleft, shift, usable;
while (dwords--) {
bitsleft = width - offset;
srcp = src + (offset >> 5);
shift = offset & 31;
usable = 32 - shift;
if (bitsleft < 32) {
if (bitsleft <= usable) {
bits = SHIFT_L(*src, bitsleft) |
(SHIFT_R(*srcp, shift) & XAAShiftMasks[bitsleft]);
}
else {
bits = SHIFT_L(*src, bitsleft) |
(SHIFT_L(srcp[1], usable) & XAAShiftMasks[bitsleft]) |
(SHIFT_R(*srcp, shift) & XAAShiftMasks[usable]);
}
}
else if (shift)
bits = SHIFT_R(*srcp, shift) | SHIFT_L(srcp[1], usable);
else
bits = *srcp;
#ifdef TRIPLE_BITS
if (dwords >= 2) {
WRITE_BITS3(bits);
dwords -= 2;
}
else if (dwords > 0) {
WRITE_BITS2(bits);
dwords--;
}
else {
WRITE_BITS1(bits);
}
#else
WRITE_BITS(bits);
#endif
offset += 32;
offset %= width;
}
return base;
}
static CARD32 *
StippleOver32_Inverted(CARD32 *base, CARD32 *src,
int offset, int width, int dwords)
{
CARD32 *srcp;
CARD32 bits;
int bitsleft, shift, usable;
while (dwords--) {
bitsleft = width - offset;
srcp = src + (offset >> 5);
shift = offset & 31;
usable = 32 - shift;
if (bitsleft < 32) {
if (bitsleft <= usable) {
bits = SHIFT_L(*src, bitsleft) |
(SHIFT_R(*srcp, shift) & XAAShiftMasks[bitsleft]);
}
else {
bits = SHIFT_L(*src, bitsleft) |
(SHIFT_L(srcp[1], usable) & XAAShiftMasks[bitsleft]) |
(SHIFT_R(*srcp, shift) & XAAShiftMasks[usable]);
}
}
else if (shift)
bits = SHIFT_R(*srcp, shift) | SHIFT_L(srcp[1], usable);
else
bits = *srcp;
bits = ~bits;
#ifdef TRIPLE_BITS
if (dwords >= 2) {
WRITE_BITS3(bits);
dwords -= 2;
}
else if (dwords > 0) {
WRITE_BITS2(bits);
dwords--;
}
else {
WRITE_BITS1(bits);
}
#else
WRITE_BITS(bits);
#endif
offset += 32;
offset %= width;
}
return base;
}
Reference in New Issue View Git Blame Copy Permalink