fb: FB_SHIFT is 5 (and FB_UNIT is 32)
The other paths don't build or work, PCI and other buses are almost always 32 bit data paths, and X doesn't really support pixels bigger than that anyway. Reviewed-by: Keith Packard <keithp@keithp.com> Signed-off-by: Adam Jackson <ajax@redhat.com>
This commit is contained in:
Adam Jackson
parent
3d35bd6b79
commit
a198373685
173
fb/fb.h
173
fb/fb.h
|
|
@ -83,11 +83,7 @@
|
|||
#define FB_SHIFT LOG2_BITMAP_PAD
|
||||
#endif
|
||||
|
||||
#if FB_SHIFT < LOG2_BITMAP_PAD
|
||||
error FB_SHIFT must be >= LOG2_BITMAP_PAD
|
||||
#endif
|
||||
#define FB_UNIT (1 << FB_SHIFT)
|
||||
#define FB_HALFUNIT (1 << (FB_SHIFT-1))
|
||||
#define FB_MASK (FB_UNIT - 1)
|
||||
#define FB_ALLONES ((FbBits) -1)
|
||||
#if GLYPHPADBYTES != 4
|
||||
|
|
@ -105,37 +101,15 @@ error FB_SHIFT must be >= LOG2_BITMAP_PAD
|
|||
#define FbStipStrideToBitsStride(s) (((s) >> (FB_SHIFT - FB_STIP_SHIFT)))
|
||||
#define FbBitsStrideToStipStride(s) (((s) << (FB_SHIFT - FB_STIP_SHIFT)))
|
||||
#define FbFullMask(n) ((n) == FB_UNIT ? FB_ALLONES : ((((FbBits) 1) << n) - 1))
|
||||
#if FB_SHIFT == 6
|
||||
#ifdef WIN32
|
||||
typedef unsigned __int64 FbBits;
|
||||
#else
|
||||
#if defined(__alpha__) || defined(__alpha) || \
|
||||
defined(ia64) || defined(__ia64__) || \
|
||||
defined(__sparc64__) || defined(_LP64) || \
|
||||
defined(__s390x__) || \
|
||||
defined(amd64) || defined (__amd64__) || \
|
||||
defined (__powerpc64__)
|
||||
typedef unsigned long FbBits;
|
||||
#else
|
||||
typedef unsigned long long FbBits;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if FB_SHIFT == 5
|
||||
typedef CARD32 FbBits;
|
||||
#endif
|
||||
|
||||
#if FB_SHIFT == 4
|
||||
typedef CARD16 FbBits;
|
||||
#else
|
||||
#error "Unsupported FB_SHIFT"
|
||||
#endif
|
||||
|
||||
#if LOG2_BITMAP_PAD == FB_SHIFT
|
||||
typedef FbBits FbStip;
|
||||
#else
|
||||
#if LOG2_BITMAP_PAD == 5
|
||||
typedef CARD32 FbStip;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
typedef int FbStride;
|
||||
|
|
@ -264,122 +238,8 @@ extern _X_EXPORT void fbSetBits(FbStip * bits, int stride, FbStip data);
|
|||
n >>= FB_SHIFT; \
|
||||
}
|
||||
|
||||
#if FB_SHIFT == 6
|
||||
#define FbDoLeftMaskByteRRop6Cases(dst,xor) \
|
||||
case (sizeof (FbBits) - 7) | (1 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 7,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 7) | (2 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 7,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 7) | (3 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 7,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 7) | (4 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 7,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 7) | (5 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 7,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD16,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 7) | (6 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 7,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 2,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 7): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 7,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD32,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 6) | (1 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 6) | (2 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 6) | (3 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 6) | (4 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD16,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 6) | (5 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 2,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 6): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 6,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD32,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 5) | (1 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 5,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 5) | (2 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 5,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 5) | (3 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 5,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD16,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 5) | (4 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 5,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 2,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 5): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 5,CARD8,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD32,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 4) | (1 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 4) | (2 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD16,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 4) | (3 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD16,xor); \
|
||||
FbStorePart(dst,sizeof (FbBits) - 2,CARD8,xor); \
|
||||
break; \
|
||||
case (sizeof (FbBits) - 4): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 4,CARD32,xor); \
|
||||
break;
|
||||
|
||||
#define FbDoRightMaskByteRRop6Cases(dst,xor) \
|
||||
case 4: \
|
||||
FbStorePart(dst,0,CARD32,xor); \
|
||||
break; \
|
||||
case 5: \
|
||||
FbStorePart(dst,0,CARD32,xor); \
|
||||
FbStorePart(dst,4,CARD8,xor); \
|
||||
break; \
|
||||
case 6: \
|
||||
FbStorePart(dst,0,CARD32,xor); \
|
||||
FbStorePart(dst,4,CARD16,xor); \
|
||||
break; \
|
||||
case 7: \
|
||||
FbStorePart(dst,0,CARD32,xor); \
|
||||
FbStorePart(dst,4,CARD16,xor); \
|
||||
FbStorePart(dst,6,CARD8,xor); \
|
||||
break;
|
||||
#else
|
||||
#define FbDoLeftMaskByteRRop6Cases(dst,xor)
|
||||
#define FbDoRightMaskByteRRop6Cases(dst,xor)
|
||||
#endif
|
||||
|
||||
#define FbDoLeftMaskByteRRop(dst,lb,l,and,xor) { \
|
||||
switch (lb) { \
|
||||
FbDoLeftMaskByteRRop6Cases(dst,xor) \
|
||||
case (sizeof (FbBits) - 3) | (1 << (FB_SHIFT - 3)): \
|
||||
FbStorePart(dst,sizeof (FbBits) - 3,CARD8,xor); \
|
||||
break; \
|
||||
|
|
@ -416,7 +276,6 @@ extern _X_EXPORT void fbSetBits(FbStip * bits, int stride, FbStip data);
|
|||
FbStorePart(dst,0,CARD16,xor); \
|
||||
FbStorePart(dst,2,CARD8,xor); \
|
||||
break; \
|
||||
FbDoRightMaskByteRRop6Cases(dst,xor) \
|
||||
default: \
|
||||
WRITE(dst, FbDoMaskRRop (READ(dst), and, xor, r)); \
|
||||
} \
|
||||
|
|
@ -470,21 +329,7 @@ extern _X_EXPORT void fbSetBits(FbStip * bits, int stride, FbStip data);
|
|||
FbLaneCase2((n)>>2,a,(o)+2) \
|
||||
}
|
||||
|
||||
#define FbLaneCase8(n,a,o) \
|
||||
if ((n) == 0x0ff) { \
|
||||
*(FbBits *) ((a)+(o)) = fgxor; \
|
||||
} else { \
|
||||
FbLaneCase4((n)&15,a,o) \
|
||||
FbLaneCase4((n)>>4,a,(o)+4) \
|
||||
}
|
||||
|
||||
#if FB_SHIFT == 6
|
||||
#define FbLaneCase(n,a) FbLaneCase8(n,(CARD8 *) (a),0)
|
||||
#endif
|
||||
|
||||
#if FB_SHIFT == 5
|
||||
#define FbLaneCase(n,a) FbLaneCase4(n,(CARD8 *) (a),0)
|
||||
#endif
|
||||
|
||||
/* Rotate a filled pixel value to the specified alignement */
|
||||
#define FbRot24(p,b) (FbScrRight(p,b) | FbScrLeft(p,24-(b)))
|
||||
|
|
@ -497,19 +342,6 @@ extern _X_EXPORT void fbSetBits(FbStip * bits, int stride, FbStip data);
|
|||
#define FbPrev24Stip(p) (FbRot24(p,FB_STIP_UNIT%24))
|
||||
|
||||
/* step a rotation value to the next/previous rotation value */
|
||||
#if FB_UNIT == 64
|
||||
#define FbNext24Rot(r) ((r) == 16 ? 0 : (r) + 8)
|
||||
#define FbPrev24Rot(r) ((r) == 0 ? 16 : (r) - 8)
|
||||
|
||||
#if IMAGE_BYTE_ORDER == MSBFirst
|
||||
#define FbFirst24Rot(x) (((x) + 8) % 24)
|
||||
#else
|
||||
#define FbFirst24Rot(x) ((x) % 24)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#if FB_UNIT == 32
|
||||
#define FbNext24Rot(r) ((r) == 0 ? 16 : (r) - 8)
|
||||
#define FbPrev24Rot(r) ((r) == 16 ? 0 : (r) + 8)
|
||||
|
||||
|
|
@ -518,7 +350,6 @@ extern _X_EXPORT void fbSetBits(FbStip * bits, int stride, FbStip data);
|
|||
#else
|
||||
#define FbFirst24Rot(x) ((x) % 24)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define FbNext24RotStip(r) ((r) == 0 ? 16 : (r) - 8)
|
||||
#define FbPrev24RotStip(r) ((r) == 16 ? 0 : (r) + 8)
|
||||
|
|
|
|||
12
fb/fbbits.c
12
fb/fbbits.c
|
|
@ -70,9 +70,6 @@
|
|||
#define POLYSEGMENT fbPolySegment16
|
||||
#define BITS CARD16
|
||||
#define BITS2 CARD32
|
||||
#if FB_SHIFT == 6
|
||||
#define BITS4 FbBits
|
||||
#endif
|
||||
|
||||
#include "fbbits.h"
|
||||
|
||||
|
|
@ -85,9 +82,6 @@
|
|||
#undef POLYSEGMENT
|
||||
#undef BITS
|
||||
#undef BITS2
|
||||
#if FB_SHIFT == 6
|
||||
#undef BITS4
|
||||
#endif
|
||||
|
||||
#define BRESSOLID fbBresSolid24
|
||||
#define BRESDASH fbBresDash24
|
||||
|
|
@ -155,9 +149,6 @@
|
|||
#define POLYLINE fbPolyline32
|
||||
#define POLYSEGMENT fbPolySegment32
|
||||
#define BITS CARD32
|
||||
#if FB_SHIFT == 6
|
||||
#define BITS2 FbBits
|
||||
#endif
|
||||
|
||||
#include "fbbits.h"
|
||||
|
||||
|
|
@ -169,6 +160,3 @@
|
|||
#undef POLYLINE
|
||||
#undef POLYSEGMENT
|
||||
#undef BITS
|
||||
#if FB_SHIFT == 6
|
||||
#undef BITS2
|
||||
#endif
|
||||
|
|
|
|||
271
fb/fbblt.c
271
fb/fbblt.c
|
|
@ -520,277 +520,12 @@ fbBlt24(FbBits * srcLine,
|
|||
#endif
|
||||
}
|
||||
|
||||
#if FB_SHIFT == FB_STIP_SHIFT + 1
|
||||
|
||||
/*
|
||||
* Could be generalized to FB_SHIFT > FB_STIP_SHIFT + 1 by
|
||||
* creating an ring of values stepped through for each line
|
||||
*/
|
||||
|
||||
void
|
||||
fbBltOdd(FbBits * srcLine,
|
||||
FbStride srcStrideEven,
|
||||
FbStride srcStrideOdd,
|
||||
int srcXEven,
|
||||
int srcXOdd,
|
||||
FbBits * dstLine,
|
||||
FbStride dstStrideEven,
|
||||
FbStride dstStrideOdd,
|
||||
int dstXEven,
|
||||
int dstXOdd, int width, int height, int alu, FbBits pm, int bpp)
|
||||
{
|
||||
FbBits *src;
|
||||
int leftShiftEven, rightShiftEven;
|
||||
FbBits startmaskEven, endmaskEven;
|
||||
int nmiddleEven;
|
||||
|
||||
FbBits *dst;
|
||||
int leftShiftOdd, rightShiftOdd;
|
||||
FbBits startmaskOdd, endmaskOdd;
|
||||
int nmiddleOdd;
|
||||
|
||||
int leftShift, rightShift;
|
||||
FbBits startmask, endmask;
|
||||
int nmiddle;
|
||||
|
||||
int srcX, dstX;
|
||||
|
||||
FbBits bits, bits1;
|
||||
int n;
|
||||
|
||||
Bool destInvarient;
|
||||
Bool even;
|
||||
|
||||
FbDeclareMergeRop();
|
||||
|
||||
FbInitializeMergeRop(alu, pm);
|
||||
destInvarient = FbDestInvarientMergeRop();
|
||||
|
||||
srcLine += srcXEven >> FB_SHIFT;
|
||||
dstLine += dstXEven >> FB_SHIFT;
|
||||
srcXEven &= FB_MASK;
|
||||
dstXEven &= FB_MASK;
|
||||
srcXOdd &= FB_MASK;
|
||||
dstXOdd &= FB_MASK;
|
||||
|
||||
FbMaskBits(dstXEven, width, startmaskEven, nmiddleEven, endmaskEven);
|
||||
FbMaskBits(dstXOdd, width, startmaskOdd, nmiddleOdd, endmaskOdd);
|
||||
|
||||
even = TRUE;
|
||||
InitializeShifts(srcXEven, dstXEven, leftShiftEven, rightShiftEven);
|
||||
InitializeShifts(srcXOdd, dstXOdd, leftShiftOdd, rightShiftOdd);
|
||||
while (height--) {
|
||||
src = srcLine;
|
||||
dst = dstLine;
|
||||
if (even) {
|
||||
srcX = srcXEven;
|
||||
dstX = dstXEven;
|
||||
startmask = startmaskEven;
|
||||
endmask = endmaskEven;
|
||||
nmiddle = nmiddleEven;
|
||||
leftShift = leftShiftEven;
|
||||
rightShift = rightShiftEven;
|
||||
srcLine += srcStrideEven;
|
||||
dstLine += dstStrideEven;
|
||||
even = FALSE;
|
||||
}
|
||||
else {
|
||||
srcX = srcXOdd;
|
||||
dstX = dstXOdd;
|
||||
startmask = startmaskOdd;
|
||||
endmask = endmaskOdd;
|
||||
nmiddle = nmiddleOdd;
|
||||
leftShift = leftShiftOdd;
|
||||
rightShift = rightShiftOdd;
|
||||
srcLine += srcStrideOdd;
|
||||
dstLine += dstStrideOdd;
|
||||
even = TRUE;
|
||||
}
|
||||
if (srcX == dstX) {
|
||||
if (startmask) {
|
||||
bits = READ(src++);
|
||||
WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), startmask));
|
||||
dst++;
|
||||
}
|
||||
n = nmiddle;
|
||||
if (destInvarient) {
|
||||
while (n--) {
|
||||
bits = READ(src++);
|
||||
WRITE(dst, FbDoDestInvarientMergeRop(bits));
|
||||
dst++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
while (n--) {
|
||||
bits = READ(src++);
|
||||
WRITE(dst, FbDoMergeRop(bits, READ(dst)));
|
||||
dst++;
|
||||
}
|
||||
}
|
||||
if (endmask) {
|
||||
bits = READ(src);
|
||||
WRITE(dst, FbDoMaskMergeRop(bits, READ(dst), endmask));
|
||||
}
|
||||
}
|
||||
else {
|
||||
bits = 0;
|
||||
if (srcX > dstX)
|
||||
bits = READ(src++);
|
||||
if (startmask) {
|
||||
bits1 = FbScrLeft(bits, leftShift);
|
||||
bits = READ(src++);
|
||||
bits1 |= FbScrRight(bits, rightShift);
|
||||
WRITE(dst, FbDoMaskMergeRop(bits1, READ(dst), startmask));
|
||||
dst++;
|
||||
}
|
||||
n = nmiddle;
|
||||
if (destInvarient) {
|
||||
while (n--) {
|
||||
bits1 = FbScrLeft(bits, leftShift);
|
||||
bits = READ(src++);
|
||||
bits1 |= FbScrRight(bits, rightShift);
|
||||
WRITE(dst, FbDoDestInvarientMergeRop(bits1));
|
||||
dst++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
while (n--) {
|
||||
bits1 = FbScrLeft(bits, leftShift);
|
||||
bits = READ(src++);
|
||||
bits1 |= FbScrRight(bits, rightShift);
|
||||
WRITE(dst, FbDoMergeRop(bits1, READ(dst)));
|
||||
dst++;
|
||||
}
|
||||
}
|
||||
if (endmask) {
|
||||
bits1 = FbScrLeft(bits, leftShift);
|
||||
if (FbScrLeft(endmask, rightShift)) {
|
||||
bits = READ(src);
|
||||
bits1 |= FbScrRight(bits, rightShift);
|
||||
}
|
||||
WRITE(dst, FbDoMaskMergeRop(bits1, READ(dst), endmask));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
fbBltOdd24(FbBits * srcLine,
|
||||
FbStride srcStrideEven,
|
||||
FbStride srcStrideOdd,
|
||||
int srcXEven,
|
||||
int srcXOdd,
|
||||
FbBits * dstLine,
|
||||
FbStride dstStrideEven,
|
||||
FbStride dstStrideOdd,
|
||||
int dstXEven, int dstXOdd, int width, int height, int alu, FbBits pm)
|
||||
{
|
||||
Bool even = TRUE;
|
||||
|
||||
while (height--) {
|
||||
if (even) {
|
||||
fbBlt24Line(srcLine, srcXEven, dstLine, dstXEven,
|
||||
width, alu, pm, FALSE);
|
||||
srcLine += srcStrideEven;
|
||||
dstLine += dstStrideEven;
|
||||
even = FALSE;
|
||||
}
|
||||
else {
|
||||
fbBlt24Line(srcLine, srcXOdd, dstLine, dstXOdd,
|
||||
width, alu, pm, FALSE);
|
||||
srcLine += srcStrideOdd;
|
||||
dstLine += dstStrideOdd;
|
||||
even = TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if FB_STIP_SHIFT != FB_SHIFT
|
||||
void
|
||||
fbSetBltOdd(FbStip * stip,
|
||||
FbStride stipStride,
|
||||
int srcX,
|
||||
FbBits ** bits,
|
||||
FbStride * strideEven,
|
||||
FbStride * strideOdd, int *srcXEven, int *srcXOdd)
|
||||
{
|
||||
int srcAdjust;
|
||||
int strideAdjust;
|
||||
|
||||
/*
|
||||
* bytes needed to align source
|
||||
*/
|
||||
srcAdjust = (((int) stip) & (FB_MASK >> 3));
|
||||
/*
|
||||
* FbStip units needed to align stride
|
||||
*/
|
||||
strideAdjust = stipStride & (FB_MASK >> FB_STIP_SHIFT);
|
||||
|
||||
*bits = (FbBits *) ((char *) stip - srcAdjust);
|
||||
if (srcAdjust) {
|
||||
*strideEven = FbStipStrideToBitsStride(stipStride + 1);
|
||||
*strideOdd = FbStipStrideToBitsStride(stipStride);
|
||||
|
||||
*srcXEven = srcX + (srcAdjust << 3);
|
||||
*srcXOdd = srcX + (srcAdjust << 3) - (strideAdjust << FB_STIP_SHIFT);
|
||||
}
|
||||
else {
|
||||
*strideEven = FbStipStrideToBitsStride(stipStride);
|
||||
*strideOdd = FbStipStrideToBitsStride(stipStride + 1);
|
||||
|
||||
*srcXEven = srcX;
|
||||
*srcXOdd = srcX + (strideAdjust << FB_STIP_SHIFT);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
fbBltStip(FbStip * src, FbStride srcStride, /* in FbStip units, not FbBits units */
|
||||
int srcX, FbStip * dst, FbStride dstStride, /* in FbStip units, not FbBits units */
|
||||
int dstX, int width, int height, int alu, FbBits pm, int bpp)
|
||||
{
|
||||
#if FB_STIP_SHIFT != FB_SHIFT
|
||||
if (FB_STIP_ODDSTRIDE(srcStride) || FB_STIP_ODDPTR(src) ||
|
||||
FB_STIP_ODDSTRIDE(dstStride) || FB_STIP_ODDPTR(dst)) {
|
||||
FbStride srcStrideEven, srcStrideOdd;
|
||||
FbStride dstStrideEven, dstStrideOdd;
|
||||
int srcXEven, srcXOdd;
|
||||
int dstXEven, dstXOdd;
|
||||
FbBits *s, *d;
|
||||
int sx, dx;
|
||||
|
||||
src += srcX >> FB_STIP_SHIFT;
|
||||
srcX &= FB_STIP_MASK;
|
||||
dst += dstX >> FB_STIP_SHIFT;
|
||||
dstX &= FB_STIP_MASK;
|
||||
|
||||
fbSetBltOdd(src, srcStride, srcX,
|
||||
&s, &srcStrideEven, &srcStrideOdd, &srcXEven, &srcXOdd);
|
||||
|
||||
fbSetBltOdd(dst, dstStride, dstX,
|
||||
&d, &dstStrideEven, &dstStrideOdd, &dstXEven, &dstXOdd);
|
||||
|
||||
if (bpp == 24 && !FbCheck24Pix(pm)) {
|
||||
fbBltOdd24(s, srcStrideEven, srcStrideOdd,
|
||||
srcXEven, srcXOdd,
|
||||
d, dstStrideEven, dstStrideOdd,
|
||||
dstXEven, dstXOdd, width, height, alu, pm);
|
||||
}
|
||||
else {
|
||||
fbBltOdd(s, srcStrideEven, srcStrideOdd,
|
||||
srcXEven, srcXOdd,
|
||||
d, dstStrideEven, dstStrideOdd,
|
||||
dstXEven, dstXOdd, width, height, alu, pm, bpp);
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
fbBlt((FbBits *) src, FbStipStrideToBitsStride(srcStride),
|
||||
srcX,
|
||||
(FbBits *) dst, FbStipStrideToBitsStride(dstStride),
|
||||
dstX, width, height, alu, pm, bpp, FALSE, FALSE);
|
||||
}
|
||||
fbBlt((FbBits *) src, FbStipStrideToBitsStride(srcStride), srcX,
|
||||
(FbBits *) dst, FbStipStrideToBitsStride(dstStride), dstX,
|
||||
width, height, alu, pm, bpp, FALSE, FALSE);
|
||||
}
|
||||
|
|
|
|||
114
fb/fbbltone.c
114
fb/fbbltone.c
|
|
@ -67,59 +67,9 @@
|
|||
#define LaneCases4(n,a) LaneCases2(n,a); LaneCases2(n+2,a)
|
||||
#define LaneCases8(n,a) LaneCases4(n,a); LaneCases4(n+4,a)
|
||||
#define LaneCases16(n,a) LaneCases8(n,a); LaneCases8(n+8,a)
|
||||
#define LaneCases32(n,a) LaneCases16(n,a); LaneCases16(n+16,a)
|
||||
#define LaneCases64(n,a) LaneCases32(n,a); LaneCases32(n+32,a)
|
||||
#define LaneCases128(n,a) LaneCases64(n,a); LaneCases64(n+64,a)
|
||||
#define LaneCases256(n,a) LaneCases128(n,a); LaneCases128(n+128,a)
|
||||
|
||||
#if FB_SHIFT == 6
|
||||
#define LaneCases(a) LaneCases256(0,a)
|
||||
#endif
|
||||
|
||||
#if FB_SHIFT == 5
|
||||
#define LaneCases(a) LaneCases16(0,a)
|
||||
#endif
|
||||
|
||||
#if FB_SHIFT == 6
|
||||
static const CARD8 fb8Lane[256] = {
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
|
||||
21,
|
||||
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
|
||||
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
|
||||
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
|
||||
79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
|
||||
98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
|
||||
113, 114, 115,
|
||||
116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,
|
||||
131, 132, 133,
|
||||
134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
|
||||
149, 150, 151,
|
||||
152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166,
|
||||
167, 168, 169,
|
||||
170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
|
||||
185, 186, 187,
|
||||
188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202,
|
||||
203, 204, 205,
|
||||
206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
|
||||
221, 222, 223,
|
||||
224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
|
||||
239, 240, 241,
|
||||
242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
|
||||
};
|
||||
|
||||
static const CARD8 fb16Lane[256] = {
|
||||
0x00, 0x03, 0x0c, 0x0f,
|
||||
0x30, 0x33, 0x3c, 0x3f,
|
||||
0xc0, 0xc3, 0xcc, 0xcf,
|
||||
0xf0, 0xf3, 0xfc, 0xff,
|
||||
};
|
||||
|
||||
static const CARD8 fb32Lane[16] = {
|
||||
0x00, 0x0f, 0xf0, 0xff,
|
||||
};
|
||||
#endif
|
||||
|
||||
#if FB_SHIFT == 5
|
||||
static const CARD8 fb8Lane[16] = {
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
|
||||
};
|
||||
|
|
@ -131,7 +81,6 @@ static const CARD8 fb16Lane[16] = {
|
|||
static const CARD8 fb32Lane[16] = {
|
||||
0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
};
|
||||
#endif
|
||||
|
||||
void
|
||||
fbBltOne(FbStip * src, FbStride srcStride, /* FbStip units per scanline */
|
||||
|
|
@ -285,12 +234,7 @@ fbBltOne(FbStip * src, FbStride srcStride, /* FbStip units per scanline */
|
|||
* Consume stipple bits for startmask
|
||||
*/
|
||||
if (startmask) {
|
||||
#if FB_UNIT > 32
|
||||
if (pixelsPerDst == 16)
|
||||
mask = FbStipple16Bits(FbLeftStipBits(bits, 16));
|
||||
else
|
||||
#endif
|
||||
mask = fbBits[FbLeftStipBits(bits, pixelsPerDst)];
|
||||
mask = fbBits[FbLeftStipBits(bits, pixelsPerDst)];
|
||||
if (fbLane) {
|
||||
fbTransparentSpan(dst, mask & startmask, fgxor, 1);
|
||||
}
|
||||
|
|
@ -312,12 +256,7 @@ fbBltOne(FbStip * src, FbStride srcStride, /* FbStip units per scanline */
|
|||
w -= n;
|
||||
if (copy) {
|
||||
while (n--) {
|
||||
#if FB_UNIT > 32
|
||||
if (pixelsPerDst == 16)
|
||||
mask = FbStipple16Bits(FbLeftStipBits(bits, 16));
|
||||
else
|
||||
#endif
|
||||
mask = fbBits[FbLeftStipBits(bits, pixelsPerDst)];
|
||||
mask = fbBits[FbLeftStipBits(bits, pixelsPerDst)];
|
||||
WRITE(dst, FbOpaqueStipple(mask, fgxor, bgxor));
|
||||
dst++;
|
||||
bits = FbStipLeft(bits, pixelsPerDst);
|
||||
|
|
@ -367,12 +306,7 @@ fbBltOne(FbStip * src, FbStride srcStride, /* FbStip units per scanline */
|
|||
if (endNeedsLoad) {
|
||||
LoadBits;
|
||||
}
|
||||
#if FB_UNIT > 32
|
||||
if (pixelsPerDst == 16)
|
||||
mask = FbStipple16Bits(FbLeftStipBits(bits, 16));
|
||||
else
|
||||
#endif
|
||||
mask = fbBits[FbLeftStipBits(bits, pixelsPerDst)];
|
||||
mask = fbBits[FbLeftStipBits(bits, pixelsPerDst)];
|
||||
if (fbLane) {
|
||||
fbTransparentSpan(dst, mask & endmask, fgxor, 1);
|
||||
}
|
||||
|
|
@ -410,47 +344,6 @@ fbBltOne(FbStip * src, FbStride srcStride, /* FbStip units per scanline */
|
|||
|
||||
#define SelMask24(b,n,r) ((((b) >> n) & 1) * Mask24(n,r))
|
||||
|
||||
/*
|
||||
* Untested for MSBFirst or FB_UNIT == 32
|
||||
*/
|
||||
|
||||
#if FB_UNIT == 64
|
||||
#define C4_24(b,r) \
|
||||
(SelMask24(b,0,r) | \
|
||||
SelMask24(b,1,r) | \
|
||||
SelMask24(b,2,r) | \
|
||||
SelMask24(b,3,r))
|
||||
|
||||
#define FbStip24New(rot) (2 + (rot != 0))
|
||||
#define FbStip24Len 4
|
||||
|
||||
const FbBits fbStipple24Bits[3][1 << FbStip24Len] = {
|
||||
/* rotate 0 */
|
||||
{
|
||||
C4_24(0, 0), C4_24(1, 0), C4_24(2, 0), C4_24(3, 0),
|
||||
C4_24(4, 0), C4_24(5, 0), C4_24(6, 0), C4_24(7, 0),
|
||||
C4_24(8, 0), C4_24(9, 0), C4_24(10, 0), C4_24(11, 0),
|
||||
C4_24(12, 0), C4_24(13, 0), C4_24(14, 0), C4_24(15, 0),
|
||||
},
|
||||
/* rotate 8 */
|
||||
{
|
||||
C4_24(0, 8), C4_24(1, 8), C4_24(2, 8), C4_24(3, 8),
|
||||
C4_24(4, 8), C4_24(5, 8), C4_24(6, 8), C4_24(7, 8),
|
||||
C4_24(8, 8), C4_24(9, 8), C4_24(10, 8), C4_24(11, 8),
|
||||
C4_24(12, 8), C4_24(13, 8), C4_24(14, 8), C4_24(15, 8),
|
||||
},
|
||||
/* rotate 16 */
|
||||
{
|
||||
C4_24(0, 16), C4_24(1, 16), C4_24(2, 16), C4_24(3, 16),
|
||||
C4_24(4, 16), C4_24(5, 16), C4_24(6, 16), C4_24(7, 16),
|
||||
C4_24(8, 16), C4_24(9, 16), C4_24(10, 16), C4_24(11, 16),
|
||||
C4_24(12, 16), C4_24(13, 16), C4_24(14, 16), C4_24(15, 16),
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#if FB_UNIT == 32
|
||||
#define C2_24(b,r) \
|
||||
(SelMask24(b,0,r) | \
|
||||
SelMask24(b,1,r))
|
||||
|
|
@ -476,7 +369,6 @@ const FbBits fbStipple24Bits[3][1 << FbStip24Len] = {
|
|||
C2_24(0, 16), C2_24(1, 16), C2_24(2, 16), C2_24(3, 16),
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
#if BITMAP_BIT_ORDER == LSBFirst
|
||||
|
||||
|
|
|
|||
|
|
@ -56,11 +56,7 @@ fbGlyphIn(RegionPtr pRegion, int x, int y, int width, int height)
|
|||
#define WRITE1(d,n,fg) WRITE((d) + (n), (CARD8) fg)
|
||||
#define WRITE2(d,n,fg) WRITE((CARD16 *) &(d[n]), (CARD16) fg)
|
||||
#define WRITE4(d,n,fg) WRITE((CARD32 *) &(d[n]), (CARD32) fg)
|
||||
#if FB_UNIT == 6 && IMAGE_BYTE_ORDER == LSBFirst
|
||||
#define WRITE8(d) WRITE((FbBits *) &(d[0]), fg)
|
||||
#else
|
||||
#define WRITE8(d) WRITE4(d,0,_ABCA), WRITE4(d,4,_BCAB)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* This is a bit tricky, but it's brief. Write 12 bytes worth
|
||||
|
|
|
|||
|
|
@ -309,17 +309,9 @@ create_bits_picture(PicturePtr pict, Bool has_clip, int *xoff, int *yoff)
|
|||
return NULL;
|
||||
|
||||
#ifdef FB_ACCESS_WRAPPER
|
||||
#if FB_SHIFT==5
|
||||
|
||||
pixman_image_set_accessors(image,
|
||||
(pixman_read_memory_func_t) wfbReadMemory,
|
||||
(pixman_write_memory_func_t) wfbWriteMemory);
|
||||
|
||||
#else
|
||||
|
||||
#error The pixman library only works when FbBits is 32 bits wide
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* pCompositeClip is undefined for source pictures, so
|
||||
|
|
|
|||
|
|
@ -95,10 +95,6 @@ extern _X_EXPORT const FbMergeRopRec FbMergeRopBits[16];
|
|||
* Stippling operations;
|
||||
*/
|
||||
|
||||
extern _X_EXPORT const FbBits fbStipple16Bits[256]; /* half of table */
|
||||
|
||||
#define FbStipple16Bits(b) \
|
||||
(fbStipple16Bits[(b)&0xff] | fbStipple16Bits[(b) >> 8] << FB_HALFUNIT)
|
||||
extern _X_EXPORT const FbBits fbStipple8Bits[256];
|
||||
extern _X_EXPORT const FbBits fbStipple4Bits[16];
|
||||
extern _X_EXPORT const FbBits fbStipple2Bits[4];
|
||||
|
|
|
|||
|
|
@ -38,18 +38,8 @@
|
|||
#define LaneCases4(c,a) LaneCases2(c,a); LaneCases2(c+2,a)
|
||||
#define LaneCases8(c,a) LaneCases4(c,a); LaneCases4(c+4,a)
|
||||
#define LaneCases16(c,a) LaneCases8(c,a); LaneCases8(c+8,a)
|
||||
#define LaneCases32(c,a) LaneCases16(c,a); LaneCases16(c+16,a)
|
||||
#define LaneCases64(c,a) LaneCases32(c,a); LaneCases32(c+32,a)
|
||||
#define LaneCases128(c,a) LaneCases64(c,a); LaneCases64(c+64,a)
|
||||
#define LaneCases256(c,a) LaneCases128(c,a); LaneCases128(c+128,a)
|
||||
|
||||
#if FB_SHIFT == 6
|
||||
#define LaneCases(a) LaneCases256(0,a)
|
||||
#endif
|
||||
|
||||
#if FB_SHIFT == 5
|
||||
#define LaneCases(a) LaneCases16(0,a)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Repeat a transparent stipple across a scanline n times
|
||||
|
|
@ -64,12 +54,6 @@ fbTransparentSpan(FbBits * dst, FbBits stip, FbBits fgxor, int n)
|
|||
s |= ((FbStip) (stip >> 8) & 0x02);
|
||||
s |= ((FbStip) (stip >> 16) & 0x04);
|
||||
s |= ((FbStip) (stip >> 24) & 0x08);
|
||||
#if FB_SHIFT > 5
|
||||
s |= ((FbStip) (stip >> 32) & 0x10);
|
||||
s |= ((FbStip) (stip >> 40) & 0x20);
|
||||
s |= ((FbStip) (stip >> 48) & 0x40);
|
||||
s |= ((FbStip) (stip >> 56) & 0x80);
|
||||
#endif
|
||||
switch (s) {
|
||||
LaneCases(dst);
|
||||
}
|
||||
|
|
@ -142,12 +126,7 @@ fbEvenStipple(FbBits * dst,
|
|||
s += stipStride;
|
||||
if (s == stipEnd)
|
||||
s = stip;
|
||||
#if FB_UNIT > 32
|
||||
if (pixelsPerDst == 16)
|
||||
mask = FbStipple16Bits(FbLeftStipBits(bits, 16));
|
||||
else
|
||||
#endif
|
||||
mask = fbBits[FbLeftStipBits(bits, pixelsPerDst)];
|
||||
mask = fbBits[FbLeftStipBits(bits, pixelsPerDst)];
|
||||
/*
|
||||
* Rotate into position and compute reduced rop values
|
||||
*/
|
||||
|
|
|
|||
123
fb/fbutil.c
123
fb/fbutil.c
|
|
@ -174,24 +174,6 @@ const FbMergeRopRec FbMergeRopBits[16] = {
|
|||
SelMask(b,6,w) | \
|
||||
SelMask(b,7,w))
|
||||
|
||||
#if FB_UNIT == 16
|
||||
#define fbStipple16Bits 0
|
||||
#define fbStipple8Bits 0
|
||||
const FbBits fbStipple4Bits[16] = {
|
||||
C4(0, 4), C4(1, 4), C4(2, 4), C4(3, 4), C4(4, 4), C4(5, 4),
|
||||
C4(6, 4), C4(7, 4), C4(8, 4), C4(9, 4), C4(10, 4), C4(11, 4),
|
||||
C4(12, 4), C4(13, 4), C4(14, 4), C4(15, 4),
|
||||
};
|
||||
|
||||
const FbBits fbStipple2Bits[4] = {
|
||||
C2(0, 8), C2(1, 8), C2(2, 8), C2(3, 8),
|
||||
};
|
||||
|
||||
const FbBits fbStipple1Bits[2] = {
|
||||
C1(0, 16), C1(1, 16),
|
||||
};
|
||||
#endif
|
||||
#if FB_UNIT == 32
|
||||
#define fbStipple16Bits 0
|
||||
const FbBits fbStipple8Bits[256] = {
|
||||
C8(0, 4), C8(1, 4), C8(2, 4), C8(3, 4), C8(4, 4), C8(5, 4),
|
||||
|
|
@ -252,112 +234,7 @@ const FbBits fbStipple2Bits[4] = {
|
|||
const FbBits fbStipple1Bits[2] = {
|
||||
C1(0, 32), C1(1, 32),
|
||||
};
|
||||
#endif
|
||||
#if FB_UNIT == 64
|
||||
const FbBits fbStipple16Bits[256] = {
|
||||
C8(0, 4), C8(1, 4), C8(2, 4), C8(3, 4), C8(4, 4), C8(5, 4),
|
||||
C8(6, 4), C8(7, 4), C8(8, 4), C8(9, 4), C8(10, 4), C8(11, 4),
|
||||
C8(12, 4), C8(13, 4), C8(14, 4), C8(15, 4), C8(16, 4), C8(17, 4),
|
||||
C8(18, 4), C8(19, 4), C8(20, 4), C8(21, 4), C8(22, 4), C8(23, 4),
|
||||
C8(24, 4), C8(25, 4), C8(26, 4), C8(27, 4), C8(28, 4), C8(29, 4),
|
||||
C8(30, 4), C8(31, 4), C8(32, 4), C8(33, 4), C8(34, 4), C8(35, 4),
|
||||
C8(36, 4), C8(37, 4), C8(38, 4), C8(39, 4), C8(40, 4), C8(41, 4),
|
||||
C8(42, 4), C8(43, 4), C8(44, 4), C8(45, 4), C8(46, 4), C8(47, 4),
|
||||
C8(48, 4), C8(49, 4), C8(50, 4), C8(51, 4), C8(52, 4), C8(53, 4),
|
||||
C8(54, 4), C8(55, 4), C8(56, 4), C8(57, 4), C8(58, 4), C8(59, 4),
|
||||
C8(60, 4), C8(61, 4), C8(62, 4), C8(63, 4), C8(64, 4), C8(65, 4),
|
||||
C8(66, 4), C8(67, 4), C8(68, 4), C8(69, 4), C8(70, 4), C8(71, 4),
|
||||
C8(72, 4), C8(73, 4), C8(74, 4), C8(75, 4), C8(76, 4), C8(77, 4),
|
||||
C8(78, 4), C8(79, 4), C8(80, 4), C8(81, 4), C8(82, 4), C8(83, 4),
|
||||
C8(84, 4), C8(85, 4), C8(86, 4), C8(87, 4), C8(88, 4), C8(89, 4),
|
||||
C8(90, 4), C8(91, 4), C8(92, 4), C8(93, 4), C8(94, 4), C8(95, 4),
|
||||
C8(96, 4), C8(97, 4), C8(98, 4), C8(99, 4), C8(100, 4), C8(101, 4),
|
||||
C8(102, 4), C8(103, 4), C8(104, 4), C8(105, 4), C8(106, 4), C8(107, 4),
|
||||
C8(108, 4), C8(109, 4), C8(110, 4), C8(111, 4), C8(112, 4), C8(113, 4),
|
||||
C8(114, 4), C8(115, 4), C8(116, 4), C8(117, 4), C8(118, 4), C8(119, 4),
|
||||
C8(120, 4), C8(121, 4), C8(122, 4), C8(123, 4), C8(124, 4), C8(125, 4),
|
||||
C8(126, 4), C8(127, 4), C8(128, 4), C8(129, 4), C8(130, 4), C8(131, 4),
|
||||
C8(132, 4), C8(133, 4), C8(134, 4), C8(135, 4), C8(136, 4), C8(137, 4),
|
||||
C8(138, 4), C8(139, 4), C8(140, 4), C8(141, 4), C8(142, 4), C8(143, 4),
|
||||
C8(144, 4), C8(145, 4), C8(146, 4), C8(147, 4), C8(148, 4), C8(149, 4),
|
||||
C8(150, 4), C8(151, 4), C8(152, 4), C8(153, 4), C8(154, 4), C8(155, 4),
|
||||
C8(156, 4), C8(157, 4), C8(158, 4), C8(159, 4), C8(160, 4), C8(161, 4),
|
||||
C8(162, 4), C8(163, 4), C8(164, 4), C8(165, 4), C8(166, 4), C8(167, 4),
|
||||
C8(168, 4), C8(169, 4), C8(170, 4), C8(171, 4), C8(172, 4), C8(173, 4),
|
||||
C8(174, 4), C8(175, 4), C8(176, 4), C8(177, 4), C8(178, 4), C8(179, 4),
|
||||
C8(180, 4), C8(181, 4), C8(182, 4), C8(183, 4), C8(184, 4), C8(185, 4),
|
||||
C8(186, 4), C8(187, 4), C8(188, 4), C8(189, 4), C8(190, 4), C8(191, 4),
|
||||
C8(192, 4), C8(193, 4), C8(194, 4), C8(195, 4), C8(196, 4), C8(197, 4),
|
||||
C8(198, 4), C8(199, 4), C8(200, 4), C8(201, 4), C8(202, 4), C8(203, 4),
|
||||
C8(204, 4), C8(205, 4), C8(206, 4), C8(207, 4), C8(208, 4), C8(209, 4),
|
||||
C8(210, 4), C8(211, 4), C8(212, 4), C8(213, 4), C8(214, 4), C8(215, 4),
|
||||
C8(216, 4), C8(217, 4), C8(218, 4), C8(219, 4), C8(220, 4), C8(221, 4),
|
||||
C8(222, 4), C8(223, 4), C8(224, 4), C8(225, 4), C8(226, 4), C8(227, 4),
|
||||
C8(228, 4), C8(229, 4), C8(230, 4), C8(231, 4), C8(232, 4), C8(233, 4),
|
||||
C8(234, 4), C8(235, 4), C8(236, 4), C8(237, 4), C8(238, 4), C8(239, 4),
|
||||
C8(240, 4), C8(241, 4), C8(242, 4), C8(243, 4), C8(244, 4), C8(245, 4),
|
||||
C8(246, 4), C8(247, 4), C8(248, 4), C8(249, 4), C8(250, 4), C8(251, 4),
|
||||
C8(252, 4), C8(253, 4), C8(254, 4), C8(255, 4),
|
||||
};
|
||||
|
||||
const FbBits fbStipple8Bits[256] = {
|
||||
C8(0, 8), C8(1, 8), C8(2, 8), C8(3, 8), C8(4, 8), C8(5, 8),
|
||||
C8(6, 8), C8(7, 8), C8(8, 8), C8(9, 8), C8(10, 8), C8(11, 8),
|
||||
C8(12, 8), C8(13, 8), C8(14, 8), C8(15, 8), C8(16, 8), C8(17, 8),
|
||||
C8(18, 8), C8(19, 8), C8(20, 8), C8(21, 8), C8(22, 8), C8(23, 8),
|
||||
C8(24, 8), C8(25, 8), C8(26, 8), C8(27, 8), C8(28, 8), C8(29, 8),
|
||||
C8(30, 8), C8(31, 8), C8(32, 8), C8(33, 8), C8(34, 8), C8(35, 8),
|
||||
C8(36, 8), C8(37, 8), C8(38, 8), C8(39, 8), C8(40, 8), C8(41, 8),
|
||||
C8(42, 8), C8(43, 8), C8(44, 8), C8(45, 8), C8(46, 8), C8(47, 8),
|
||||
C8(48, 8), C8(49, 8), C8(50, 8), C8(51, 8), C8(52, 8), C8(53, 8),
|
||||
C8(54, 8), C8(55, 8), C8(56, 8), C8(57, 8), C8(58, 8), C8(59, 8),
|
||||
C8(60, 8), C8(61, 8), C8(62, 8), C8(63, 8), C8(64, 8), C8(65, 8),
|
||||
C8(66, 8), C8(67, 8), C8(68, 8), C8(69, 8), C8(70, 8), C8(71, 8),
|
||||
C8(72, 8), C8(73, 8), C8(74, 8), C8(75, 8), C8(76, 8), C8(77, 8),
|
||||
C8(78, 8), C8(79, 8), C8(80, 8), C8(81, 8), C8(82, 8), C8(83, 8),
|
||||
C8(84, 8), C8(85, 8), C8(86, 8), C8(87, 8), C8(88, 8), C8(89, 8),
|
||||
C8(90, 8), C8(91, 8), C8(92, 8), C8(93, 8), C8(94, 8), C8(95, 8),
|
||||
C8(96, 8), C8(97, 8), C8(98, 8), C8(99, 8), C8(100, 8), C8(101, 8),
|
||||
C8(102, 8), C8(103, 8), C8(104, 8), C8(105, 8), C8(106, 8), C8(107, 8),
|
||||
C8(108, 8), C8(109, 8), C8(110, 8), C8(111, 8), C8(112, 8), C8(113, 8),
|
||||
C8(114, 8), C8(115, 8), C8(116, 8), C8(117, 8), C8(118, 8), C8(119, 8),
|
||||
C8(120, 8), C8(121, 8), C8(122, 8), C8(123, 8), C8(124, 8), C8(125, 8),
|
||||
C8(126, 8), C8(127, 8), C8(128, 8), C8(129, 8), C8(130, 8), C8(131, 8),
|
||||
C8(132, 8), C8(133, 8), C8(134, 8), C8(135, 8), C8(136, 8), C8(137, 8),
|
||||
C8(138, 8), C8(139, 8), C8(140, 8), C8(141, 8), C8(142, 8), C8(143, 8),
|
||||
C8(144, 8), C8(145, 8), C8(146, 8), C8(147, 8), C8(148, 8), C8(149, 8),
|
||||
C8(150, 8), C8(151, 8), C8(152, 8), C8(153, 8), C8(154, 8), C8(155, 8),
|
||||
C8(156, 8), C8(157, 8), C8(158, 8), C8(159, 8), C8(160, 8), C8(161, 8),
|
||||
C8(162, 8), C8(163, 8), C8(164, 8), C8(165, 8), C8(166, 8), C8(167, 8),
|
||||
C8(168, 8), C8(169, 8), C8(170, 8), C8(171, 8), C8(172, 8), C8(173, 8),
|
||||
C8(174, 8), C8(175, 8), C8(176, 8), C8(177, 8), C8(178, 8), C8(179, 8),
|
||||
C8(180, 8), C8(181, 8), C8(182, 8), C8(183, 8), C8(184, 8), C8(185, 8),
|
||||
C8(186, 8), C8(187, 8), C8(188, 8), C8(189, 8), C8(190, 8), C8(191, 8),
|
||||
C8(192, 8), C8(193, 8), C8(194, 8), C8(195, 8), C8(196, 8), C8(197, 8),
|
||||
C8(198, 8), C8(199, 8), C8(200, 8), C8(201, 8), C8(202, 8), C8(203, 8),
|
||||
C8(204, 8), C8(205, 8), C8(206, 8), C8(207, 8), C8(208, 8), C8(209, 8),
|
||||
C8(210, 8), C8(211, 8), C8(212, 8), C8(213, 8), C8(214, 8), C8(215, 8),
|
||||
C8(216, 8), C8(217, 8), C8(218, 8), C8(219, 8), C8(220, 8), C8(221, 8),
|
||||
C8(222, 8), C8(223, 8), C8(224, 8), C8(225, 8), C8(226, 8), C8(227, 8),
|
||||
C8(228, 8), C8(229, 8), C8(230, 8), C8(231, 8), C8(232, 8), C8(233, 8),
|
||||
C8(234, 8), C8(235, 8), C8(236, 8), C8(237, 8), C8(238, 8), C8(239, 8),
|
||||
C8(240, 8), C8(241, 8), C8(242, 8), C8(243, 8), C8(244, 8), C8(245, 8),
|
||||
C8(246, 8), C8(247, 8), C8(248, 8), C8(249, 8), C8(250, 8), C8(251, 8),
|
||||
C8(252, 8), C8(253, 8), C8(254, 8), C8(255, 8),
|
||||
};
|
||||
|
||||
const FbBits fbStipple4Bits[16] = {
|
||||
C4(0, 16), C4(1, 16), C4(2, 16), C4(3, 16), C4(4, 16), C4(5, 16),
|
||||
C4(6, 16), C4(7, 16), C4(8, 16), C4(9, 16), C4(10, 16), C4(11, 16),
|
||||
C4(12, 16), C4(13, 16), C4(14, 16), C4(15, 16),
|
||||
};
|
||||
|
||||
const FbBits fbStipple2Bits[4] = {
|
||||
C2(0, 32), C2(1, 32), C2(2, 32), C2(3, 32),
|
||||
};
|
||||
|
||||
#define fbStipple1Bits 0
|
||||
#endif
|
||||
const FbBits *const fbStippleTable[] = {
|
||||
0,
|
||||
fbStipple1Bits,
|
||||
|
|
|
|||
Loading…
Reference in New Issue