#define INLINE inline
/* End of stuff added to get it to compile
- */
+ */
static unsigned int
SourcePictureClassify (source_image_t *pict,
pixman_fixed_48_16_t dx, dy, a, b, off;
pixman_fixed_48_16_t factors[4];
int i;
-
+
dx = linear->p2.x - linear->p1.x;
dy = linear->p2.y - linear->p1.y;
l = dx * dx + dy * dy;
{
a = b = 0;
}
-
+
off = (-a * linear->p1.x
-b * linear->p1.y) >> 16;
-
+
for (i = 0; i < 3; i++)
{
v.vector[0] = pixman_int_to_fixed ((i % 2) * (width - 1) + x);
v.vector[1] = pixman_int_to_fixed ((i / 2) * (height - 1) + y);
v.vector[2] = pixman_fixed_1;
-
+
if (pict->common.transform)
{
if (!pixman_transform_point_3d (pict->common.transform, &v))
return SOURCE_IMAGE_CLASS_UNKNOWN;
}
-
+
factors[i] = ((a * v.vector[0] + b * v.vector[1]) >> 16) + off;
}
-
+
if (factors[2] == factors[0])
pict->class = SOURCE_IMAGE_CLASS_HORIZONTAL;
else if (factors[1] == factors[0])
pict->class = SOURCE_IMAGE_CLASS_VERTICAL;
}
-
+
return pict->class;
}
stride * pict->height; \
int offset1 = stride < 0 ? \
offset0 + ((-stride) >> 1) * ((pict->height) >> 1) : \
- offset0 + (offset0 >> 2);
+ offset0 + (offset0 >> 2);
#define YV12_Y(line) \
((uint8_t *) ((bits) + (stride) * (line)))
typedef FASTCALL void (*fetchProc)(bits_image_t *pict, int x, int y, int width, uint32_t *buffer);
/*
- * Used by READ/WRITE macros
- */
-#define image ((pixman_image_t *)pict)
-
-/*
* All of the fetch functions
*/
fbFetch_a8r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
- MEMCPY_WRAPPED(buffer, (const uint32_t *)bits + x,
+ MEMCPY_WRAPPED(pict,
+ buffer, (const uint32_t *)bits + x,
width*sizeof(uint32_t));
}
const uint32_t *pixel = (const uint32_t *)bits + x;
const uint32_t *end = pixel + width;
while (pixel < end) {
- *buffer++ = READ(pixel++) | 0xff000000;
+ *buffer++ = READ(pict, pixel++) | 0xff000000;
}
}
const uint32_t *pixel = (uint32_t *)bits + x;
const uint32_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
+ uint32_t p = READ(pict, pixel++);
*buffer++ = (p & 0xff00ff00) |
((p >> 16) & 0xff) |
((p & 0xff) << 16);
const uint32_t *pixel = (uint32_t *)bits + x;
const uint32_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
+ uint32_t p = READ(pict, pixel++);
*buffer++ = 0xff000000 |
(p & 0x0000ff00) |
((p >> 16) & 0xff) |
const uint8_t *pixel = (const uint8_t *)bits + 3*x;
const uint8_t *end = pixel + 3*width;
while (pixel < end) {
- uint32_t b = Fetch24(pixel) | 0xff000000;
+ uint32_t b = Fetch24(pict, pixel) | 0xff000000;
pixel += 3;
*buffer++ = b;
}
while (pixel < end) {
uint32_t b = 0xff000000;
#if IMAGE_BYTE_ORDER == MSBFirst
- b |= (READ(pixel++));
- b |= (READ(pixel++) << 8);
- b |= (READ(pixel++) << 16);
+ b |= (READ(pict, pixel++));
+ b |= (READ(pict, pixel++) << 8);
+ b |= (READ(pict, pixel++) << 16);
#else
- b |= (READ(pixel++) << 16);
- b |= (READ(pixel++) << 8);
- b |= (READ(pixel++));
+ b |= (READ(pict, pixel++) << 16);
+ b |= (READ(pict, pixel++) << 8);
+ b |= (READ(pict, pixel++));
#endif
*buffer++ = b;
}
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
- uint32_t r = (((p) << 3) & 0xf8) |
+ uint32_t p = READ(pict, pixel++);
+ uint32_t r = (((p) << 3) & 0xf8) |
(((p) << 5) & 0xfc00) |
(((p) << 8) & 0xf80000);
r |= (r >> 5) & 0x70007;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
+ uint32_t p = READ(pict, pixel++);
b = ((p & 0xf800) | ((p & 0xe000) >> 5)) >> 8;
g = ((p & 0x07e0) | ((p & 0x0600) >> 6)) << 5;
r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
a = (uint32_t) ((uint8_t) (0 - ((p & 0x8000) >> 15))) << 24;
r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
b = ((p & 0x001c) | ((p & 0x001f) << 5)) >> 2;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
a = (uint32_t) ((uint8_t) (0 - ((p & 0x8000) >> 15))) << 24;
b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
b = ((p & 0x000f) | ((p & 0x000f) << 4));
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) >> 4;
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) >> 4;
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
r = ((p & 0x000f) | ((p & 0x000f) << 4)) << 16;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- *buffer++ = READ(pixel++) << 24;
+ *buffer++ = READ(pict, pixel++) << 24;
}
}
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
r = ((p & 0xe0) | ((p & 0xe0) >> 3) | ((p & 0xc0) >> 6)) << 16;
g = ((p & 0x1c) | ((p & 0x18) >> 3) | ((p & 0x1c) << 3)) << 8;
b = (((p & 0x03) ) |
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
b = (((p & 0xc0) ) |
((p & 0xc0) >> 2) |
((p & 0xc0) >> 4) |
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
a = ((p & 0xc0) * 0x55) << 18;
r = ((p & 0x30) * 0x55) << 12;
g = ((p & 0x0c) * 0x55) << 6;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
-
+ uint32_t p = READ(pict, pixel++);
+
a = ((p & 0xc0) * 0x55) << 18;
b = ((p & 0x30) * 0x55) >> 6;
g = ((p & 0x0c) * 0x55) << 6;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pixel++);
+ uint32_t p = READ(pict, pixel++);
*buffer++ = indexed->rgba[p];
}
}
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint8_t p = READ(pixel++) & 0xf;
+ uint8_t p = READ(pict, pixel++) & 0xf;
*buffer++ = (p | (p << 4)) << 24;
}
}
-#define Fetch8(l,o) (READ((uint8_t *)(l) + ((o) >> 2)))
+#define Fetch8(img,l,o) (READ(img, (uint8_t *)(l) + ((o) >> 2)))
#if IMAGE_BYTE_ORDER == MSBFirst
-#define Fetch4(l,o) ((o) & 2 ? Fetch8(l,o) & 0xf : Fetch8(l,o) >> 4)
+#define Fetch4(img,l,o) ((o) & 2 ? Fetch8(img,l,o) & 0xf : Fetch8(img,l,o) >> 4)
#else
-#define Fetch4(l,o) ((o) & 2 ? Fetch8(l,o) >> 4 : Fetch8(l,o) & 0xf)
+#define Fetch4(img,l,o) ((o) & 2 ? Fetch8(img,l,o) >> 4 : Fetch8(img,l,o) & 0xf)
#endif
static FASTCALL void
const uint32_t *bits = pict->bits + y*pict->rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(bits, i + x);
-
+ uint32_t p = Fetch4(pict, bits, i + x);
+
p |= p << 4;
*buffer++ = p << 24;
}
const uint32_t *bits = pict->bits + y*pict->rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(bits, i + x);
-
+ uint32_t p = Fetch4(pict, bits, i + x);
+
r = ((p & 0x8) * 0xff) << 13;
g = ((p & 0x6) * 0x55) << 7;
b = ((p & 0x1) * 0xff);
const uint32_t *bits = pict->bits + y*pict->rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(bits, i + x);
-
+ uint32_t p = Fetch4(pict, bits, i + x);
+
b = ((p & 0x8) * 0xff) >> 3;
g = ((p & 0x6) * 0x55) << 7;
r = ((p & 0x1) * 0xff) << 16;
const uint32_t *bits = pict->bits + y*pict->rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(bits, i + x);
-
+ uint32_t p = Fetch4(pict, bits, i + x);
+
a = ((p & 0x8) * 0xff) << 21;
r = ((p & 0x4) * 0xff) << 14;
g = ((p & 0x2) * 0xff) << 7;
const uint32_t *bits = pict->bits + y*pict->rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(bits, i + x);
-
+ uint32_t p = Fetch4(pict, bits, i + x);
+
a = ((p & 0x8) * 0xff) << 21;
r = ((p & 0x4) * 0xff) >> 3;
g = ((p & 0x2) * 0xff) << 7;
const pixman_indexed_t * indexed = pict->indexed;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(bits, i + x);
-
+ uint32_t p = Fetch4(pict, bits, i + x);
+
*buffer++ = indexed->rgba[p];
}
}
const uint32_t *bits = pict->bits + y*pict->rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = READ(bits + ((i + x) >> 5));
+ uint32_t p = READ(pict, bits + ((i + x) >> 5));
uint32_t a;
#if BITMAP_BIT_ORDER == MSBFirst
a = p >> (0x1f - ((i+x) & 0x1f));
const pixman_indexed_t * indexed = pict->indexed;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = READ(bits + ((i+x) >> 5));
+ uint32_t p = READ(pict, bits + ((i+x) >> 5));
uint32_t a;
#if BITMAP_BIT_ORDER == MSBFirst
a = p >> (0x1f - ((i+x) & 0x1f));
/* B = 1.164(Y - 16) + 2.018(U - 128) */
b = 0x012b27 * y + 0x0206a2 * u;
- WRITE(buffer++, 0xff000000 |
+ WRITE(pict, buffer++, 0xff000000 |
(r >= 0 ? r < 0x1000000 ? r & 0xff0000 : 0xff0000 : 0) |
(g >= 0 ? g < 0x1000000 ? (g >> 8) & 0x00ff00 : 0x00ff00 : 0) |
(b >= 0 ? b < 0x1000000 ? (b >> 16) & 0x0000ff : 0x0000ff : 0));
/* B = 1.164(Y - 16) + 2.018(U - 128) */
b = 0x012b27 * y + 0x0206a2 * u;
- WRITE(buffer++, 0xff000000 |
+ WRITE(pict, buffer++, 0xff000000 |
(r >= 0 ? r < 0x1000000 ? r & 0xff0000 : 0xff0000 : 0) |
(g >= 0 ? g < 0x1000000 ? (g >> 8) & 0x00ff00 : 0x00ff00 : 0) |
(b >= 0 ? b < 0x1000000 ? (b >> 16) & 0x0000ff : 0x0000ff : 0));
case PIXMAN_x8r8g8b8: return fbFetch_x8r8g8b8;
case PIXMAN_a8b8g8r8: return fbFetch_a8b8g8r8;
case PIXMAN_x8b8g8r8: return fbFetch_x8b8g8r8;
-
+
/* 24bpp formats */
case PIXMAN_r8g8b8: return fbFetch_r8g8b8;
case PIXMAN_b8g8r8: return fbFetch_b8g8r8;
-
+
/* 16bpp formats */
case PIXMAN_r5g6b5: return fbFetch_r5g6b5;
case PIXMAN_b5g6r5: return fbFetch_b5g6r5;
-
+
case PIXMAN_a1r5g5b5: return fbFetch_a1r5g5b5;
case PIXMAN_x1r5g5b5: return fbFetch_x1r5g5b5;
case PIXMAN_a1b5g5r5: return fbFetch_a1b5g5r5;
case PIXMAN_x4r4g4b4: return fbFetch_x4r4g4b4;
case PIXMAN_a4b4g4r4: return fbFetch_a4b4g4r4;
case PIXMAN_x4b4g4r4: return fbFetch_x4b4g4r4;
-
+
/* 8bpp formats */
case PIXMAN_a8: return fbFetch_a8;
case PIXMAN_r3g3b2: return fbFetch_r3g3b2;
case PIXMAN_c8: return fbFetch_c8;
case PIXMAN_g8: return fbFetch_c8;
case PIXMAN_x4a4: return fbFetch_x4a4;
-
+
/* 4bpp formats */
case PIXMAN_a4: return fbFetch_a4;
case PIXMAN_r1g2b1: return fbFetch_r1g2b1;
case PIXMAN_a1b1g1r1: return fbFetch_a1b1g1r1;
case PIXMAN_c4: return fbFetch_c4;
case PIXMAN_g4: return fbFetch_c4;
-
+
/* 1bpp formats */
case PIXMAN_a1: return fbFetch_a1;
case PIXMAN_g1: return fbFetch_g1;
case PIXMAN_yuy2: return fbFetch_yuy2;
case PIXMAN_yv12: return fbFetch_yv12;
}
-
+
return NULL;
}
fbFetchPixel_a8r8g8b8 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- return READ((uint32_t *)bits + offset);
+ return READ(pict, (uint32_t *)bits + offset);
}
static FASTCALL uint32_t
fbFetchPixel_x8r8g8b8 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- return READ((uint32_t *)bits + offset) | 0xff000000;
+ return READ(pict, (uint32_t *)bits + offset) | 0xff000000;
}
static FASTCALL uint32_t
fbFetchPixel_a8b8g8r8 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint32_t *)bits + offset);
-
+ uint32_t pixel = READ(pict, (uint32_t *)bits + offset);
+
return ((pixel & 0xff000000) |
((pixel >> 16) & 0xff) |
(pixel & 0x0000ff00) |
fbFetchPixel_x8b8g8r8 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint32_t *)bits + offset);
-
+ uint32_t pixel = READ(pict, (uint32_t *)bits + offset);
+
return ((0xff000000) |
((pixel >> 16) & 0xff) |
(pixel & 0x0000ff00) |
uint8_t *pixel = ((uint8_t *) bits) + (offset*3);
#if IMAGE_BYTE_ORDER == MSBFirst
return (0xff000000 |
- (READ(pixel + 0) << 16) |
- (READ(pixel + 1) << 8) |
- (READ(pixel + 2)));
+ (READ(pict, pixel + 0) << 16) |
+ (READ(pict, pixel + 1) << 8) |
+ (READ(pict, pixel + 2)));
#else
return (0xff000000 |
- (READ(pixel + 2) << 16) |
- (READ(pixel + 1) << 8) |
- (READ(pixel + 0)));
+ (READ(pict, pixel + 2) << 16) |
+ (READ(pict, pixel + 1) << 8) |
+ (READ(pict, pixel + 0)));
#endif
}
uint8_t *pixel = ((uint8_t *) bits) + (offset*3);
#if IMAGE_BYTE_ORDER == MSBFirst
return (0xff000000 |
- (READ(pixel + 2) << 16) |
- (READ(pixel + 1) << 8) |
- (READ(pixel + 0)));
+ (READ(pict, pixel + 2) << 16) |
+ (READ(pict, pixel + 1) << 8) |
+ (READ(pict, pixel + 0)));
#else
return (0xff000000 |
- (READ(pixel + 0) << 16) |
- (READ(pixel + 1) << 8) |
- (READ(pixel + 2)));
+ (READ(pict, pixel + 0) << 16) |
+ (READ(pict, pixel + 1) << 8) |
+ (READ(pict, pixel + 2)));
#endif
}
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
r = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) << 8;
g = ((pixel & 0x07e0) | ((pixel & 0x0600) >> 6)) << 5;
b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
b = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) >> 8;
g = ((pixel & 0x07e0) | ((pixel & 0x0600) >> 6)) << 5;
r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
a = (uint32_t) ((uint8_t) (0 - ((pixel & 0x8000) >> 15))) << 24;
r = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) << 9;
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
r = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) << 9;
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
a = (uint32_t) ((uint8_t) (0 - ((pixel & 0x8000) >> 15))) << 24;
b = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) >> 7;
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
b = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) >> 7;
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
r = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
r = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
b = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
b = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) >> 4;
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint16_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint16_t *) bits + offset);
+
b = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) >> 4;
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
r = ((pixel & 0x000f) | ((pixel & 0x000f) << 4)) << 16;
fbFetchPixel_a8 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint8_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint8_t *) bits + offset);
+
return pixel << 24;
}
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint8_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint8_t *) bits + offset);
+
r = ((pixel & 0xe0) | ((pixel & 0xe0) >> 3) | ((pixel & 0xc0) >> 6)) << 16;
g = ((pixel & 0x1c) | ((pixel & 0x18) >> 3) | ((pixel & 0x1c) << 3)) << 8;
b = (((pixel & 0x03) ) |
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint8_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint8_t *) bits + offset);
+
b = (((pixel & 0xc0) ) |
((pixel & 0xc0) >> 2) |
((pixel & 0xc0) >> 4) |
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint8_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint8_t *) bits + offset);
+
a = ((pixel & 0xc0) * 0x55) << 18;
r = ((pixel & 0x30) * 0x55) << 12;
g = ((pixel & 0x0c) * 0x55) << 6;
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint8_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint8_t *) bits + offset);
+
a = ((pixel & 0xc0) * 0x55) << 18;
b = ((pixel & 0x30) * 0x55) >> 6;
g = ((pixel & 0x0c) * 0x55) << 6;
fbFetchPixel_c8 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint8_t *) bits + offset);
+ uint32_t pixel = READ(pict, (uint8_t *) bits + offset);
const pixman_indexed_t * indexed = pict->indexed;
return indexed->rgba[pixel];
}
fbFetchPixel_x4a4 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ((uint8_t *) bits + offset);
-
+ uint32_t pixel = READ(pict, (uint8_t *) bits + offset);
+
return ((pixel & 0xf) | ((pixel & 0xf) << 4)) << 24;
}
fbFetchPixel_a4 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(bits, offset);
-
+ uint32_t pixel = Fetch4(pict, bits, offset);
+
pixel |= pixel << 4;
return pixel << 24;
}
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(bits, offset);
-
+ uint32_t pixel = Fetch4(pict, bits, offset);
+
r = ((pixel & 0x8) * 0xff) << 13;
g = ((pixel & 0x6) * 0x55) << 7;
b = ((pixel & 0x1) * 0xff);
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(bits, offset);
-
+ uint32_t pixel = Fetch4(pict, bits, offset);
+
b = ((pixel & 0x8) * 0xff) >> 3;
g = ((pixel & 0x6) * 0x55) << 7;
r = ((pixel & 0x1) * 0xff) << 16;
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(bits, offset);
-
+ uint32_t pixel = Fetch4(pict, bits, offset);
+
a = ((pixel & 0x8) * 0xff) << 21;
r = ((pixel & 0x4) * 0xff) << 14;
g = ((pixel & 0x2) * 0xff) << 7;
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(bits, offset);
-
+ uint32_t pixel = Fetch4(pict, bits, offset);
+
a = ((pixel & 0x8) * 0xff) << 21;
r = ((pixel & 0x4) * 0xff) >> 3;
g = ((pixel & 0x2) * 0xff) << 7;
fbFetchPixel_c4 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(bits, offset);
+ uint32_t pixel = Fetch4(pict, bits, offset);
const pixman_indexed_t * indexed = pict->indexed;
-
+
return indexed->rgba[pixel];
}
fbFetchPixel_a1 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ(bits + (offset >> 5));
+ uint32_t pixel = READ(pict, bits + (offset >> 5));
uint32_t a;
#if BITMAP_BIT_ORDER == MSBFirst
a = pixel >> (0x1f - (offset & 0x1f));
fbFetchPixel_g1 (bits_image_t *pict, int offset, int line)
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = READ(bits + (offset >> 5));
+ uint32_t pixel = READ(pict, bits + (offset >> 5));
const pixman_indexed_t * indexed = pict->indexed;
uint32_t a;
#if BITMAP_BIT_ORDER == MSBFirst
case PIXMAN_x8r8g8b8: return fbFetchPixel_x8r8g8b8;
case PIXMAN_a8b8g8r8: return fbFetchPixel_a8b8g8r8;
case PIXMAN_x8b8g8r8: return fbFetchPixel_x8b8g8r8;
-
+
/* 24bpp formats */
case PIXMAN_r8g8b8: return fbFetchPixel_r8g8b8;
case PIXMAN_b8g8r8: return fbFetchPixel_b8g8r8;
-
+
/* 16bpp formats */
case PIXMAN_r5g6b5: return fbFetchPixel_r5g6b5;
case PIXMAN_b5g6r5: return fbFetchPixel_b5g6r5;
-
+
case PIXMAN_a1r5g5b5: return fbFetchPixel_a1r5g5b5;
case PIXMAN_x1r5g5b5: return fbFetchPixel_x1r5g5b5;
case PIXMAN_a1b5g5r5: return fbFetchPixel_a1b5g5r5;
case PIXMAN_x4r4g4b4: return fbFetchPixel_x4r4g4b4;
case PIXMAN_a4b4g4r4: return fbFetchPixel_a4b4g4r4;
case PIXMAN_x4b4g4r4: return fbFetchPixel_x4b4g4r4;
-
+
/* 8bpp formats */
case PIXMAN_a8: return fbFetchPixel_a8;
case PIXMAN_r3g3b2: return fbFetchPixel_r3g3b2;
case PIXMAN_c8: return fbFetchPixel_c8;
case PIXMAN_g8: return fbFetchPixel_c8;
case PIXMAN_x4a4: return fbFetchPixel_x4a4;
-
+
/* 4bpp formats */
case PIXMAN_a4: return fbFetchPixel_a4;
case PIXMAN_r1g2b1: return fbFetchPixel_r1g2b1;
case PIXMAN_a1b1g1r1: return fbFetchPixel_a1b1g1r1;
case PIXMAN_c4: return fbFetchPixel_c4;
case PIXMAN_g4: return fbFetchPixel_c4;
-
+
/* 1bpp formats */
case PIXMAN_a1: return fbFetchPixel_a1;
case PIXMAN_g1: return fbFetchPixel_g1;
case PIXMAN_yuy2: return fbFetchPixel_yuy2;
case PIXMAN_yv12: return fbFetchPixel_yv12;
}
-
+
return NULL;
}
-#undef image
-
/*
* All the store functions
fbStore_a8r8g8b8 (pixman_image_t *image,
uint32_t *bits, const uint32_t *values, int x, int width, const pixman_indexed_t * indexed)
{
- MEMCPY_WRAPPED(((uint32_t *)bits) + x, values, width*sizeof(uint32_t));
+ MEMCPY_WRAPPED(image, ((uint32_t *)bits) + x, values, width*sizeof(uint32_t));
}
static FASTCALL void
int i;
uint32_t *pixel = (uint32_t *)bits + x;
for (i = 0; i < width; ++i)
- WRITE(pixel++, values[i] & 0xffffff);
+ WRITE(image, pixel++, values[i] & 0xffffff);
}
static FASTCALL void
int i;
uint32_t *pixel = (uint32_t *)bits + x;
for (i = 0; i < width; ++i)
- WRITE(pixel++, (values[i] & 0xff00ff00) | ((values[i] >> 16) & 0xff) | ((values[i] & 0xff) << 16));
+ WRITE(image, pixel++, (values[i] & 0xff00ff00) | ((values[i] >> 16) & 0xff) | ((values[i] & 0xff) << 16));
}
static FASTCALL void
int i;
uint32_t *pixel = (uint32_t *)bits + x;
for (i = 0; i < width; ++i)
- WRITE(pixel++, (values[i] & 0x0000ff00) | ((values[i] >> 16) & 0xff) | ((values[i] & 0xff) << 16));
+ WRITE(image, pixel++, (values[i] & 0x0000ff00) | ((values[i] >> 16) & 0xff) | ((values[i] & 0xff) << 16));
}
static FASTCALL void
int i;
uint8_t *pixel = ((uint8_t *) bits) + 3*x;
for (i = 0; i < width; ++i) {
- Store24(pixel, values[i]);
+ Store24(image, pixel, values[i]);
pixel += 3;
}
}
for (i = 0; i < width; ++i) {
uint32_t val = values[i];
#if IMAGE_BYTE_ORDER == MSBFirst
- WRITE(pixel++, Blue(val));
- WRITE(pixel++, Green(val));
- WRITE(pixel++, Red(val));
+ WRITE(image, pixel++, Blue(val));
+ WRITE(image, pixel++, Green(val));
+ WRITE(image, pixel++, Red(val));
#else
- WRITE(pixel++, Red(val));
- WRITE(pixel++, Green(val));
- WRITE(pixel++, Blue(val));
+ WRITE(image, pixel++, Red(val));
+ WRITE(image, pixel++, Green(val));
+ WRITE(image, pixel++, Blue(val));
#endif
}
}
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
uint32_t s = values[i];
- WRITE(pixel++, ((s >> 3) & 0x001f) |
+ WRITE(image, pixel++, ((s >> 3) & 0x001f) |
((s >> 5) & 0x07e0) |
((s >> 8) & 0xf800));
}
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
Split(values[i]);
- WRITE(pixel++, ((b << 8) & 0xf800) |
+ WRITE(image, pixel++, ((b << 8) & 0xf800) |
((g << 3) & 0x07e0) |
((r >> 3) ));
}
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
Splita(values[i]);
- WRITE(pixel++, ((a << 8) & 0x8000) |
+ WRITE(image, pixel++, ((a << 8) & 0x8000) |
((r << 7) & 0x7c00) |
((g << 2) & 0x03e0) |
((b >> 3) ));
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
Split(values[i]);
- WRITE(pixel++, ((r << 7) & 0x7c00) |
+ WRITE(image, pixel++, ((r << 7) & 0x7c00) |
((g << 2) & 0x03e0) |
((b >> 3) ));
}
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
Splita(values[i]);
- WRITE(pixel++, ((a << 8) & 0x8000) |
+ WRITE(image, pixel++, ((a << 8) & 0x8000) |
((b << 7) & 0x7c00) |
((g << 2) & 0x03e0) |
((r >> 3) ));
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
Split(values[i]);
- WRITE(pixel++, ((b << 7) & 0x7c00) |
+ WRITE(image, pixel++, ((b << 7) & 0x7c00) |
((g << 2) & 0x03e0) |
((r >> 3) ));
}
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
Splita(values[i]);
- WRITE(pixel++, ((a << 8) & 0xf000) |
+ WRITE(image, pixel++, ((a << 8) & 0xf000) |
((r << 4) & 0x0f00) |
((g ) & 0x00f0) |
((b >> 4) ));
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
Split(values[i]);
- WRITE(pixel++, ((r << 4) & 0x0f00) |
+ WRITE(image, pixel++, ((r << 4) & 0x0f00) |
((g ) & 0x00f0) |
((b >> 4) ));
}
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
Splita(values[i]);
- WRITE(pixel++, ((a << 8) & 0xf000) |
+ WRITE(image, pixel++, ((a << 8) & 0xf000) |
((b << 4) & 0x0f00) |
((g ) & 0x00f0) |
((r >> 4) ));
uint16_t *pixel = ((uint16_t *) bits) + x;
for (i = 0; i < width; ++i) {
Split(values[i]);
- WRITE(pixel++, ((b << 4) & 0x0f00) |
+ WRITE(image, pixel++, ((b << 4) & 0x0f00) |
((g ) & 0x00f0) |
((r >> 4) ));
}
int i;
uint8_t *pixel = ((uint8_t *) bits) + x;
for (i = 0; i < width; ++i) {
- WRITE(pixel++, values[i] >> 24);
+ WRITE(image, pixel++, values[i] >> 24);
}
}
uint8_t *pixel = ((uint8_t *) bits) + x;
for (i = 0; i < width; ++i) {
Split(values[i]);
- WRITE(pixel++,
+ WRITE(image, pixel++,
((r ) & 0xe0) |
((g >> 3) & 0x1c) |
((b >> 6) ));
uint8_t *pixel = ((uint8_t *) bits) + x;
for (i = 0; i < width; ++i) {
Split(values[i]);
- WRITE(pixel++,
+ WRITE(image, pixel++,
((b ) & 0xc0) |
((g >> 2) & 0x1c) |
((r >> 5) ));
uint8_t *pixel = ((uint8_t *) bits) + x;
for (i = 0; i < width; ++i) {
Splita(values[i]);
- WRITE(pixel++, ((a ) & 0xc0) |
+ WRITE(image, pixel++, ((a ) & 0xc0) |
((r >> 2) & 0x30) |
((g >> 4) & 0x0c) |
((b >> 6) ));
int i;
uint8_t *pixel = ((uint8_t *) bits) + x;
for (i = 0; i < width; ++i) {
- WRITE(pixel++, miIndexToEnt24(indexed,values[i]));
+ WRITE(image, pixel++, miIndexToEnt24(indexed,values[i]));
}
}
int i;
uint8_t *pixel = ((uint8_t *) bits) + x;
for (i = 0; i < width; ++i) {
- WRITE(pixel++, values[i] >> 28);
+ WRITE(image, pixel++, values[i] >> 28);
}
}
-#define Store8(l,o,v) (WRITE((uint8_t *)(l) + ((o) >> 3), (v)))
+#define Store8(img,l,o,v) (WRITE(img, (uint8_t *)(l) + ((o) >> 3), (v)))
#if IMAGE_BYTE_ORDER == MSBFirst
-#define Store4(l,o,v) Store8(l,o,((o) & 4 ? \
- (Fetch8(l,o) & 0xf0) | (v) : \
- (Fetch8(l,o) & 0x0f) | ((v) << 4)))
+#define Store4(img,l,o,v) Store8(img,l,o,((o) & 4 ? \
+ (Fetch8(img,l,o) & 0xf0) | (v) : \
+ (Fetch8(img,l,o) & 0x0f) | ((v) << 4)))
#else
-#define Store4(l,o,v) Store8(l,o,((o) & 4 ? \
- (Fetch8(l,o) & 0x0f) | ((v) << 4) : \
- (Fetch8(l,o) & 0xf0) | (v)))
+#define Store4(img,l,o,v) Store8(img,l,o,((o) & 4 ? \
+ (Fetch8(img,l,o) & 0x0f) | ((v) << 4) : \
+ (Fetch8(img,l,o) & 0xf0) | (v)))
#endif
static FASTCALL void
{
int i;
for (i = 0; i < width; ++i) {
- Store4(bits, i + x, values[i]>>28);
+ Store4(image, bits, i + x, values[i]>>28);
}
}
int i;
for (i = 0; i < width; ++i) {
uint32_t pixel;
-
+
Split(values[i]);
pixel = (((r >> 4) & 0x8) |
((g >> 5) & 0x6) |
((b >> 7) ));
- Store4(bits, i + x, pixel);
+ Store4(image, bits, i + x, pixel);
}
}
int i;
for (i = 0; i < width; ++i) {
uint32_t pixel;
-
+
Split(values[i]);
pixel = (((b >> 4) & 0x8) |
((g >> 5) & 0x6) |
((r >> 7) ));
- Store4(bits, i + x, pixel);
+ Store4(image, bits, i + x, pixel);
}
}
((r >> 5) & 0x4) |
((g >> 6) & 0x2) |
((b >> 7) ));
- Store4(bits, i + x, pixel);
+ Store4(image, bits, i + x, pixel);
}
}
((b >> 5) & 0x4) |
((g >> 6) & 0x2) |
((r >> 7) ));
- Store4(bits, i + x, pixel);
+ Store4(image, bits, i + x, pixel);
}
}
int i;
for (i = 0; i < width; ++i) {
uint32_t pixel;
-
+
pixel = miIndexToEnt24(indexed, values[i]);
- Store4(bits, i + x, pixel);
+ Store4(image, bits, i + x, pixel);
}
}
for (i = 0; i < width; ++i) {
uint32_t *pixel = ((uint32_t *) bits) + ((i+x) >> 5);
uint32_t mask = FbStipMask((i+x) & 0x1f, 1);
-
+
uint32_t v = values[i] & 0x80000000 ? mask : 0;
- WRITE(pixel, (READ(pixel) & ~mask) | v);
+ WRITE(image, pixel, (READ(image, pixel) & ~mask) | v);
}
}
for (i = 0; i < width; ++i) {
uint32_t *pixel = ((uint32_t *) bits) + ((i+x) >> 5);
uint32_t mask = FbStipMask((i+x) & 0x1f, 1);
-
+
uint32_t v = miIndexToEntY24(indexed,values[i]) ? mask : 0;
- WRITE(pixel, (READ(pixel) & ~mask) | v);
+ WRITE(image, pixel, (READ(image, pixel) & ~mask) | v);
}
}
case PIXMAN_x8r8g8b8: return fbStore_x8r8g8b8;
case PIXMAN_a8b8g8r8: return fbStore_a8b8g8r8;
case PIXMAN_x8b8g8r8: return fbStore_x8b8g8r8;
-
+
/* 24bpp formats */
case PIXMAN_r8g8b8: return fbStore_r8g8b8;
case PIXMAN_b8g8r8: return fbStore_b8g8r8;
-
+
/* 16bpp formats */
case PIXMAN_r5g6b5: return fbStore_r5g6b5;
case PIXMAN_b5g6r5: return fbStore_b5g6r5;
-
+
case PIXMAN_a1r5g5b5: return fbStore_a1r5g5b5;
case PIXMAN_x1r5g5b5: return fbStore_x1r5g5b5;
case PIXMAN_a1b5g5r5: return fbStore_a1b5g5r5;
case PIXMAN_x4r4g4b4: return fbStore_x4r4g4b4;
case PIXMAN_a4b4g4r4: return fbStore_a4b4g4r4;
case PIXMAN_x4b4g4r4: return fbStore_x4b4g4r4;
-
+
/* 8bpp formats */
case PIXMAN_a8: return fbStore_a8;
case PIXMAN_r3g3b2: return fbStore_r3g3b2;
case PIXMAN_c8: return fbStore_c8;
case PIXMAN_g8: return fbStore_c8;
case PIXMAN_x4a4: return fbStore_x4a4;
-
+
/* 4bpp formats */
case PIXMAN_a4: return fbStore_a4;
case PIXMAN_r1g2b1: return fbStore_r1g2b1;
case PIXMAN_a1b1g1r1: return fbStore_a1b1g1r1;
case PIXMAN_c4: return fbStore_c4;
case PIXMAN_g4: return fbStore_c4;
-
+
/* 1bpp formats */
case PIXMAN_a1: return fbStore_a1;
case PIXMAN_g1: return fbStore_g1;
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint32_t ia = Alpha(~s);
-
+
FbByteMulAdd(d, ia, s);
*(dest + i) = d;
}
uint32_t d = *(dest + i);
uint32_t dest_a = Alpha(d);
uint32_t src_ia = Alpha(~s);
-
+
FbByteAddMul(s, dest_a, d, src_ia);
*(dest + i) = s;
}
uint32_t d = *(dest + i);
uint32_t src_a = Alpha(s);
uint32_t dest_ia = Alpha(~d);
-
+
FbByteAddMul(s, dest_ia, d, src_a);
*(dest + i) = s;
}
uint32_t d = *(dest + i);
uint32_t src_ia = Alpha(~s);
uint32_t dest_ia = Alpha(~d);
-
+
FbByteAddMul(s, dest_ia, d, src_ia);
*(dest + i) = s;
}
uint32_t s = *(src + i);
uint32_t d = *(dest + i);
uint16_t sa, da;
-
+
sa = s >> 24;
da = ~d >> 24;
if (sa > da)
/*
* All of the disjoint composing functions
-
+
The four entries in the first column indicate what source contributions
come from each of the four areas of the picture -- areas covered by neither
A nor B, areas covered only by A, areas covered only by B and finally
areas covered by both A and B.
-
+
Disjoint Conjoint
Fa Fb Fa Fb
(0,0,0,0) 0 0 0 0
(0,0,B,A) max(1-(1-b)/a,0) min(1,(1-a)/b) min(1,b/a) max(1-a/b,0)
(0,A,0,B) min(1,(1-b)/a) max(1-(1-a)/b,0) max(1-b/a,0) min(1,a/b)
(0,A,B,0) min(1,(1-b)/a) min(1,(1-a)/b) max(1-b/a,0) max(1-a/b,0)
-
+
*/
#define CombineAOut 1
fbCombineDisjointOutPart (uint8_t a, uint8_t b)
{
/* min (1, (1-b) / a) */
-
+
b = ~b; /* 1 - b */
if (b >= a) /* 1 - b >= a -> (1-b)/a >= 1 */
return 0xff; /* 1 */
/* max (1-(1-b)/a,0) */
/* = - min ((1-b)/a - 1, 0) */
/* = 1 - min (1, (1-b)/a) */
-
+
b = ~b; /* 1 - b */
if (b >= a) /* 1 - b >= a -> (1-b)/a >= 1 */
return 0; /* 1 - 1 */
uint16_t Fa, Fb, t, u, v;
uint8_t sa = s >> 24;
uint8_t da = d >> 24;
-
+
switch (combine & CombineA) {
default:
Fa = 0;
Fa = 0xff;
break;
}
-
+
switch (combine & CombineB) {
default:
Fb = 0;
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint16_t a = s >> 24;
-
+
if (a != 0x00)
{
if (a != 0xff)
{
/* max (1-b/a,0) */
/* = 1-min(b/a,1) */
-
+
/* min (1, (1-b) / a) */
-
+
if (b >= a) /* b >= a -> b/a >= 1 */
return 0x00; /* 0 */
return ~FbIntDiv(b,a); /* 1 - b/a */
fbCombineConjointInPart (uint8_t a, uint8_t b)
{
/* min (1,b/a) */
-
+
if (b >= a) /* b >= a -> b/a >= 1 */
return 0xff; /* 1 */
return FbIntDiv(b,a); /* b/a */
uint16_t Fa, Fb, t, u, v;
uint8_t sa = s >> 24;
uint8_t da = d >> 24;
-
+
switch (combine & CombineA) {
default:
Fa = 0;
Fa = 0xff;
break;
}
-
+
switch (combine & CombineB) {
default:
Fb = 0;
fbCombineMaskC (uint32_t *src, uint32_t *mask)
{
uint32_t a = *mask;
-
+
uint32_t x;
uint16_t xa;
-
+
if (!a)
{
*(src) = 0;
return;
}
-
+
x = *(src);
if (a == 0xffffffff)
{
*(mask) = x;
return;
}
-
+
xa = x >> 24;
FbByteMulC(x, a);
*(src) = x;
{
uint32_t a = *mask;
uint32_t x;
-
+
if (!a)
{
*(src) = 0;
return;
}
-
+
if (a == 0xffffffff)
return;
-
+
x = *(src);
FbByteMulC(x, a);
*(src) =x;
{
uint32_t a = *(mask);
uint32_t x;
-
+
if (!a)
return;
-
+
x = *(src) >> 24;
if (x == 0xff)
return;
*(mask) = x;
return;
}
-
+
FbByteMul(a, x);
*(mask) = a;
}
fbCombineSrcC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
-
+
fbCombineMaskValueC (&s, &m);
-
+
*(dest) = s;
}
}
fbCombineOverC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t a;
-
+
fbCombineMaskC (&s, &m);
-
+
a = ~m;
if (a != 0xffffffff)
{
fbCombineOverReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint32_t a = ~d >> 24;
-
+
if (a)
{
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
-
+
fbCombineMaskValueC (&s, &m);
-
+
if (a != 0xff)
{
FbByteMulAdd(s, a, d);
fbCombineInC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint16_t a = d >> 24;
if (a)
{
uint32_t m = *(mask + i);
-
+
s = *(src + i);
fbCombineMaskValueC (&s, &m);
if (a != 0xff)
fbCombineInReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t a;
-
+
fbCombineMaskAlphaC (&s, &m);
-
+
a = m;
if (a != 0xffffffff)
{
d = *(dest + i);
FbByteMulC(d, a);
}
- *(dest + i) = d;
+ *(dest + i) = d;
}
}
}
fbCombineOutC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint16_t a = ~d >> 24;
if (a)
{
uint32_t m = *(mask + i);
-
+
s = *(src + i);
fbCombineMaskValueC (&s, &m);
-
+
if (a != 0xff)
{
FbByteMul(s, a);
fbCombineOutReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t a;
-
+
fbCombineMaskAlphaC (&s, &m);
-
+
a = ~m;
if (a != 0xffffffff)
{
fbCombineAtopC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t ad;
uint16_t as = d >> 24;
-
+
fbCombineMaskC (&s, &m);
-
+
ad = ~m;
-
+
FbByteAddMulC(d, ad, s, as);
*(dest + i) = d;
}
fbCombineAtopReverseC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
-
+
uint32_t d = *(dest + i);
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t ad;
uint16_t as = ~d >> 24;
-
+
fbCombineMaskC (&s, &m);
-
+
ad = m;
-
+
FbByteAddMulC(d, ad, s, as);
*(dest + i) = d;
}
fbCombineXorC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t d = *(dest + i);
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t ad;
uint16_t as = ~d >> 24;
-
+
fbCombineMaskC (&s, &m);
-
+
ad = ~m;
-
+
FbByteAddMulC(d, ad, s, as);
*(dest + i) = d;
}
fbCombineAddC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t s = *(src + i);
uint32_t m = *(mask + i);
uint32_t d = *(dest + i);
-
+
fbCombineMaskValueC (&s, &m);
-
+
FbByteAdd(d, s);
*(dest + i) = d;
}
fbCombineSaturateC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t s, d;
uint16_t sa, sr, sg, sb, da;
uint16_t t, u, v;
uint32_t m,n,o,p;
-
+
d = *(dest + i);
s = *(src + i);
m = *(mask + i);
-
+
fbCombineMaskC (&s, &m);
-
+
sa = (m >> 24);
sr = (m >> 16) & 0xff;
sg = (m >> 8) & 0xff;
sb = (m ) & 0xff;
da = ~d >> 24;
-
+
if (sb <= da)
m = FbAdd(s,d,0,t);
else
m = FbGen (s, d, 0, (da << 8) / sb, 0xff, t, u, v);
-
+
if (sg <= da)
n = FbAdd(s,d,8,t);
else
n = FbGen (s, d, 8, (da << 8) / sg, 0xff, t, u, v);
-
+
if (sr <= da)
o = FbAdd(s,d,16,t);
else
o = FbGen (s, d, 16, (da << 8) / sr, 0xff, t, u, v);
-
+
if (sa <= da)
p = FbAdd(s,d,24,t);
else
p = FbGen (s, d, 24, (da << 8) / sa, 0xff, t, u, v);
-
+
*(dest + i) = m|n|o|p;
}
}
fbCombineDisjointGeneralC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width, uint8_t combine)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t s, d;
uint32_t m,n,o,p;
uint16_t t, u, v;
uint32_t sa;
uint8_t da;
-
+
s = *(src + i);
m = *(mask + i);
d = *(dest + i);
da = d >> 24;
-
+
fbCombineMaskC (&s, &m);
-
+
sa = m;
-
+
switch (combine & CombineA) {
default:
Fa = 0;
Fa = 0xffffffff;
break;
}
-
+
switch (combine & CombineB) {
default:
Fb = 0;
fbCombineConjointGeneralC (uint32_t *dest, uint32_t *src, uint32_t *mask, int width, uint8_t combine)
{
int i;
-
+
for (i = 0; i < width; ++i) {
uint32_t s, d;
uint32_t m,n,o,p;
uint16_t t, u, v;
uint32_t sa;
uint8_t da;
-
+
s = *(src + i);
m = *(mask + i);
d = *(dest + i);
da = d >> 24;
-
+
fbCombineMaskC (&s, &m);
-
+
sa = m;
-
+
switch (combine & CombineA) {
default:
Fa = 0;
Fa = 0xffffffff;
break;
}
-
+
switch (combine & CombineB) {
default:
Fb = 0;
uint32_t color;
uint32_t *end;
fetchPixelProc fetch = fetchPixelProcForPicture(pict);
-
+
color = fetch(pict, 0, 0);
-
+
end = buffer + width;
while (buffer < end)
*(buffer++) = color;
static void fbFetch(bits_image_t * pict, int x, int y, int width, uint32_t *buffer, uint32_t *mask, uint32_t maskBits)
{
fetchProc fetch = fetchProcForPicture(pict);
-
+
fetch(pict, x, y, width, buffer);
}
int32_t left_x;
int32_t right_x;
int32_t stepper;
-
+
pixman_gradient_stop_t *stops;
int num_stops;
unsigned int spread;
-
+
int need_reset;
} GradientWalker;
walker->right_ag = 0;
walker->right_rb = 0;
walker->spread = spread;
-
+
walker->need_reset = TRUE;
}
pixman_color_t *left_c, *right_c;
int n, count = walker->num_stops;
pixman_gradient_stop_t * stops = walker->stops;
-
+
static const pixman_color_t transparent_black = { 0, 0, 0, 0 };
-
+
switch (walker->spread)
{
case PIXMAN_REPEAT_NORMAL:
left_x = stops[n-1].x;
left_c = &stops[n-1].color;
}
-
+
if (n == count) {
right_x = stops[0].x + 0x10000;
right_c = &stops[0].color;
left_x += (pos - x);
right_x += (pos - x);
break;
-
+
case PIXMAN_REPEAT_PAD:
for (n = 0; n < count; n++)
if (pos < stops[n].x)
break;
-
+
if (n == 0) {
left_x = INT32_MIN;
left_c = &stops[0].color;
left_x = stops[n-1].x;
left_c = &stops[n-1].color;
}
-
+
if (n == count) {
right_x = INT32_MAX;
right_c = &stops[n-1].color;
right_c = &stops[n].color;
}
break;
-
+
case PIXMAN_REPEAT_REFLECT:
x = (int32_t)pos & 0xFFFF;
if ((int32_t)pos & 0x10000)
for (n = 0; n < count; n++)
if (x < stops[n].x)
break;
-
+
if (n == 0) {
left_x = -stops[0].x;
left_c = &stops[0].color;
left_x = stops[n-1].x;
left_c = &stops[n-1].color;
}
-
+
if (n == count) {
right_x = 0x20000 - stops[n-1].x;
right_c = &stops[n-1].color;
right_x = stops[n].x;
right_c = &stops[n].color;
}
-
+
if ((int32_t)pos & 0x10000) {
pixman_color_t *tmp_c;
int32_t tmp_x;
-
+
tmp_x = 0x10000 - right_x;
right_x = 0x10000 - left_x;
left_x = tmp_x;
-
+
tmp_c = right_c;
right_c = left_c;
left_c = tmp_c;
-
+
x = 0x10000 - x;
}
left_x += (pos - x);
right_x += (pos - x);
break;
-
+
default: /* RepeatNone */
for (n = 0; n < count; n++)
if (pos < stops[n].x)
break;
-
+
if (n == 0)
{
left_x = INT32_MIN;
right_c = &stops[n].color;
}
}
-
+
walker->left_x = left_x;
walker->right_x = right_x;
walker->left_ag = ((left_c->alpha >> 8) << 16) | (left_c->green >> 8);
walker->left_rb = ((left_c->red & 0xff00) << 8) | (left_c->blue >> 8);
walker->right_ag = ((right_c->alpha >> 8) << 16) | (right_c->green >> 8);
walker->right_rb = ((right_c->red & 0xff00) << 8) | (right_c->blue >> 8);
-
+
if ( walker->left_x == walker->right_x ||
( walker->left_ag == walker->right_ag &&
walker->left_rb == walker->right_rb ) )
int32_t width = right_x - left_x;
walker->stepper = ((1 << 24) + width/2)/width;
}
-
+
walker->need_reset = FALSE;
}
{
int dist, idist;
uint32_t t1, t2, a, color;
-
+
if (GRADIENT_WALKER_NEED_RESET (walker, x))
_gradient_walker_reset (walker, x);
-
+
dist = ((int)(x - walker->left_x)*walker->stepper) >> 16;
idist = 256 - dist;
-
+
/* combined INTERPOLATE and premultiply */
t1 = walker->left_rb*idist + walker->right_rb*dist;
t1 = (t1 >> 8) & 0xff00ff;
-
+
t2 = walker->left_ag*idist + walker->right_ag*dist;
t2 &= 0xff00ff00;
-
+
color = t2 & 0xff000000;
a = t2 >> 24;
-
+
t1 = t1*a + 0x800080;
t1 = (t1 + ((t1 >> 8) & 0xff00ff)) >> 8;
-
+
t2 = (t2 >> 8)*a + 0x800080;
t2 = (t2 + ((t2 >> 8) & 0xff00ff));
-
+
return (color | (t1 & 0xff00ff) | (t2 & 0xff00));
}
GradientWalker walker;
uint32_t *end = buffer + width;
gradient_t *gradient;
-
+
if (pict->common.type == SOLID)
{
register uint32_t color = ((solid_fill_t *)pict)->color;
-
+
while (buffer < end)
*(buffer++) = color;
-
+
return;
}
-
+
gradient = (gradient_t *)pict;
-
+
_gradient_walker_init (&walker, gradient, pict->common.repeat);
-
+
if (pict->common.type == LINEAR) {
pixman_vector_t v, unit;
pixman_fixed_32_32_t l;
pixman_fixed_48_16_t dx, dy, a, b, off;
linear_gradient_t *linear = (linear_gradient_t *)pict;
-
+
/* reference point is the center of the pixel */
v.vector[0] = pixman_int_to_fixed(x) + pixman_fixed_1/2;
v.vector[1] = pixman_int_to_fixed(y) + pixman_fixed_1/2;
unit.vector[1] = 0;
unit.vector[2] = 0;
}
-
+
dx = linear->p2.x - linear->p1.x;
dy = linear->p2.y - linear->p1.y;
l = dx*dx + dy*dy;
t = ((a*v.vector[0] + b*v.vector[1]) >> 16) + off;
inc = (a * unit.vector[0] + b * unit.vector[1]) >> 16;
}
-
+
if (pict->class == SOURCE_IMAGE_CLASS_VERTICAL)
{
register uint32_t color;
-
+
color = _gradient_walker_pixel( &walker, t );
while (buffer < end)
*(buffer++) = color;
else /* projective transformation */
{
pixman_fixed_48_16_t t;
-
+
if (pict->class == SOURCE_IMAGE_CLASS_VERTICAL)
{
register uint32_t color;
-
+
if (v.vector[2] == 0)
{
t = 0;
else
{
pixman_fixed_48_16_t x, y;
-
+
x = ((pixman_fixed_48_16_t) v.vector[0] << 16) / v.vector[2];
y = ((pixman_fixed_48_16_t) v.vector[1] << 16) / v.vector[2];
t = ((a * x + b * y) >> 16) + off;
}
-
+
color = _gradient_walker_pixel( &walker, t );
while (buffer < end)
*(buffer++) = color;
}
}
} else {
-
+
/*
* In the radial gradient problem we are given two circles (c₁,r₁) and
* (c₂,r₂) that define the gradient itself. Then, for any point p, we
double rx = x + 0.5;
double ry = y + 0.5;
double rz = 1.;
-
+
if (pict->common.transform) {
pixman_vector_t v;
/* reference point is the center of the pixel */
v.vector[2] = pixman_fixed_1;
if (!pixman_transform_point_3d (pict->common.transform, &v))
return;
-
+
cx = pict->common.transform->matrix[0][0]/65536.;
cy = pict->common.transform->matrix[1][0]/65536.;
cz = pict->common.transform->matrix[2][0]/65536.;
rz = v.vector[2]/65536.;
affine = pict->common.transform->matrix[2][0] == 0 && v.vector[2] == pixman_fixed_1;
}
-
+
if (pict->common.type == RADIAL) {
radial_gradient_t *radial = (radial_gradient_t *)pict;
if (affine) {
double c1y = radial->c1.y / 65536.0;
double r1 = radial->c1.radius / 65536.0;
pixman_fixed_48_16_t t;
-
+
pdx = rx - c1x;
pdy = ry - c1y;
-
+
B = -2 * ( pdx * radial->cdx
+ pdy * radial->cdy
+ r1 * radial->dr);
C = (pdx * pdx + pdy * pdy - r1 * r1);
-
+
det = (B * B) - (4 * radial->A * C);
if (det < 0.0)
det = 0.0;
-
+
if (radial->A < 0)
t = (pixman_fixed_48_16_t) ((- B - sqrt(det)) / (2.0 * radial->A) * 65536);
else
t = (pixman_fixed_48_16_t) ((- B + sqrt(det)) / (2.0 * radial->A) * 65536);
-
+
*(buffer) = _gradient_walker_pixel (&walker, t);
}
++buffer;
-
+
rx += cx;
ry += cy;
}
double r1 = radial->c1.radius / 65536.0;
pixman_fixed_48_16_t t;
double x, y;
-
+
if (rz != 0) {
x = rx/rz;
y = ry/rz;
} else {
x = y = 0.;
}
-
+
pdx = x - c1x;
pdy = y - c1y;
-
+
B = -2 * ( pdx * radial->cdx
+ pdy * radial->cdy
+ r1 * radial->dr);
C = (pdx * pdx + pdy * pdy - r1 * r1);
-
+
det = (B * B) - (4 * radial->A * C);
if (det < 0.0)
det = 0.0;
-
+
if (radial->A < 0)
t = (pixman_fixed_48_16_t) ((- B - sqrt(det)) / (2.0 * radial->A) * 65536);
else
t = (pixman_fixed_48_16_t) ((- B + sqrt(det)) / (2.0 * radial->A) * 65536);
-
+
*(buffer) = _gradient_walker_pixel (&walker, t);
}
++buffer;
-
+
rx += cx;
ry += cy;
rz += cz;
if (affine) {
rx -= conical->center.x/65536.;
ry -= conical->center.y/65536.;
-
+
while (buffer < end) {
double angle;
-
+
if (!mask || *mask++ & maskBits)
{
pixman_fixed_48_16_t t;
-
+
angle = atan2(ry, rx) + a;
t = (pixman_fixed_48_16_t) (angle * (65536. / (2*M_PI)));
-
+
*(buffer) = _gradient_walker_pixel (&walker, t);
}
-
+
++buffer;
rx += cx;
ry += cy;
while (buffer < end) {
double x, y;
double angle;
-
+
if (!mask || *mask++ & maskBits)
{
pixman_fixed_48_16_t t;
-
+
if (rz != 0) {
x = rx/rz;
y = ry/rz;
y -= conical->center.y/65536.;
angle = atan2(y, x) + a;
t = (pixman_fixed_48_16_t) (angle * (65536. / (2*M_PI)));
-
+
*(buffer) = _gradient_walker_pixel (&walker, t);
}
-
+
++buffer;
rx += cx;
ry += cy;
int i;
pixman_box16_t box;
pixman_bool_t affine = TRUE;
-
+
fetch = fetchPixelProcForPicture(pict);
-
+
bits = pict->bits;
stride = pict->rowstride;
-
+
/* reference point is the center of the pixel */
v.vector[0] = pixman_int_to_fixed(x) + pixman_fixed_1 / 2;
v.vector[1] = pixman_int_to_fixed(y) + pixman_fixed_1 / 2;
v.vector[2] = pixman_fixed_1;
-
+
/* when using convolution filters one might get here without a transform */
if (pict->common.transform)
{
unit.vector[1] = 0;
unit.vector[2] = 0;
}
-
+
if (pict->common.filter == PIXMAN_FILTER_NEAREST || pict->common.filter == PIXMAN_FILTER_FAST)
{
if (pict->common.repeat == PIXMAN_REPEAT_NORMAL) {
*(buffer + i) = fetch(pict, x, y);
}
}
-
+
v.vector[0] += unit.vector[0];
v.vector[1] += unit.vector[1];
v.vector[2] += unit.vector[2];
*(buffer + i) = 0;
}
}
-
+
v.vector[0] += unit.vector[0];
v.vector[1] += unit.vector[1];
v.vector[2] += unit.vector[2];
v.vector[1] -= v.vector[2] / 2;
unit.vector[0] -= unit.vector[2] / 2;
unit.vector[1] -= unit.vector[2] / 2;
-
+
if (pict->common.repeat == PIXMAN_REPEAT_NORMAL) {
if (pixman_region_n_rects(pict->common.src_clip) == 1) {
for (i = 0; i < width; ++i) {
int x1, x2, y1, y2, distx, idistx, disty, idisty;
uint32_t tl, tr, bl, br, r;
uint32_t ft, fb;
-
+
if (!affine) {
pixman_fixed_48_16_t div;
div = ((pixman_fixed_48_16_t)v.vector[0] << 16)/v.vector[2];
}
x2 = x1 + 1;
y2 = y1 + 1;
-
+
idistx = 256 - distx;
idisty = 256 - disty;
-
+
x1 = MOD (x1, pict->width);
x2 = MOD (x2, pict->width);
y1 = MOD (y1, pict->height);
y2 = MOD (y2, pict->height);
-
+
tl = fetch(pict, x1, y1);
tr = fetch(pict, x2, y1);
bl = fetch(pict, x1, y2);
br = fetch(pict, x2, y2);
-
+
ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
int x1, x2, y1, y2, distx, idistx, disty, idisty;
uint32_t tl, tr, bl, br, r;
uint32_t ft, fb;
-
+
if (!affine) {
pixman_fixed_48_16_t div;
div = ((pixman_fixed_48_16_t)v.vector[0] << 16)/v.vector[2];
}
x2 = x1 + 1;
y2 = y1 + 1;
-
+
idistx = 256 - distx;
idisty = 256 - disty;
-
+
x1 = MOD (x1, pict->width);
x2 = MOD (x2, pict->width);
y1 = MOD (y1, pict->height);
y2 = MOD (y2, pict->height);
-
+
tl = pixman_region_contains_point(pict->common.src_clip, x1, y1, &box)
? fetch(pict, x1, y1) : 0;
tr = pixman_region_contains_point(pict->common.src_clip, x2, y1, &box)
? fetch(pict, x1, y2) : 0;
br = pixman_region_contains_point(pict->common.src_clip, x2, y2, &box)
? fetch(pict, x2, y2) : 0;
-
+
ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
*(buffer + i) = r;
}
}
-
+
v.vector[0] += unit.vector[0];
v.vector[1] += unit.vector[1];
v.vector[2] += unit.vector[2];
uint32_t tl, tr, bl, br, r;
pixman_bool_t x1_out, x2_out, y1_out, y2_out;
uint32_t ft, fb;
-
+
if (!affine) {
pixman_fixed_48_16_t div;
div = ((pixman_fixed_48_16_t)v.vector[0] << 16)/v.vector[2];
}
x2 = x1 + 1;
y2 = y1 + 1;
-
+
idistx = 256 - distx;
idisty = 256 - disty;
-
+
x1_out = (x1 < box.x1) | (x1 >= box.x2);
x2_out = (x2 < box.x1) | (x2 >= box.x2);
y1_out = (y1 < box.y1) | (y1 >= box.y2);
y2_out = (y2 < box.y1) | (y2 >= box.y2);
-
+
tl = x1_out|y1_out ? 0 : fetch(pict, x1, y1);
tr = x2_out|y1_out ? 0 : fetch(pict, x2, y1);
bl = x1_out|y2_out ? 0 : fetch(pict, x1, y2);
br = x2_out|y2_out ? 0 : fetch(pict, x2, y2);
-
+
ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
*(buffer + i) = r;
}
}
-
+
v.vector[0] += unit.vector[0];
v.vector[1] += unit.vector[1];
v.vector[2] += unit.vector[2];
int x1, x2, y1, y2, distx, idistx, disty, idisty;
uint32_t tl, tr, bl, br, r;
uint32_t ft, fb;
-
+
if (!affine) {
pixman_fixed_48_16_t div;
div = ((pixman_fixed_48_16_t)v.vector[0] << 16)/v.vector[2];
}
x2 = x1 + 1;
y2 = y1 + 1;
-
+
idistx = 256 - distx;
idisty = 256 - disty;
-
+
tl = pixman_region_contains_point(pict->common.src_clip, x1, y1, &box)
? fetch(pict, x1, y1) : 0;
tr = pixman_region_contains_point(pict->common.src_clip, x2, y1, &box)
? fetch(pict, x1, y2) : 0;
br = pixman_region_contains_point(pict->common.src_clip, x2, y2, &box)
? fetch(pict, x2, y2) : 0;
-
+
ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
*(buffer + i) = r;
}
}
-
+
v.vector[0] += unit.vector[0];
v.vector[1] += unit.vector[1];
v.vector[2] += unit.vector[2];
int x1, x2, y1, y2, x, y;
int32_t srtot, sgtot, sbtot, satot;
pixman_fixed_t *p = params;
-
+
if (!affine) {
pixman_fixed_48_16_t tmp;
tmp = ((pixman_fixed_48_16_t)v.vector[0] << 16)/v.vector[2] - xoff;
}
x2 = x1 + cwidth;
y2 = y1 + cheight;
-
+
srtot = sgtot = sbtot = satot = 0;
-
+
for (y = y1; y < y2; y++) {
int ty = (pict->common.repeat == PIXMAN_REPEAT_NORMAL) ? MOD (y, pict->height) : y;
for (x = x1; x < x2; x++) {
int tx = (pict->common.repeat == PIXMAN_REPEAT_NORMAL) ? MOD (x, pict->width) : x;
if (pixman_region_contains_point (pict->common.src_clip, tx, ty, &box)) {
uint32_t c = fetch(pict, tx, ty);
-
+
srtot += Red(c) * *p;
sgtot += Green(c) * *p;
sbtot += Blue(c) * *p;
p++;
}
}
-
+
satot >>= 16;
srtot >>= 16;
sgtot >>= 16;
sbtot >>= 16;
-
+
if (satot < 0) satot = 0; else if (satot > 0xff) satot = 0xff;
if (srtot < 0) srtot = 0; else if (srtot > 0xff) srtot = 0xff;
if (sgtot < 0) sgtot = 0; else if (sgtot > 0xff) sgtot = 0xff;
if (sbtot < 0) sbtot = 0; else if (sbtot > 0xff) sbtot = 0xff;
-
+
*(buffer + i) = ((satot << 24) |
(srtot << 16) |
(sgtot << 8) |
v.vector[2] += unit.vector[2];
}
}
-
+
fbFinishAccess (pict->pDrawable);
}
int i;
uint32_t _alpha_buffer[SCANLINE_BUFFER_LENGTH];
uint32_t *alpha_buffer = _alpha_buffer;
-
+
if (!pict->common.alpha_map) {
fbFetchTransformed (pict, x, y, width, buffer, mask, maskBits);
return;
}
if (width > SCANLINE_BUFFER_LENGTH)
alpha_buffer = (uint32_t *) pixman_malloc_ab (width, sizeof(uint32_t));
-
+
fbFetchTransformed(pict, x, y, width, buffer, mask, maskBits);
fbFetchTransformed((bits_image_t *)pict->common.alpha_map, x - pict->common.alpha_origin.x,
y - pict->common.alpha_origin.y, width, alpha_buffer,
| (div_255(Blue(*(buffer + i)) * a));
}
}
-
+
if (alpha_buffer != _alpha_buffer)
free(alpha_buffer);
}
uint32_t stride;
storeProc store = storeProcForPicture(pict);
const pixman_indexed_t * indexed = pict->indexed;
-
+
bits = pict->bits;
stride = pict->rowstride;
bits += y*stride;
storeProc astore;
const pixman_indexed_t * indexed = pict->indexed;
const pixman_indexed_t * aindexed;
-
+
if (!pict->common.alpha_map) {
fbStore(pict, x, y, width, buffer);
return;
}
-
+
store = storeProcForPicture(pict);
astore = storeProcForPicture(pict->common.alpha_map);
aindexed = pict->common.alpha_map->indexed;
-
+
ax = x;
ay = y;
-
+
bits = pict->bits;
stride = pict->rowstride;
-
+
alpha_bits = pict->common.alpha_map->bits;
astride = pict->common.alpha_map->rowstride;
-
+
bits += y*stride;
alpha_bits += (ay - pict->common.alpha_origin.y)*astride;
-
-
+
+
store((pixman_image_t *)pict, bits, buffer, x, width, indexed);
astore((pixman_image_t *)pict->common.alpha_map,
alpha_bits, buffer, ax - pict->common.alpha_origin.x, width, aindexed);
-
+
fbFinishAccess (pict->alpha_map->pDrawable);
fbFinishAccess (pict->pDrawable);
}
uint32_t *bits;
uint32_t stride;
int xoff, yoff;
-
+
if (data->op == PIXMAN_OP_CLEAR)
fetchSrc = NULL;
else if (IS_SOURCE_IMAGE (data->src))
else
{
bits_image_t *bits = (bits_image_t *)data->src;
-
+
if (bits->common.alpha_map)
{
fetchSrc = (scanFetchProc)fbFetchExternalAlpha;
fetchSrc = (scanFetchProc)fbFetchTransformed;
}
}
-
+
if (!data->mask || data->op == PIXMAN_OP_CLEAR)
{
fetchMask = NULL;
else
{
bits_image_t *bits = (bits_image_t *)data->mask;
-
+
if (bits->common.alpha_map)
{
fetchMask = (scanFetchProc)fbFetchExternalAlpha;
fetchMask = (scanFetchProc)fbFetchTransformed;
}
}
-
+
if (data->dest->common.alpha_map)
{
fetchDest = (scanFetchProc)fbFetchExternalAlpha;
store = (scanStoreProc)fbStoreExternalAlpha;
-
+
if (data->op == PIXMAN_OP_CLEAR || data->op == PIXMAN_OP_SRC)
fetchDest = NULL;
}
{
fetchDest = (scanFetchProc)fbFetch;
store = (scanStoreProc)fbStore;
-
+
switch (data->op)
{
case PIXMAN_OP_CLEAR:
break;
}
}
-
+
if (!store)
{
bits = data->dest->bits.bits;
stride = 0;
xoff = yoff = 0;
}
-
+
if (fetchSrc &&
fetchMask &&
data->mask &&
- data->mask->common.type == BITS &&
+ data->mask->common.type == BITS &&
data->mask->common.component_alpha &&
PIXMAN_FORMAT_RGB (data->mask->bits.format))
{
CombineFuncC compose = PIXMAN_COMPOSE_FUNCTIONS.combineC[data->op];
if (!compose)
return;
-
+
for (i = 0; i < data->height; ++i) {
/* fill first half of scanline with source */
if (fetchSrc)
source can be optimized */
fetchMask (data->mask, data->xMask, data->yMask + i,
data->width, mask_buffer, 0, 0);
-
+
if (maskClass == SOURCE_IMAGE_CLASS_HORIZONTAL)
fetchMask = NULL;
}
-
+
if (srcClass == SOURCE_IMAGE_CLASS_HORIZONTAL)
{
fetchSrc (data->src, data->xSrc, data->ySrc + i,
fetchMask (data->mask, data->xMask, data->yMask + i,
data->width, mask_buffer, 0, 0);
}
-
+
if (store)
{
/* fill dest into second half of scanline */
if (fetchDest)
fetchDest (data->dest, data->xDest, data->yDest + i,
data->width, dest_buffer, 0, 0);
-
+
/* blend */
compose (dest_buffer, src_buffer, mask_buffer, data->width);
-
+
/* write back */
store (data->dest, data->xDest, data->yDest + i, data->width,
dest_buffer);
CombineFuncU compose = PIXMAN_COMPOSE_FUNCTIONS.combineU[data->op];
if (!compose)
return;
-
+
if (fetchMask)
mask_buffer = dest_buffer + data->width;
-
+
for (i = 0; i < data->height; ++i) {
/* fill first half of scanline with source */
if (fetchSrc)
source can be optimized */
fetchMask (data->mask, data->xMask, data->yMask + i,
data->width, mask_buffer, 0, 0);
-
+
if (maskClass == SOURCE_IMAGE_CLASS_HORIZONTAL)
fetchMask = NULL;
}
-
+
if (srcClass == SOURCE_IMAGE_CLASS_HORIZONTAL)
{
fetchSrc (data->src, data->xSrc, data->ySrc + i,
data->width, src_buffer, 0, 0);
-
+
if (mask_buffer)
{
fbCombineInU (mask_buffer, src_buffer, data->width);
}
else
src_mask_buffer = src_buffer;
-
+
fetchSrc = NULL;
}
else
fetchSrc (data->src, data->xSrc, data->ySrc + i,
data->width, src_buffer, mask_buffer,
0xff000000);
-
+
if (mask_buffer)
PIXMAN_COMPOSE_FUNCTIONS.combineMaskU (src_buffer,
mask_buffer,
data->width);
-
+
src_mask_buffer = src_buffer;
}
}
{
fetchMask (data->mask, data->xMask, data->yMask + i,
data->width, mask_buffer, 0, 0);
-
+
fbCombineInU (mask_buffer, src_buffer, data->width);
-
+
src_mask_buffer = mask_buffer;
}
-
+
if (store)
{
/* fill dest into second half of scanline */
if (fetchDest)
fetchDest (data->dest, data->xDest, data->yDest + i,
data->width, dest_buffer, 0, 0);
-
+
/* blend */
compose (dest_buffer, src_mask_buffer, data->width);
-
+
/* write back */
store (data->dest, data->xDest, data->yDest + i, data->width,
dest_buffer);
}
}
}
-
+
if (!store)
fbFinishAccess (data->dest->pDrawable);
}
*
* Author: Søren Sandmann (sandmann@redhat.com)
* Minor Improvements: Nicholas Miell (nmiell@gmail.com)
- * MMX code paths for fbcompose.c by Lars Knoll (lars@trolltech.com)
+ * MMX code paths for fbcompose.c by Lars Knoll (lars@trolltech.com)
*
* Based on work by Owen Taylor
*/
#undef READ
#undef WRITE
-#define READ(x) *(x)
-#define WRITE(ptr,v) (*(ptr) = (v));
+#define READ(img,x) *(x)
+#define WRITE(img,ptr,v) (*(ptr) = (v));
#define noVERBOSE
pix_multiply (__m64 a, __m64 b)
{
__m64 res;
-
+
res = _mm_mullo_pi16 (a, b);
res = _mm_adds_pu16 (res, MC(4x0080));
res = _mm_adds_pu16 (res, _mm_srli_pi16 (res, 8));
res = _mm_srli_pi16 (res, 8);
-
+
return res;
}
expand_alpha_rev (__m64 pixel)
{
return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE(0, 0, 0, 0));
-}
+}
static inline __m64
invert_colors (__m64 pixel)
expand_alpha (__m64 pixel)
{
__m64 t1, t2;
-
+
t1 = shift (pixel, -48);
t2 = shift (t1, 16);
t1 = _mm_or_si64 (t1, t2);
{
__m64 srca = expand_alpha (src);
__m64 srcfaaa = _mm_or_si64 (srca, MC(full_alpha));
-
+
return over(pix_multiply(invert_colors(src), srcfaaa), srca, dest);
}
/* Expand 16 bits positioned at @pos (0-3) of a mmx register into
*
* 00RR00GG00BB
- *
+ *
* --- Expanding 565 in the low word ---
- *
+ *
* m = (m << (32 - 3)) | (m << (16 - 5)) | m;
* m = m & (01f0003f001f);
* m = m * (008404100840);
* m = m >> 8;
- *
+ *
* Note the trick here - the top word is shifted by another nibble to
* avoid it bumping into the middle word
*/
{
__m64 p = pixel;
__m64 t1, t2;
-
+
/* move pixel to low 16 bit and zero the rest */
- p = shift (shift (p, (3 - pos) * 16), -48);
-
+ p = shift (shift (p, (3 - pos) * 16), -48);
+
t1 = shift (p, 36 - 11);
t2 = shift (p, 16 - 5);
-
+
p = _mm_or_si64 (t1, p);
p = _mm_or_si64 (t2, p);
p = _mm_and_si64 (p, MC(565_rgb));
-
+
pixel = _mm_mullo_pi16 (p, MC(565_unpack_multiplier));
return _mm_srli_pi16 (pixel, 8);
}
__m64 p = pixel;
__m64 t = target;
__m64 r, g, b;
-
+
r = _mm_and_si64 (p, MC(565_r));
g = _mm_and_si64 (p, MC(565_g));
b = _mm_and_si64 (p, MC(565_b));
-
+
r = shift (r, - (32 - 8) + pos * 16);
g = shift (g, - (16 - 3) + pos * 16);
b = shift (b, - (0 + 3) + pos * 16);
-
+
if (pos == 0)
t = _mm_and_si64 (t, MC(mask_0));
else if (pos == 1)
t = _mm_and_si64 (t, MC(mask_2));
else if (pos == 3)
t = _mm_and_si64 (t, MC(mask_3));
-
+
p = _mm_or_si64 (r, t);
p = _mm_or_si64 (g, p);
-
+
return _mm_or_si64 (b, p);
}
mmxCombineOverU (uint32_t *dest, const uint32_t *src, int width)
{
const uint32_t *end = dest + width;
-
+
while (dest < end) {
uint32_t ssrc = *src;
uint32_t a = ssrc >> 24;
__m64 s = load8888(*src);
__m64 d = load8888(*dest);
__m64 sa = expand_alpha(s);
-
+
*dest = store8888(in_over (s, sa, a, d));
-
+
++src;
++dest;
++mask;
__m64 da = expand_alpha(d);
*dest = store8888(over (d, da, in (s, a)));
-
+
++src;
++dest;
++mask;
__m64 s = load8888(*src);
__m64 d = load8888(*dest);
__m64 da = expand_alpha(d);
- __m64 sa = expand_alpha(s);
+ __m64 sa = expand_alpha(s);
s = pix_multiply(s, a);
a = pix_multiply(a, sa);
a = negate(a);
pixman_composeFunctions.combineC[PIXMAN_OP_ADD] = mmxCombineAddC;
pixman_composeFunctions.combineMaskU = mmxCombineMaskU;
- }
+ }
}
uint16_t w;
int dstStride;
__m64 vsrc, vsrca;
-
+
CHECKPOINT();
-
+
fbComposeGetSolid(pSrc, src, pDst->bits.format);
-
+
if (src >> 24 == 0)
return;
-
+
fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
-
+
vsrc = load8888 (src);
vsrca = expand_alpha (vsrc);
-
+
while (height--)
{
dst = dstLine;
dstLine += dstStride;
w = width;
-
+
CHECKPOINT();
-
+
while (w && (unsigned long)dst & 7)
{
*dst = store8888(over(vsrc, vsrca, load8888(*dst)));
-
+
w--;
dst++;
}
-
+
while (w >= 2)
{
__m64 vdest;
__m64 dest0, dest1;
-
+
vdest = *(__m64 *)dst;
-
+
dest0 = over(vsrc, vsrca, expand8888(vdest, 0));
dest1 = over(vsrc, vsrca, expand8888(vdest, 1));
-
+
*(__m64 *)dst = pack8888(dest0, dest1);
-
+
dst += 2;
w -= 2;
}
-
+
CHECKPOINT();
-
+
while (w)
{
*dst = store8888(over(vsrc, vsrca, load8888(*dst)));
-
+
w--;
dst++;
}
}
-
+
_mm_empty();
}
uint16_t w;
int dstStride;
__m64 vsrc, vsrca;
-
+
CHECKPOINT();
-
+
fbComposeGetSolid(pSrc, src, pDst->bits.format);
-
+
if (src >> 24 == 0)
return;
-
+
fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
-
+
vsrc = load8888 (src);
vsrca = expand_alpha (vsrc);
-
+
while (height--)
{
dst = dstLine;
dstLine += dstStride;
w = width;
-
+
CHECKPOINT();
-
+
while (w && (unsigned long)dst & 7)
{
ullong d = *dst;
__m64 vdest = expand565 ((__m64)d, 0);
vdest = pack565(over(vsrc, vsrca, vdest), vdest, 0);
*dst = (ullong)vdest;
-
+
w--;
dst++;
}
-
+
while (w >= 4)
{
__m64 vdest;
-
+
vdest = *(__m64 *)dst;
-
+
vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 0)), vdest, 0);
vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 1)), vdest, 1);
vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 2)), vdest, 2);
vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 3)), vdest, 3);
-
+
*(__m64 *)dst = vdest;
-
+
dst += 4;
w -= 4;
}
-
+
CHECKPOINT();
-
+
while (w)
{
ullong d = *dst;
__m64 vdest = expand565 ((__m64)d, 0);
vdest = pack565(over(vsrc, vsrca, vdest), vdest, 0);
*dst = (ullong)vdest;
-
+
w--;
dst++;
}
}
-
+
_mm_empty();
}
uint32_t *maskLine;
int dstStride, maskStride;
__m64 vsrc, vsrca;
-
+
CHECKPOINT();
-
+
fbComposeGetSolid(pSrc, src, pDst->bits.format);
-
+
srca = src >> 24;
if (srca == 0)
return;
-
+
fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
fbComposeGetStart (pMask, xMask, yMask, uint32_t, maskStride, maskLine, 1);
-
+
vsrc = load8888(src);
vsrca = expand_alpha(vsrc);
-
+
while (height--)
{
int twidth = width;
uint32_t *p = (uint32_t *)maskLine;
uint32_t *q = (uint32_t *)dstLine;
-
+
while (twidth && (unsigned long)q & 7)
{
uint32_t m = *(uint32_t *)p;
-
+
if (m)
{
__m64 vdest = load8888(*q);
vdest = in_over(vsrc, vsrca, load8888(m), vdest);
*q = store8888(vdest);
}
-
+
twidth--;
p++;
q++;
}
-
+
while (twidth >= 2)
{
uint32_t m0, m1;
m0 = *p;
m1 = *(p + 1);
-
+
if (m0 | m1)
{
__m64 dest0, dest1;
__m64 vdest = *(__m64 *)q;
-
+
dest0 = in_over(vsrc, vsrca, load8888(m0),
expand8888 (vdest, 0));
dest1 = in_over(vsrc, vsrca, load8888(m1),
expand8888 (vdest, 1));
-
+
*(__m64 *)q = pack8888(dest0, dest1);
}
-
+
p += 2;
q += 2;
twidth -= 2;
}
-
+
while (twidth)
{
uint32_t m = *(uint32_t *)p;
-
+
if (m)
{
__m64 vdest = load8888(*q);
vdest = in_over(vsrc, vsrca, load8888(m), vdest);
*q = store8888(vdest);
}
-
+
twidth--;
p++;
q++;
}
-
+
dstLine += dstStride;
maskLine += maskStride;
}
-
+
_mm_empty();
}
__m64 vd5 = *(__m64 *)(dst + 10);
__m64 vd6 = *(__m64 *)(dst + 12);
__m64 vd7 = *(__m64 *)(dst + 14);
-
+
__m64 vs0 = *(__m64 *)(src + 0);
__m64 vs1 = *(__m64 *)(src + 2);
__m64 vs2 = *(__m64 *)(src + 4);
__m64 vs5 = *(__m64 *)(src + 10);
__m64 vs6 = *(__m64 *)(src + 12);
__m64 vs7 = *(__m64 *)(src + 14);
-
+
vd0 = pack8888 (
in_over (expand8888 (vs0, 0), srca, vmask, expand8888 (vd0, 0)),
in_over (expand8888 (vs0, 1), srca, vmask, expand8888 (vd0, 1)));
-
+
vd1 = pack8888 (
in_over (expand8888 (vs1, 0), srca, vmask, expand8888 (vd1, 0)),
in_over (expand8888 (vs1, 1), srca, vmask, expand8888 (vd1, 1)));
-
+
vd2 = pack8888 (
in_over (expand8888 (vs2, 0), srca, vmask, expand8888 (vd2, 0)),
in_over (expand8888 (vs2, 1), srca, vmask, expand8888 (vd2, 1)));
-
+
vd3 = pack8888 (
in_over (expand8888 (vs3, 0), srca, vmask, expand8888 (vd3, 0)),
in_over (expand8888 (vs3, 1), srca, vmask, expand8888 (vd3, 1)));
-
+
vd4 = pack8888 (
in_over (expand8888 (vs4, 0), srca, vmask, expand8888 (vd4, 0)),
in_over (expand8888 (vs4, 1), srca, vmask, expand8888 (vd4, 1)));
-
+
vd5 = pack8888 (
in_over (expand8888 (vs5, 0), srca, vmask, expand8888 (vd5, 0)),
in_over (expand8888 (vs5, 1), srca, vmask, expand8888 (vd5, 1)));
dst += 16;
src += 16;
}
-
+
while (w)
{
__m64 s = load8888 (*src | 0xff000000);
int dstStride, srcStride;
uint8_t a;
uint16_t w;
-
+
CHECKPOINT();
-
+
fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
dst++;
}
}
- _mm_empty();
+ _mm_empty();
}
void
uint32_t *srcLine, *src;
int dstStride, srcStride;
uint16_t w;
-
+
CHECKPOINT();
-
+
fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
-
+
#if 0
/* FIXME */
assert (pSrc->pDrawable == pMask->pDrawable);
#endif
-
+
while (height--)
{
dst = dstLine;
src = srcLine;
srcLine += srcStride;
w = width;
-
+
CHECKPOINT();
-
+
while (w && (unsigned long)dst & 7)
{
__m64 vsrc = load8888 (*src);
ullong d = *dst;
__m64 vdest = expand565 ((__m64)d, 0);
-
+
vdest = pack565(over(vsrc, expand_alpha(vsrc), vdest), vdest, 0);
-
+
*dst = (ullong)vdest;
-
+
w--;
dst++;
src++;
}
-
+
CHECKPOINT();
-
+
while (w >= 4)
{
__m64 vsrc0, vsrc1, vsrc2, vsrc3;
vsrc3 = load8888(*(src + 3));
vdest = *(__m64 *)dst;
-
+
vdest = pack565(over(vsrc0, expand_alpha(vsrc0), expand565(vdest, 0)), vdest, 0);
vdest = pack565(over(vsrc1, expand_alpha(vsrc1), expand565(vdest, 1)), vdest, 1);
vdest = pack565(over(vsrc2, expand_alpha(vsrc2), expand565(vdest, 2)), vdest, 2);
vdest = pack565(over(vsrc3, expand_alpha(vsrc3), expand565(vdest, 3)), vdest, 3);
-
+
*(__m64 *)dst = vdest;
w -= 4;
}
CHECKPOINT();
-
+
while (w)
{
__m64 vsrc = load8888 (*src);
ullong d = *dst;
__m64 vdest = expand565 ((__m64)d, 0);
-
+
vdest = pack565(over(vsrc, expand_alpha(vsrc), vdest), vdest, 0);
-
+
*dst = (ullong)vdest;
-
+
w--;
dst++;
src++;
}
}
-
+
_mm_empty();
}
uint16_t w;
__m64 vsrc, vsrca;
ullong srcsrc;
-
+
CHECKPOINT();
-
+
fbComposeGetSolid(pSrc, src, pDst->bits.format);
-
+
srca = src >> 24;
if (srca == 0)
return;
-
+
srcsrc = (unsigned long long)src << 32 | src;
-
+
fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);
-
+
vsrc = load8888 (src);
vsrca = expand_alpha (vsrc);
-
+
while (height--)
{
dst = dstLine;
mask = maskLine;
maskLine += maskStride;
w = width;
-
+
CHECKPOINT();
-
+
while (w && (unsigned long)dst & 7)
{
ullong m = *mask;
-
+
if (m)
{
__m64 vdest = in_over(vsrc, vsrca, expand_alpha_rev ((__m64)m), load8888(*dst));
*dst = store8888(vdest);
}
-
+
w--;
mask++;
dst++;
}
-
+
CHECKPOINT();
-
+
while (w >= 2)
{
ullong m0, m1;
m0 = *mask;
m1 = *(mask + 1);
-
+
if (srca == 0xff && (m0 & m1) == 0xff)
{
*(unsigned long long *)dst = srcsrc;
{
__m64 vdest;
__m64 dest0, dest1;
-
+
vdest = *(__m64 *)dst;
-
+
dest0 = in_over(vsrc, vsrca, expand_alpha_rev ((__m64)m0), expand8888(vdest, 0));
dest1 = in_over(vsrc, vsrca, expand_alpha_rev ((__m64)m1), expand8888(vdest, 1));
-
+
*(__m64 *)dst = pack8888(dest0, dest1);
}
-
+
mask += 2;
dst += 2;
w -= 2;
}
-
+
CHECKPOINT();
-
+
while (w)
{
ullong m = *mask;
-
+
if (m)
{
__m64 vdest = load8888(*dst);
vdest = in_over(vsrc, vsrca, expand_alpha_rev ((__m64)m), vdest);
*dst = store8888(vdest);
}
-
+
w--;
mask++;
dst++;
}
}
-
+
_mm_empty();
}
#ifdef __GNUC__
__m64 v1, v2, v3, v4, v5, v6, v7;
#endif
-
+
if (bpp == 16 && (xor >> 16 != (xor & 0xffff)))
return FALSE;
-
+
if (bpp != 16 && bpp != 32)
return FALSE;
-
+
if (bpp == 16)
{
stride = stride * sizeof (uint32_t) / 2;
byte_width = 4 * width;
stride *= 4;
}
-
+
fill = ((ullong)xor << 32) | xor;
vfill = (__m64)fill;
-
+
#ifdef __GNUC__
__asm__ (
"movq %7, %0\n"
"=y" (v4), "=y" (v5), "=y" (v6), "=y" (v7)
: "y" (vfill));
#endif
-
+
while (height--)
{
int w;
uint8_t *d = byte_line;
byte_line += stride;
w = byte_width;
-
+
while (w >= 2 && ((unsigned long)d & 3))
{
*(uint16_t *)d = xor;
w -= 2;
d += 2;
}
-
+
while (w >= 4 && ((unsigned long)d & 7))
{
*(uint32_t *)d = xor;
-
+
w -= 4;
d += 4;
}
*(__m64*) (d + 40) = vfill;
*(__m64*) (d + 48) = vfill;
*(__m64*) (d + 56) = vfill;
-#endif
+#endif
w -= 64;
d += 64;
}
-
+
while (w >= 4)
{
*(uint32_t *)d = xor;
-
+
w -= 4;
d += 4;
}
d += 2;
}
}
-
+
_mm_empty();
return TRUE;
}
uint16_t w;
__m64 vsrc, vsrca;
unsigned long long srcsrcsrcsrc, src16;
-
+
CHECKPOINT();
-
+
fbComposeGetSolid(pSrc, src, pDst->bits.format);
-
+
srca = src >> 24;
if (srca == 0)
return;
-
+
fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);
-
+
vsrc = load8888 (src);
vsrca = expand_alpha (vsrc);
-
+
src16 = (ullong)pack565(vsrc, _mm_setzero_si64(), 0);
-
+
srcsrcsrcsrc = (ullong)src16 << 48 | (ullong)src16 << 32 |
(ullong)src16 << 16 | (ullong)src16;
-
+
while (height--)
{
dst = dstLine;
mask = maskLine;
maskLine += maskStride;
w = width;
-
+
CHECKPOINT();
-
+
while (w && (unsigned long)dst & 7)
{
ullong m = *mask;
-
+
if (m)
{
ullong d = *dst;
__m64 vdest = in_over(vsrc, vsrca, expand_alpha_rev ((__m64)m), expand565(vd, 0));
*dst = (ullong)pack565(vdest, _mm_setzero_si64(), 0);
}
-
+
w--;
mask++;
dst++;
}
-
+
CHECKPOINT();
-
+
while (w >= 4)
{
ullong m0, m1, m2, m3;
m1 = *(mask + 1);
m2 = *(mask + 2);
m3 = *(mask + 3);
-
+
if (srca == 0xff && (m0 & m1 & m2 & m3) == 0xff)
{
*(unsigned long long *)dst = srcsrcsrcsrc;
{
__m64 vdest;
__m64 vm0, vm1, vm2, vm3;
-
+
vdest = *(__m64 *)dst;
-
+
vm0 = (__m64)m0;
vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm0), expand565(vdest, 0)), vdest, 0);
vm1 = (__m64)m1;
vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm2), expand565(vdest, 2)), vdest, 2);
vm3 = (__m64)m3;
vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm3), expand565(vdest, 3)), vdest, 3);
-
+
*(__m64 *)dst = vdest;
}
-
+
w -= 4;
mask += 4;
dst += 4;
}
-
+
CHECKPOINT();
-
+
while (w)
{
ullong m = *mask;
-
+
if (m)
{
ullong d = *dst;
__m64 vdest = in_over(vsrc, vsrca, expand_alpha_rev ((__m64)m), expand565(vd, 0));
*dst = (ullong)pack565(vdest, _mm_setzero_si64(), 0);
}
-
+
w--;
mask++;
dst++;
}
}
-
+
_mm_empty();
}
uint32_t *srcLine, *src;
int dstStride, srcStride;
uint16_t w;
-
+
CHECKPOINT();
-
+
fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
-
+
#if 0
/* FIXME */
assert (pSrc->pDrawable == pMask->pDrawable);
#endif
-
+
while (height--)
{
dst = dstLine;
src = srcLine;
srcLine += srcStride;
w = width;
-
+
CHECKPOINT();
-
+
while (w && (unsigned long)dst & 7)
{
__m64 vsrc = load8888 (*src);
ullong d = *dst;
__m64 vdest = expand565 ((__m64)d, 0);
-
+
vdest = pack565(over_rev_non_pre(vsrc, vdest), vdest, 0);
-
+
*dst = (ullong)vdest;
-
+
w--;
dst++;
src++;
}
-
+
CHECKPOINT();
-
+
while (w >= 4)
{
uint32_t s0, s1, s2, s3;
unsigned char a0, a1, a2, a3;
-
+
s0 = *src;
s1 = *(src + 1);
s2 = *(src + 2);
s3 = *(src + 3);
-
+
a0 = (s0 >> 24);
a1 = (s1 >> 24);
a2 = (s2 >> 24);
a3 = (s3 >> 24);
-
+
if ((a0 & a1 & a2 & a3) == 0xFF)
{
__m64 vdest;
vdest = pack565(invert_colors(load8888(s1)), vdest, 1);
vdest = pack565(invert_colors(load8888(s2)), vdest, 2);
vdest = pack565(invert_colors(load8888(s3)), vdest, 3);
-
+
*(__m64 *)dst = vdest;
}
else if (a0 | a1 | a2 | a3)
{
__m64 vdest = *(__m64 *)dst;
-
+
vdest = pack565(over_rev_non_pre(load8888(s0), expand565(vdest, 0)), vdest, 0);
vdest = pack565(over_rev_non_pre(load8888(s1), expand565(vdest, 1)), vdest, 1);
vdest = pack565(over_rev_non_pre(load8888(s2), expand565(vdest, 2)), vdest, 2);
vdest = pack565(over_rev_non_pre(load8888(s3), expand565(vdest, 3)), vdest, 3);
-
+
*(__m64 *)dst = vdest;
}
-
+
w -= 4;
dst += 4;
src += 4;
}
-
+
CHECKPOINT();
-
+
while (w)
{
__m64 vsrc = load8888 (*src);
ullong d = *dst;
__m64 vdest = expand565 ((__m64)d, 0);
-
+
vdest = pack565(over_rev_non_pre(vsrc, vdest), vdest, 0);
-
+
*dst = (ullong)vdest;
-
+
w--;
dst++;
src++;
}
}
-
+
_mm_empty();
}
uint32_t *srcLine, *src;
int dstStride, srcStride;
uint16_t w;
-
+
CHECKPOINT();
-
+
fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
-
+
#if 0
/* FIXME */
assert (pSrc->pDrawable == pMask->pDrawable);
#endif
-
+
while (height--)
{
dst = dstLine;
src = srcLine;
srcLine += srcStride;
w = width;
-
+
while (w && (unsigned long)dst & 7)
{
__m64 s = load8888 (*src);
__m64 d = load8888 (*dst);
-
+
*dst = store8888 (over_rev_non_pre (s, d));
-
+
w--;
dst++;
src++;
}
-
+
while (w >= 2)
{
ullong s0, s1;
unsigned char a0, a1;
__m64 d0, d1;
-
+
s0 = *src;
s1 = *(src + 1);
-
+
a0 = (s0 >> 24);
a1 = (s1 >> 24);
-
+
if ((a0 & a1) == 0xFF)
{
d0 = invert_colors(load8888(s0));
d1 = invert_colors(load8888(s1));
-
+
*(__m64 *)dst = pack8888 (d0, d1);
}
else if (a0 | a1)
{
__m64 vdest = *(__m64 *)dst;
-
+
d0 = over_rev_non_pre (load8888(s0), expand8888 (vdest, 0));
d1 = over_rev_non_pre (load8888(s1), expand8888 (vdest, 1));
-
+
*(__m64 *)dst = pack8888 (d0, d1);
}
-
+
w -= 2;
dst += 2;
src += 2;
}
-
+
while (w)
{
__m64 s = load8888 (*src);
__m64 d = load8888 (*dst);
-
+
*dst = store8888 (over_rev_non_pre (s, d));
-
+
w--;
dst++;
src++;
}
}
-
+
_mm_empty();
}
uint32_t *maskLine;
int dstStride, maskStride;
__m64 vsrc, vsrca;
-
+
CHECKPOINT();
-
+
fbComposeGetSolid(pSrc, src, pDst->bits.format);
-
+
srca = src >> 24;
if (srca == 0)
return;
-
+
fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
fbComposeGetStart (pMask, xMask, yMask, uint32_t, maskStride, maskLine, 1);
-
+
vsrc = load8888 (src);
vsrca = expand_alpha (vsrc);
-
+
while (height--)
{
int twidth = width;
uint32_t *p = (uint32_t *)maskLine;
uint16_t *q = (uint16_t *)dstLine;
-
+
while (twidth && ((unsigned long)q & 7))
{
uint32_t m = *(uint32_t *)p;
-
+
if (m)
{
ullong d = *q;
vdest = pack565 (in_over (vsrc, vsrca, load8888 (m), vdest), vdest, 0);
*q = (ullong)vdest;
}
-
+
twidth--;
p++;
q++;
}
-
+
while (twidth >= 4)
{
uint32_t m0, m1, m2, m3;
-
+
m0 = *p;
m1 = *(p + 1);
m2 = *(p + 2);
m3 = *(p + 3);
-
+
if ((m0 | m1 | m2 | m3))
{
__m64 vdest = *(__m64 *)q;
-
+
vdest = pack565(in_over(vsrc, vsrca, load8888(m0), expand565(vdest, 0)), vdest, 0);
vdest = pack565(in_over(vsrc, vsrca, load8888(m1), expand565(vdest, 1)), vdest, 1);
vdest = pack565(in_over(vsrc, vsrca, load8888(m2), expand565(vdest, 2)), vdest, 2);
vdest = pack565(in_over(vsrc, vsrca, load8888(m3), expand565(vdest, 3)), vdest, 3);
-
+
*(__m64 *)q = vdest;
}
twidth -= 4;
p += 4;
q += 4;
}
-
+
while (twidth)
{
uint32_t m;
-
+
m = *(uint32_t *)p;
if (m)
{
vdest = pack565 (in_over(vsrc, vsrca, load8888(m), vdest), vdest, 0);
*q = (ullong)vdest;
}
-
+
twidth--;
p++;
q++;
}
-
+
maskLine += maskStride;
dstLine += dstStride;
}
-
+
_mm_empty ();
}
uint16_t w;
uint8_t s, d;
uint16_t t;
-
+
CHECKPOINT();
-
+
fbComposeGetStart (pSrc, xSrc, ySrc, uint8_t, srcStride, srcLine, 1);
fbComposeGetStart (pDst, xDst, yDst, uint8_t, dstStride, dstLine, 1);
-
+
while (height--)
{
dst = dstLine;
src = srcLine;
srcLine += srcStride;
w = width;
-
+
while (w && (unsigned long)dst & 7)
{
s = *src;
t = d + s;
s = t | (0 - (t >> 8));
*dst = s;
-
+
dst++;
src++;
w--;
}
-
+
while (w >= 8)
{
*(__m64*)dst = _mm_adds_pu8(*(__m64*)src, *(__m64*)dst);
src += 8;
w -= 8;
}
-
+
while (w)
{
s = *src;
t = d + s;
s = t | (0 - (t >> 8));
*dst = s;
-
+
dst++;
src++;
w--;
}
}
-
+
_mm_empty();
}
uint32_t *srcLine, *src;
int dstStride, srcStride;
uint16_t w;
-
+
CHECKPOINT();
-
+
fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
-
+
while (height--)
{
dst = dstLine;
src = srcLine;
srcLine += srcStride;
w = width;
-
+
while (w && (unsigned long)dst & 7)
{
*dst = _mm_cvtsi64_si32(_mm_adds_pu8(_mm_cvtsi32_si64(*src),
src++;
w--;
}
-
+
while (w >= 2)
{
*(ullong*)dst = (ullong) _mm_adds_pu8(*(__m64*)src, *(__m64*)dst);
src += 2;
w -= 2;
}
-
+
if (w)
{
*dst = _mm_cvtsi64_si32(_mm_adds_pu8(_mm_cvtsi32_si64(*src),
_mm_cvtsi32_si64(*dst)));
-
+
}
}
-
+
_mm_empty();
}
-pixman_bool_t
+pixman_bool_t
pixman_blt_mmx (uint32_t *src_bits,
uint32_t *dst_bits,
int src_stride,
uint8_t * src_bytes;
uint8_t * dst_bytes;
int byte_width;
-
+
if (src_bpp != dst_bpp)
return FALSE;
-
+
if (src_bpp == 16)
{
src_stride = src_stride * sizeof (uint32_t) / 2;
src_bytes += src_stride;
dst_bytes += dst_stride;
w = byte_width;
-
+
while (w >= 2 && ((unsigned long)d & 3))
{
*(uint16_t *)d = *(uint16_t *)s;
s += 2;
d += 2;
}
-
+
while (w >= 4 && ((unsigned long)d & 7))
{
*(uint32_t *)d = *(uint32_t *)s;
-
+
w -= 4;
s += 4;
d += 4;
}
-
+
while (w >= 64)
{
#ifdef __GNUC__
*(__m64 *)(d + 40) = v5;
*(__m64 *)(d + 48) = v6;
*(__m64 *)(d + 56) = v7;
-#endif
-
+#endif
+
w -= 64;
s += 64;
d += 64;
d += 2;
}
}
-
+
_mm_empty();
return TRUE;
*dst = store8888 (vdest);
}
}
-
+
mask++;
dst++;
src++;