andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
a7eac500e6
xserver-multidpi/hw/xfree86/xaa/xaaBitmap.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

478 lines
12 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"
/********** byte swapping ***************/
#ifdef FIXEDBASE
#define DEST(i) *dest
#define RETURN(i) return(dest)
#else
#define DEST(i) dest[i]
#define RETURN(i) return(dest + i)
#endif
#ifdef MSBFIRST
#define SOURCE(i) SWAP_BITS_IN_BYTES(src[i])
#else
#define SOURCE(i) src[i]
#endif
typedef CARD32 *(*BitmapScanlineProcPtr) (CARD32 *, CARD32 *, int, int);
#ifdef TRIPLE_BITS
static CARD32 *
BitmapScanline(CARD32 *src, CARD32 *base, int count, int skipleft)
{
CARD32 bits;
while (count >= 3) {
bits = *src;
WRITE_BITS3(bits);
src++;
count -= 3;
}
if (count == 2) {
bits = *src;
WRITE_BITS2(bits);
}
else if (count == 1) {
bits = *src;
WRITE_BITS1(bits);
}
return base;
}
static CARD32 *
BitmapScanline_Inverted(CARD32 *src, CARD32 *base, int count, int skipleft)
{
CARD32 bits;
while (count >= 3) {
bits = ~(*src);
WRITE_BITS3(bits);
src++;
count -= 3;
}
if (count == 2) {
bits = ~(*src);
WRITE_BITS2(bits);
}
else if (count == 1) {
bits = ~(*src);
WRITE_BITS1(bits);
}
return base;
}
static CARD32 *
BitmapScanline_Shifted(CARD32 *src, CARD32 *base, int count, int skipleft)
{
CARD32 bits;
while (count >= 3) {
bits = SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft));
WRITE_BITS3(bits);
src++;
count -= 3;
}
if (count == 2) {
bits = SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft));
WRITE_BITS2(bits);
}
else if (count == 1) {
bits = SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft));
WRITE_BITS1(bits);
}
return base;
}
static CARD32 *
BitmapScanline_Shifted_Inverted(CARD32 *src, CARD32 *base,
int count, int skipleft)
{
CARD32 bits;
while (count >= 3) {
bits =
~(SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft)));
WRITE_BITS3(bits);
src++;
count -= 3;
}
if (count == 2) {
bits =
~(SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft)));
WRITE_BITS2(bits);
}
else if (count == 1) {
bits =
~(SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft)));
WRITE_BITS1(bits);
}
return base;
}
#define BitmapScanline_Shifted_Careful BitmapScanline_Shifted
#define BitmapScanline_Shifted_Inverted_Careful BitmapScanline_Shifted_Inverted
#else
static CARD32 *
BitmapScanline(CARD32 *src, CARD32 *dest, int count, int skipleft)
{
while (count >= 4) {
DEST(0) = SOURCE(0);
DEST(1) = SOURCE(1);
DEST(2) = SOURCE(2);
DEST(3) = SOURCE(3);
count -= 4;
src += 4;
#ifndef FIXEDBASE
dest += 4;
#endif
}
if (!count)
return dest;
DEST(0) = SOURCE(0);
if (count == 1)
RETURN(1);
DEST(1) = SOURCE(1);
if (count == 2)
RETURN(2);
DEST(2) = SOURCE(2);
RETURN(3);
}
static CARD32 *
BitmapScanline_Inverted(CARD32 *src, CARD32 *dest, int count, int skipleft)
{
while (count >= 4) {
DEST(0) = ~SOURCE(0);
DEST(1) = ~SOURCE(1);
DEST(2) = ~SOURCE(2);
DEST(3) = ~SOURCE(3);
count -= 4;
src += 4;
#ifndef FIXEDBASE
dest += 4;
#endif
}
if (!count)
return dest;
DEST(0) = ~SOURCE(0);
if (count == 1)
RETURN(1);
DEST(1) = ~SOURCE(1);
if (count == 2)
RETURN(2);
DEST(2) = ~SOURCE(2);
RETURN(3);
}
static CARD32 *
BitmapScanline_Shifted(CARD32 *bits, CARD32 *base, int count, int skipleft)
{
while (count--) {
register CARD32 tmp = SHIFT_R(*bits, skipleft) |
SHIFT_L(*(bits + 1), (32 - skipleft));
WRITE_BITS(tmp);
bits++;
}
return base;
}
static CARD32 *
BitmapScanline_Shifted_Inverted(CARD32 *bits, CARD32 *base,
int count, int skipleft)
{
while (count--) {
register CARD32 tmp = ~(SHIFT_R(*bits, skipleft) |
SHIFT_L(*(bits + 1), (32 - skipleft)));
WRITE_BITS(tmp);
bits++;
}
return base;
}
static CARD32 *
BitmapScanline_Shifted_Careful(CARD32 *bits, CARD32 *base,
int count, int skipleft)
{
register CARD32 tmp;
while (--count) {
tmp = SHIFT_R(*bits, skipleft) | SHIFT_L(*(bits + 1), (32 - skipleft));
WRITE_BITS(tmp);
bits++;
}
tmp = SHIFT_R(*bits, skipleft);
WRITE_BITS(tmp);
return base;
}
static CARD32 *
BitmapScanline_Shifted_Inverted_Careful(CARD32 *bits, CARD32 *base,
int count, int skipleft)
{
register CARD32 tmp;
while (--count) {
tmp =
~(SHIFT_R(*bits, skipleft) | SHIFT_L(*(bits + 1), (32 - skipleft)));
WRITE_BITS(tmp);
bits++;
}
tmp = ~(SHIFT_R(*bits, skipleft));
WRITE_BITS(tmp);
return base;
}
#endif
/*
When the accelerator is TRANSPARENCY_ONLY, WriteBitmap can do
the fill in two passes, inverting the source on the second pass.
For GXcopy we can fill the backing rectangle as a solid rect and
avoid the invert.
*/
void
#ifdef TRIPLE_BITS
EXPNAME(XAAWriteBitmapColorExpand3) (
#else
EXPNAME(XAAWriteBitmapColorExpand) (
#endif
ScrnInfoPtr pScrn,
int x, int y, int w, int H,
unsigned char *src,
int srcwidth,
int skipleft,
int fg, int bg,
int rop, unsigned int planemask) {
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
CARD32 *base;
unsigned char *srcp = src;
int SecondPassColor = -1;
int shift = 0, dwords;
BitmapScanlineProcPtr firstFunc;
BitmapScanlineProcPtr secondFunc;
int flag;
int h = H;
#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
if ((rop == GXcopy) && infoRec->SetupForSolidFill) {
(*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
(*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
}
else
SecondPassColor = bg;
bg = -1;
}
#ifdef TRIPLE_BITS
if (skipleft) {
#else
if (skipleft &&
(!(infoRec->CPUToScreenColorExpandFillFlags & LEFT_EDGE_CLIPPING) ||
(!(infoRec->
CPUToScreenColorExpandFillFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
(skipleft > x)))) {
#endif
if ((skipleft + ((w + 31) & ~31)) > ((skipleft + w + 31) & ~31)) {
/* don't read past the end */
firstFunc = BitmapScanline_Shifted_Careful;
secondFunc = BitmapScanline_Shifted_Inverted_Careful;
}
else {
firstFunc = BitmapScanline_Shifted;
secondFunc = BitmapScanline_Shifted_Inverted;
}
shift = skipleft;
skipleft = 0;
}
else {
firstFunc = BitmapScanline;
secondFunc = BitmapScanline_Inverted;
w += skipleft;
x -= skipleft;
}
#ifdef TRIPLE_BITS
dwords = (3 * w + 31) >> 5;
#else
dwords = (w + 31) >> 5;
#endif
SECOND_PASS:
flag = (infoRec->CPUToScreenColorExpandFillFlags
& CPU_TRANSFER_PAD_QWORD) && ((dwords * h) & 0x01);
(*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
planemask);
(*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
skipleft);
base = (CARD32 *) infoRec->ColorExpandBase;
#ifndef FIXEDBASE
if ((dwords * h) <= infoRec->ColorExpandRange)
while (h--) {
base = (*firstFunc) ((CARD32 *) srcp, base, dwords, shift);
srcp += srcwidth;
}
else
#endif
while (h--) {
(*firstFunc) ((CARD32 *) srcp, base, dwords, shift);
srcp += srcwidth;
}
if (flag) {
base = (CARD32 *) infoRec->ColorExpandBase;
base[0] = 0x00000000;
}
if (SecondPassColor != -1) {
h = H; /* Reset height */
fg = SecondPassColor;
SecondPassColor = -1;
firstFunc = secondFunc;
srcp = src;
goto SECOND_PASS;
}
if (infoRec->CPUToScreenColorExpandFillFlags & SYNC_AFTER_COLOR_EXPAND)
(*infoRec->Sync) (pScrn);
else
SET_SYNC_FLAG(infoRec);
}
#ifndef FIXEDBASE
void
#ifdef TRIPLE_BITS
EXPNAME(XAAWriteBitmapScanlineColorExpand3) (
#else
EXPNAME(XAAWriteBitmapScanlineColorExpand) (
#endif
ScrnInfoPtr pScrn,
int x, int y, int w, int h,
unsigned char *src,
int srcwidth,
int skipleft,
int fg, int bg,
int rop,
unsigned int planemask) {
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
CARD32 *base;
unsigned char *srcp = src;
int SecondPassColor = -1;
int shift = 0, dwords, bufferNo;
BitmapScanlineProcPtr firstFunc;
BitmapScanlineProcPtr secondFunc;
#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
if ((rop == GXcopy) && infoRec->SetupForSolidFill) {
(*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
(*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
}
else
SecondPassColor = bg;
bg = -1;
}
#ifdef TRIPLE_BITS
if (skipleft) {
#else
if (skipleft &&
(!(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
LEFT_EDGE_CLIPPING) ||
(!(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
LEFT_EDGE_CLIPPING_NEGATIVE_X) && (skipleft > x)))) {
#endif
if ((skipleft + ((w + 31) & ~31)) > ((skipleft + w + 31) & ~31)) {
/* don't read past the end */
firstFunc = BitmapScanline_Shifted_Careful;
secondFunc = BitmapScanline_Shifted_Inverted_Careful;
}
else {
firstFunc = BitmapScanline_Shifted;
secondFunc = BitmapScanline_Shifted_Inverted;
}
shift = skipleft;
skipleft = 0;
}
else {
firstFunc = BitmapScanline;
secondFunc = BitmapScanline_Inverted;
w += skipleft;
x -= skipleft;
}
#ifdef TRIPLE_BITS
dwords = (3 * w + 31) >> 5;
#else
dwords = (w + 31) >> 5;
#endif
SECOND_PASS:
(*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
planemask);
(*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
skipleft);
bufferNo = 0;
while (h--) {
base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
(*firstFunc) ((CARD32 *) srcp, base, dwords, shift);
(*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
srcp += srcwidth;
if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
bufferNo = 0;
}
if (SecondPassColor != -1) {
fg = SecondPassColor;
SecondPassColor = -1;
firstFunc = secondFunc;
srcp = src;
goto SECOND_PASS;
}
SET_SYNC_FLAG(infoRec);
}
#endif
Reference in New Issue View Git Blame Copy Permalink