pixman: Branch 'master' - 12 commits
Søren Sandmann Pedersen
sandmann at kemper.freedesktop.org
Wed Jun 24 09:45:17 PDT 2009
pixman/make-combine.pl | 2
pixman/pixman-access.c | 684 +++++++++++++++++++++++----------------
pixman/pixman-bits-image.c | 118 +++---
pixman/pixman-combine.c.template | 5
pixman/pixman-combine.h.template | 8
pixman/pixman-conical-gradient.c | 9
pixman/pixman-fast-path.c | 12
pixman/pixman-general.c | 4
pixman/pixman-image.c | 27 -
pixman/pixman-linear-gradient.c | 8
pixman/pixman-mmx.c | 13
pixman/pixman-private.h | 72 +---
pixman/pixman-radial-gradient.c | 8
pixman/pixman-solid-fill.c | 8
pixman/pixman-sse2.c | 3
test/clip-test.c | 1
16 files changed, 557 insertions(+), 425 deletions(-)
New commits:
commit 084392fbd72e55f87e9bc37dd02384fc145f7d36
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Wed Jun 24 05:44:18 2009 -0400
Delete scanFetchProc type. Use fetch_scanline_t instead.
fetch_scanline_t now takes a pixman_image_t argument instead of an
bits_image_t, so there is also a bunch of updates in pixman-access.c
diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c
index 491f224..833baf5 100644
--- a/pixman/pixman-access.c
+++ b/pixman/pixman-access.c
@@ -50,15 +50,16 @@
* YV12 setup and access macros
*/
-#define YV12_SETUP(pict) \
- uint32_t *bits = pict->bits; \
- int stride = pict->rowstride; \
- int offset0 = stride < 0 ? \
- ((-stride) >> 1) * ((pict->height - 1) >> 1) - stride : \
- stride * pict->height; \
- int offset1 = stride < 0 ? \
- offset0 + ((-stride) >> 1) * ((pict->height) >> 1) : \
- offset0 + (offset0 >> 2)
+#define YV12_SETUP(image) \
+ bits_image_t *__bits_image = (bits_image_t *)image; \
+ uint32_t *bits = __bits_image->bits; \
+ int stride = __bits_image->rowstride; \
+ int offset0 = stride < 0 ? \
+ ((-stride) >> 1) * ((__bits_image->height - 1) >> 1) - stride : \
+ stride * __bits_image->height; \
+ int offset1 = stride < 0 ? \
+ offset0 + ((-stride) >> 1) * ((__bits_image->height) >> 1) : \
+ offset0 + (offset0 >> 2)
/* Note no trailing semicolon on the above macro; if it's there, then
* the typical usage of YV12_SETUP(pict); will have an extra trailing ;
* that some compilers will interpret as a statement -- and then any further
@@ -79,36 +80,36 @@
/*********************************** Fetch ************************************/
static void
-fbFetch_a8r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a8r8g8b8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
- MEMCPY_WRAPPED(pict,
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
+ MEMCPY_WRAPPED(image,
buffer, (const uint32_t *)bits + x,
width*sizeof(uint32_t));
}
static void
-fbFetch_x8r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_x8r8g8b8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint32_t *pixel = (const uint32_t *)bits + x;
const uint32_t *end = pixel + width;
while (pixel < end) {
- *buffer++ = READ(pict, pixel++) | 0xff000000;
+ *buffer++ = READ(image, pixel++) | 0xff000000;
}
}
static void
-fbFetch_a8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a8b8g8r8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
const uint32_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
*buffer++ = (p & 0xff00ff00) |
((p >> 16) & 0xff) |
((p & 0xff) << 16);
@@ -116,14 +117,14 @@ fbFetch_a8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_x8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_x8b8g8r8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
const uint32_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
*buffer++ = 0xff000000 |
(p & 0x0000ff00) |
((p >> 16) & 0xff) |
@@ -132,14 +133,14 @@ fbFetch_x8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_b8g8r8a8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_b8g8r8a8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
const uint32_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
*buffer++ = ((p & 0xff000000) >> 24) |
((p & 0x00ff0000) >> 8) |
((p & 0x0000ff00) << 8) |
@@ -148,14 +149,14 @@ fbFetch_b8g8r8a8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_b8g8r8x8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_b8g8r8x8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
const uint32_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
*buffer++ = 0xff000000 |
((p & 0xff000000) >> 24) |
((p & 0x00ff0000) >> 8) |
@@ -165,16 +166,16 @@ fbFetch_b8g8r8x8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
/* Expects a uint64_t buffer */
static void
-fbFetch_a2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b,
+fbFetch_a2b10g10r10 (pixman_image_t *image, int x, int y, int width, uint32_t *b,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint32_t *pixel = bits + x;
const uint32_t *end = pixel + width;
uint64_t *buffer = (uint64_t *)b;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
uint64_t a = p >> 30;
uint64_t b = (p >> 20) & 0x3ff;
uint64_t g = (p >> 10) & 0x3ff;
@@ -195,16 +196,16 @@ fbFetch_a2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b,
/* Expects a uint64_t buffer */
static void
-fbFetch_x2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b,
+fbFetch_x2b10g10r10 (pixman_image_t *image, int x, int y, int width, uint32_t *b,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
const uint32_t *end = pixel + width;
uint64_t *buffer = (uint64_t *)b;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
uint64_t b = (p >> 20) & 0x3ff;
uint64_t g = (p >> 10) & 0x3ff;
uint64_t r = p & 0x3ff;
@@ -218,58 +219,58 @@ fbFetch_x2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b,
}
static void
-fbFetch_r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_r8g8b8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + 3*x;
const uint8_t *end = pixel + 3*width;
while (pixel < end) {
uint32_t b = 0xff000000;
#ifdef WORDS_BIGENDIAN
- b |= (READ(pict, pixel++) << 16);
- b |= (READ(pict, pixel++) << 8);
- b |= (READ(pict, pixel++));
+ b |= (READ(image, pixel++) << 16);
+ b |= (READ(image, pixel++) << 8);
+ b |= (READ(image, pixel++));
#else
- b |= (READ(pict, pixel++));
- b |= (READ(pict, pixel++) << 8);
- b |= (READ(pict, pixel++) << 16);
+ b |= (READ(image, pixel++));
+ b |= (READ(image, pixel++) << 8);
+ b |= (READ(image, pixel++) << 16);
#endif
*buffer++ = b;
}
}
static void
-fbFetch_b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_b8g8r8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + 3*x;
const uint8_t *end = pixel + 3*width;
while (pixel < end) {
uint32_t b = 0xff000000;
#ifdef WORDS_BIGENDIAN
- b |= (READ(pict, pixel++));
- b |= (READ(pict, pixel++) << 8);
- b |= (READ(pict, pixel++) << 16);
+ b |= (READ(image, pixel++));
+ b |= (READ(image, pixel++) << 8);
+ b |= (READ(image, pixel++) << 16);
#else
- b |= (READ(pict, pixel++) << 16);
- b |= (READ(pict, pixel++) << 8);
- b |= (READ(pict, pixel++));
+ b |= (READ(image, pixel++) << 16);
+ b |= (READ(image, pixel++) << 8);
+ b |= (READ(image, pixel++));
#endif
*buffer++ = b;
}
}
static void
-fbFetch_r5g6b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_r5g6b5 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
uint32_t r = (((p) << 3) & 0xf8) |
(((p) << 5) & 0xfc00) |
(((p) << 8) & 0xf80000);
@@ -280,15 +281,15 @@ fbFetch_r5g6b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_b5g6r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_b5g6r5 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
b = ((p & 0xf800) | ((p & 0xe000) >> 5)) >> 8;
g = ((p & 0x07e0) | ((p & 0x0600) >> 6)) << 5;
r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
@@ -297,15 +298,15 @@ fbFetch_b5g6r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_a1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a1r5g5b5 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b, a;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
a = (uint32_t) ((uint8_t) (0 - ((p & 0x8000) >> 15))) << 24;
r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
@@ -316,15 +317,15 @@ fbFetch_a1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_x1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_x1r5g5b5 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
@@ -334,15 +335,15 @@ fbFetch_x1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_a1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a1b5g5r5 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b, a;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
a = (uint32_t) ((uint8_t) (0 - ((p & 0x8000) >> 15))) << 24;
b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
@@ -353,15 +354,15 @@ fbFetch_a1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_x1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_x1b5g5r5 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
@@ -371,15 +372,15 @@ fbFetch_x1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_a4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a4r4g4b4 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b, a;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
@@ -390,15 +391,15 @@ fbFetch_a4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_x4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_x4r4g4b4 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
@@ -408,15 +409,15 @@ fbFetch_x4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_a4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a4b4g4r4 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b, a;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) >> 4;
@@ -427,15 +428,15 @@ fbFetch_a4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_x4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_x4b4g4r4 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
const uint16_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) >> 4;
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
@@ -445,27 +446,27 @@ fbFetch_x4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_a8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- *buffer++ = READ(pict, pixel++) << 24;
+ *buffer++ = READ(image, pixel++) << 24;
}
}
static void
-fbFetch_r3g3b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_r3g3b2 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
r = ((p & 0xe0) | ((p & 0xe0) >> 3) | ((p & 0xc0) >> 6)) << 16;
g = ((p & 0x1c) | ((p & 0x18) >> 3) | ((p & 0x1c) << 3)) << 8;
@@ -478,15 +479,15 @@ fbFetch_r3g3b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_b2g3r3 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_b2g3r3 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
b = (((p & 0xc0) ) |
((p & 0xc0) >> 2) |
@@ -501,15 +502,15 @@ fbFetch_b2g3r3 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_a2r2g2b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a2r2g2b2 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t a,r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
a = ((p & 0xc0) * 0x55) << 18;
r = ((p & 0x30) * 0x55) << 12;
@@ -520,15 +521,15 @@ fbFetch_a2r2g2b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_a2b2g2r2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a2b2g2r2 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t a,r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
a = ((p & 0xc0) * 0x55) << 18;
b = ((p & 0x30) * 0x55) >> 6;
@@ -539,28 +540,28 @@ fbFetch_a2b2g2r2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_c8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_c8 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
- const pixman_indexed_t * indexed = pict->indexed;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
+ const pixman_indexed_t * indexed = image->bits.indexed;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint32_t p = READ(pict, pixel++);
+ uint32_t p = READ(image, pixel++);
*buffer++ = indexed->rgba[p];
}
}
static void
-fbFetch_x4a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_x4a4 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
const uint8_t *end = pixel + width;
while (pixel < end) {
- uint8_t p = READ(pict, pixel++) & 0xf;
+ uint8_t p = READ(image, pixel++) & 0xf;
*buffer++ = (p | (p << 4)) << 24;
}
}
@@ -573,13 +574,13 @@ fbFetch_x4a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
#endif
static void
-fbFetch_a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a4 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(pict, bits, i + x);
+ uint32_t p = Fetch4(image, bits, i + x);
p |= p << 4;
*buffer++ = p << 24;
@@ -587,14 +588,14 @@ fbFetch_a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_r1g2b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_r1g2b1 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(pict, bits, i + x);
+ uint32_t p = Fetch4(image, bits, i + x);
r = ((p & 0x8) * 0xff) << 13;
g = ((p & 0x6) * 0x55) << 7;
@@ -604,14 +605,14 @@ fbFetch_r1g2b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_b1g2r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_b1g2r1 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(pict, bits, i + x);
+ uint32_t p = Fetch4(image, bits, i + x);
b = ((p & 0x8) * 0xff) >> 3;
g = ((p & 0x6) * 0x55) << 7;
@@ -621,14 +622,14 @@ fbFetch_b1g2r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_a1r1g1b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a1r1g1b1 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t a,r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(pict, bits, i + x);
+ uint32_t p = Fetch4(image, bits, i + x);
a = ((p & 0x8) * 0xff) << 21;
r = ((p & 0x4) * 0xff) << 14;
@@ -639,14 +640,14 @@ fbFetch_a1r1g1b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_a1b1g1r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a1b1g1r1 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
uint32_t a,r,g,b;
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(pict, bits, i + x);
+ uint32_t p = Fetch4(image, bits, i + x);
a = ((p & 0x8) * 0xff) << 21;
r = ((p & 0x4) * 0xff) >> 3;
@@ -657,14 +658,14 @@ fbFetch_a1b1g1r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_c4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_c4 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
- const pixman_indexed_t * indexed = pict->indexed;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
+ const pixman_indexed_t * indexed = image->bits.indexed;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = Fetch4(pict, bits, i + x);
+ uint32_t p = Fetch4 (image, bits, i + x);
*buffer++ = indexed->rgba[p];
}
@@ -672,13 +673,13 @@ fbFetch_c4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
static void
-fbFetch_a1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_a1 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = READ(pict, bits + ((i + x) >> 5));
+ uint32_t p = READ(image, bits + ((i + x) >> 5));
uint32_t a;
#ifdef WORDS_BIGENDIAN
a = p >> (0x1f - ((i+x) & 0x1f));
@@ -694,14 +695,14 @@ fbFetch_a1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_g1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch_g1 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- const uint32_t *bits = pict->bits + y*pict->rowstride;
- const pixman_indexed_t * indexed = pict->indexed;
+ const uint32_t *bits = image->bits.bits + y*image->bits.rowstride;
+ const pixman_indexed_t * indexed = image->bits.indexed;
int i;
for (i = 0; i < width; ++i) {
- uint32_t p = READ(pict, bits + ((i+x) >> 5));
+ uint32_t p = READ(image, bits + ((i+x) >> 5));
uint32_t a;
#ifdef WORDS_BIGENDIAN
a = p >> (0x1f - ((i+x) & 0x1f));
@@ -714,14 +715,14 @@ fbFetch_g1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
}
static void
-fbFetch_yuy2 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer,
+fbFetch_yuy2 (pixman_image_t *image, int x, int line, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
int16_t y, u, v;
int32_t r, g, b;
int i;
- const uint32_t *bits = pict->bits + pict->rowstride * line;
+ const uint32_t *bits = image->bits.bits + image->bits.rowstride * line;
for (i = 0; i < width; i++)
{
@@ -736,18 +737,18 @@ fbFetch_yuy2 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer,
/* B = 1.164(Y - 16) + 2.018(U - 128) */
b = 0x012b27 * y + 0x0206a2 * u;
- 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));
+ *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);
}
}
static void
-fbFetch_yv12 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer,
+fbFetch_yv12 (pixman_image_t *image, int x, int line, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
- YV12_SETUP(pict);
+ YV12_SETUP(image);
uint8_t *pY = YV12_Y (line);
uint8_t *pU = YV12_U (line);
uint8_t *pV = YV12_V (line);
@@ -768,10 +769,10 @@ fbFetch_yv12 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer,
/* B = 1.164(Y - 16) + 2.018(U - 128) */
b = 0x012b27 * y + 0x0206a2 * u;
- WRITE(pict, buffer++, 0xff000000 |
+ *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 >= 0 ? b < 0x1000000 ? (b >> 16) & 0x0000ff : 0x0000ff : 0);
}
}
@@ -1562,7 +1563,7 @@ fbFetchPixel_a4 (bits_image_t *pict, uint32_t *buffer, int n_pixels)
else
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(pict, bits, offset);
+ uint32_t pixel = Fetch4 (pict, bits, offset);
pixel |= pixel << 4;
buffer[i] = pixel << 24;
@@ -1588,7 +1589,7 @@ fbFetchPixel_r1g2b1 (bits_image_t *pict, uint32_t *buffer, int n_pixels)
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(pict, bits, offset);
+ uint32_t pixel = Fetch4 (pict, bits, offset);
r = ((pixel & 0x8) * 0xff) << 13;
g = ((pixel & 0x6) * 0x55) << 7;
@@ -1616,7 +1617,7 @@ fbFetchPixel_b1g2r1 (bits_image_t *pict, uint32_t *buffer, int n_pixels)
{
uint32_t r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(pict, bits, offset);
+ uint32_t pixel = Fetch4 (pict, bits, offset);
b = ((pixel & 0x8) * 0xff) >> 3;
g = ((pixel & 0x6) * 0x55) << 7;
@@ -1644,7 +1645,7 @@ fbFetchPixel_a1r1g1b1 (bits_image_t *pict, uint32_t *buffer, int n_pixels)
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(pict, bits, offset);
+ uint32_t pixel = Fetch4 (pict, bits, offset);
a = ((pixel & 0x8) * 0xff) << 21;
r = ((pixel & 0x4) * 0xff) << 14;
@@ -1673,7 +1674,7 @@ fbFetchPixel_a1b1g1r1 (bits_image_t *pict, uint32_t *buffer, int n_pixels)
{
uint32_t a,r,g,b;
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(pict, bits, offset);
+ uint32_t pixel = Fetch4 (pict, bits, offset);
a = ((pixel & 0x8) * 0xff) << 21;
r = ((pixel & 0x4) * 0xff) >> 3;
@@ -1701,7 +1702,7 @@ fbFetchPixel_c4 (bits_image_t *pict, uint32_t *buffer, int n_pixels)
else
{
uint32_t *bits = pict->bits + line*pict->rowstride;
- uint32_t pixel = Fetch4(pict, bits, offset);
+ uint32_t pixel = Fetch4 (pict, bits, offset);
const pixman_indexed_t * indexed = pict->indexed;
buffer[i] = indexed->rgba[pixel];
@@ -2497,15 +2498,15 @@ fbStore64_generic (bits_image_t *image, int x, int y, int width, const uint32_t
/* Despite the type, this function expects both buffer and mask to be uint64_t */
static void
-fbFetch64_generic (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+fbFetch64_generic (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
const uint32_t *mask, uint32_t mask_bits)
{
/* Fetch the pixels into the first half of buffer and then expand them in
* place.
*/
- pict->fetch_scanline_raw_32 (pict, x, y, width, buffer, NULL, 0);
+ image->bits.fetch_scanline_raw_32 (image, x, y, width, buffer, NULL, 0);
- pixman_expand ((uint64_t *)buffer, buffer, pict->format, width);
+ pixman_expand ((uint64_t *)buffer, buffer, image->bits.format, width);
}
/* Despite the type, this function expects a uint64_t *buffer */
diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c
index 0c5f07c..3b65a01 100644
--- a/pixman/pixman-bits-image.c
+++ b/pixman/pixman-bits-image.c
@@ -653,9 +653,9 @@ bits_image_fetch_untransformed_repeat_none (bits_image_t *image, pixman_bool_t w
w = MIN (width, image->width - x);
if (wide)
- image->fetch_scanline_raw_64 (image, x, y, w, buffer, NULL, 0);
+ image->fetch_scanline_raw_64 ((pixman_image_t *)image, x, y, w, buffer, NULL, 0);
else
- image->fetch_scanline_raw_32 (image, x, y, w, buffer, NULL, 0);
+ image->fetch_scanline_raw_32 ((pixman_image_t *)image, x, y, w, buffer, NULL, 0);
width -= w;
buffer += w;
@@ -687,9 +687,9 @@ bits_image_fetch_untransformed_repeat_normal (bits_image_t *image, pixman_bool_t
w = MIN (width, image->width - x);
if (wide)
- image->fetch_scanline_raw_64 (image, x, y, w, buffer, NULL, 0);
+ image->fetch_scanline_raw_64 ((pixman_image_t *)image, x, y, w, buffer, NULL, 0);
else
- image->fetch_scanline_raw_32 (image, x, y, w, buffer, NULL, 0);
+ image->fetch_scanline_raw_32 ((pixman_image_t *)image, x, y, w, buffer, NULL, 0);
buffer += w;
x += w;
diff --git a/pixman/pixman-general.c b/pixman/pixman-general.c
index 62cb3e4..3da6afb 100644
--- a/pixman/pixman-general.c
+++ b/pixman/pixman-general.c
@@ -65,7 +65,7 @@ general_composite_rect (pixman_implementation_t *imp,
const int Bpp = wide ? 8 : 4;
uint8_t *scanline_buffer = stack_scanline_buffer;
uint8_t *src_buffer, *mask_buffer, *dest_buffer;
- scanFetchProc fetchSrc = NULL, fetchMask = NULL, fetchDest = NULL;
+ fetch_scanline_t fetchSrc = NULL, fetchMask = NULL, fetchDest = NULL;
pixman_combine_32_func_t compose;
store_scanline_t store;
source_pict_class_t srcClass, maskClass;
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index cd5b97a..54d6563 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -26,7 +26,7 @@ typedef struct radial_gradient radial_gradient_t;
typedef struct bits_image bits_image_t;
typedef struct circle circle_t;
-typedef void (*fetch_scanline_t) (bits_image_t *pict,
+typedef void (*fetch_scanline_t) (pixman_image_t *pict,
int x, int y, int width,
uint32_t *buffer,
const uint32_t *mask,
@@ -37,10 +37,6 @@ typedef void (*store_scanline_t) (bits_image_t *image,
int x, int y, int width,
const uint32_t *values);
-typedef void (*scanFetchProc) (pixman_image_t *,
- int, int, int, uint32_t *,
- const uint32_t *, uint32_t);
-
typedef enum
{
BITS,
@@ -88,8 +84,8 @@ struct image_common
pixman_write_memory_func_t write_func;
classify_func_t classify;
property_changed_func_t property_changed;
- scanFetchProc get_scanline_32;
- scanFetchProc get_scanline_64;
+ fetch_scanline_t get_scanline_32;
+ fetch_scanline_t get_scanline_64;
pixman_image_destroy_func_t destroy_func;
void * destroy_data;
commit 588b42dc1e8fe252bde1eb0905bb9fac806e8ca3
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 21:28:28 2009 -0400
Constify the mask argument to scanline fetchers.
diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c
index e267962..0c5f07c 100644
--- a/pixman/pixman-bits-image.c
+++ b/pixman/pixman-bits-image.c
@@ -492,9 +492,9 @@ bits_image_fetch_filtered (bits_image_t *pict, uint32_t *buffer, int n_pixels)
}
static void
-bits_image_fetch_transformed (pixman_image_t * pict, int x, int y, int width,
- uint32_t *buffer, uint32_t *mask,
- uint32_t maskBits)
+bits_image_fetch_transformed (pixman_image_t * pict, int x, int y,
+ int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t maskBits)
{
uint32_t *bits;
int32_t stride;
@@ -587,10 +587,9 @@ bits_image_fetch_transformed (pixman_image_t * pict, int x, int y, int width,
}
static void
-bits_image_fetch_solid_32 (pixman_image_t * image,
- int x, int y, int width,
- uint32_t *buffer,
- uint32_t *mask, uint32_t maskBits)
+bits_image_fetch_solid_32 (pixman_image_t * image, int x, int y,
+ int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t maskBits)
{
uint32_t color[2];
uint32_t *end;
@@ -606,11 +605,9 @@ bits_image_fetch_solid_32 (pixman_image_t * image,
}
static void
-bits_image_fetch_solid_64 (pixman_image_t * image,
- int x, int y, int width,
- uint32_t *b,
- uint32_t *unused,
- uint32_t unused2)
+bits_image_fetch_solid_64 (pixman_image_t * image, int x, int y,
+ int width, uint32_t *b,
+ const uint32_t *unused, uint32_t unused2)
{
uint32_t color[2];
uint32_t *coords = (uint32_t *)color;
@@ -701,10 +698,9 @@ bits_image_fetch_untransformed_repeat_normal (bits_image_t *image, pixman_bool_t
}
static void
-bits_image_fetch_untransformed_32 (pixman_image_t * image,
- int x, int y, int width,
- uint32_t *buffer,
- uint32_t *mask, uint32_t maskBits)
+bits_image_fetch_untransformed_32 (pixman_image_t * image, int x, int y,
+ int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t maskBits)
{
if (image->common.repeat == PIXMAN_REPEAT_NONE)
{
@@ -719,10 +715,9 @@ bits_image_fetch_untransformed_32 (pixman_image_t * image,
}
static void
-bits_image_fetch_untransformed_64 (pixman_image_t * image,
- int x, int y, int width,
- uint32_t *buffer,
- uint32_t *unused, uint32_t unused2)
+bits_image_fetch_untransformed_64 (pixman_image_t * image, int x, int y,
+ int width, uint32_t *buffer,
+ const uint32_t *unused, uint32_t unused2)
{
if (image->common.repeat == PIXMAN_REPEAT_NONE)
{
@@ -762,10 +757,8 @@ bits_image_property_changed (pixman_image_t *image)
(bits->common.repeat == PIXMAN_REPEAT_NONE ||
bits->common.repeat == PIXMAN_REPEAT_NORMAL))
{
- image->common.get_scanline_64 =
- bits_image_fetch_untransformed_64;
- image->common.get_scanline_32 =
- bits_image_fetch_untransformed_32;
+ image->common.get_scanline_64 = bits_image_fetch_untransformed_64;
+ image->common.get_scanline_32 = bits_image_fetch_untransformed_32;
}
else
{
diff --git a/pixman/pixman-conical-gradient.c b/pixman/pixman-conical-gradient.c
index ea6744f..c73be56 100644
--- a/pixman/pixman-conical-gradient.c
+++ b/pixman/pixman-conical-gradient.c
@@ -29,10 +29,9 @@
#include "pixman-private.h"
static void
-conical_gradient_get_scanline_32 (pixman_image_t *image,
- int x, int y, int width,
- uint32_t *buffer,
- uint32_t *mask, uint32_t maskBits)
+conical_gradient_get_scanline_32 (pixman_image_t *image, int x, int y,
+ int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t maskBits)
{
source_image_t *source = (source_image_t *)image;
gradient_t *gradient = (gradient_t *)source;
diff --git a/pixman/pixman-image.c b/pixman/pixman-image.c
index 8793eca..32b83d3 100644
--- a/pixman/pixman-image.c
+++ b/pixman/pixman-image.c
@@ -63,10 +63,9 @@ _pixman_init_gradient (gradient_t *gradient,
* depth, but that's a project for the future.
*/
void
-_pixman_image_get_scanline_64_generic (pixman_image_t * pict,
- int x, int y, int width,
- uint32_t *buffer,
- uint32_t *mask, uint32_t maskBits)
+_pixman_image_get_scanline_64_generic (pixman_image_t * pict, int x, int y,
+ int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t maskBits)
{
uint32_t *mask8 = NULL;
@@ -136,8 +135,8 @@ _pixman_image_classify (pixman_image_t *image,
}
void
-_pixman_image_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
- uint32_t *buffer, uint32_t *mask, uint32_t mask_bits)
+_pixman_image_get_scanline_32 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
image->common.get_scanline_32 (image, x, y, width, buffer, mask, mask_bits);
}
@@ -146,8 +145,8 @@ _pixman_image_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
* a uint64_t *buffer.
*/
void
-_pixman_image_get_scanline_64 (pixman_image_t *image, int x, int y, int width,
- uint32_t *buffer, uint32_t *unused, uint32_t unused2)
+_pixman_image_get_scanline_64 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *unused, uint32_t unused2)
{
image->common.get_scanline_64 (image, x, y, width, buffer, unused, unused2);
}
diff --git a/pixman/pixman-linear-gradient.c b/pixman/pixman-linear-gradient.c
index 3e76b4d..f01c62c 100644
--- a/pixman/pixman-linear-gradient.c
+++ b/pixman/pixman-linear-gradient.c
@@ -88,8 +88,8 @@ linear_gradient_classify (pixman_image_t *image,
}
static void
-linear_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
- uint32_t *buffer, uint32_t *mask, uint32_t maskBits)
+linear_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t maskBits)
{
pixman_vector_t v, unit;
pixman_fixed_32_32_t l;
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index b62bfa2..cd5b97a 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -39,7 +39,7 @@ typedef void (*store_scanline_t) (bits_image_t *image,
typedef void (*scanFetchProc) (pixman_image_t *,
int, int, int, uint32_t *,
- uint32_t *, uint32_t);
+ const uint32_t *, uint32_t);
typedef enum
{
@@ -205,7 +205,7 @@ _pixman_image_get_scanline_64_generic (pixman_image_t *pict,
int y,
int width,
uint32_t *buffer,
- uint32_t *mask,
+ const uint32_t *mask,
uint32_t maskBits);
source_pict_class_t
@@ -216,17 +216,15 @@ _pixman_image_classify (pixman_image_t *image,
int height);
void
-_pixman_image_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
- uint32_t *buffer, uint32_t *mask,
- uint32_t mask_bits);
+_pixman_image_get_scanline_32 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits);
/* Even thought the type of buffer is uint32_t *, the function actually expects
* a uint64_t *buffer.
*/
void
-_pixman_image_get_scanline_64 (pixman_image_t *image, int x, int y, int width,
- uint32_t *buffer,
- uint32_t *unused, uint32_t unused2);
+_pixman_image_get_scanline_64 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *unused, uint32_t unused2);
void
_pixman_image_store_scanline_32 (bits_image_t *image, int x, int y, int width,
diff --git a/pixman/pixman-radial-gradient.c b/pixman/pixman-radial-gradient.c
index 80ac64d..00fdae0 100644
--- a/pixman/pixman-radial-gradient.c
+++ b/pixman/pixman-radial-gradient.c
@@ -32,8 +32,8 @@
#include "pixman-private.h"
static void
-radial_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
- uint32_t *buffer, uint32_t *mask, uint32_t maskBits)
+radial_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t maskBits)
{
/*
* In the radial gradient problem we are given two circles (câ‚,râ‚) and
diff --git a/pixman/pixman-solid-fill.c b/pixman/pixman-solid-fill.c
index 284b6d3..0801267 100644
--- a/pixman/pixman-solid-fill.c
+++ b/pixman/pixman-solid-fill.c
@@ -25,8 +25,8 @@
#include "pixman-private.h"
static void
-solid_fill_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
- uint32_t *buffer, uint32_t *mask, uint32_t maskBits)
+solid_fill_get_scanline_32 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t maskBits)
{
uint32_t *end = buffer + width;
register uint32_t color = ((solid_fill_t *)image)->color;
commit 5cfdee917d3cac38b103f7453c5a8a0047b95337
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 21:22:06 2009 -0400
Add a mask and mask_bits argument to the raw scanline fetchers.
diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c
index 1382488..491f224 100644
--- a/pixman/pixman-access.c
+++ b/pixman/pixman-access.c
@@ -79,7 +79,8 @@
/*********************************** Fetch ************************************/
static void
-fbFetch_a8r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a8r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
MEMCPY_WRAPPED(pict,
@@ -88,7 +89,8 @@ fbFetch_a8r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_x8r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_x8r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint32_t *pixel = (const uint32_t *)bits + x;
@@ -99,7 +101,8 @@ fbFetch_x8r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
@@ -113,7 +116,8 @@ fbFetch_a8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_x8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_x8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
@@ -128,7 +132,8 @@ fbFetch_x8b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_b8g8r8a8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_b8g8r8a8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
@@ -143,7 +148,8 @@ fbFetch_b8g8r8a8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_b8g8r8x8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_b8g8r8x8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
@@ -159,7 +165,8 @@ fbFetch_b8g8r8x8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
/* Expects a uint64_t buffer */
static void
-fbFetch_a2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b)
+fbFetch_a2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint32_t *pixel = bits + x;
@@ -188,7 +195,8 @@ fbFetch_a2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b)
/* Expects a uint64_t buffer */
static void
-fbFetch_x2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b)
+fbFetch_x2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
@@ -210,7 +218,8 @@ fbFetch_x2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b)
}
static void
-fbFetch_r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint8_t *pixel = (const uint8_t *)bits + 3*x;
@@ -231,7 +240,8 @@ fbFetch_r8g8b8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint8_t *pixel = (const uint8_t *)bits + 3*x;
@@ -252,7 +262,8 @@ fbFetch_b8g8r8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_r5g6b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_r5g6b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
@@ -269,7 +280,8 @@ fbFetch_r5g6b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_b5g6r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_b5g6r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -285,7 +297,8 @@ fbFetch_b5g6r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b, a;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -303,7 +316,8 @@ fbFetch_a1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_x1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_x1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -320,7 +334,8 @@ fbFetch_x1r5g5b5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b, a;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -338,7 +353,8 @@ fbFetch_a1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_x1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_x1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -355,7 +371,8 @@ fbFetch_x1b5g5r5 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b, a;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -373,7 +390,8 @@ fbFetch_a4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_x4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_x4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -390,7 +408,8 @@ fbFetch_x4r4g4b4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b, a;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -408,7 +427,8 @@ fbFetch_a4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_x4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_x4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -425,7 +445,8 @@ fbFetch_x4b4g4r4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
@@ -436,7 +457,8 @@ fbFetch_a8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_r3g3b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_r3g3b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -456,7 +478,8 @@ fbFetch_r3g3b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_b2g3r3 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_b2g3r3 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -478,7 +501,8 @@ fbFetch_b2g3r3 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a2r2g2b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a2r2g2b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t a,r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -496,7 +520,8 @@ fbFetch_a2r2g2b2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a2b2g2r2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a2b2g2r2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t a,r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -514,7 +539,8 @@ fbFetch_a2b2g2r2 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_c8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_c8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const pixman_indexed_t * indexed = pict->indexed;
@@ -527,7 +553,8 @@ fbFetch_c8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_x4a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_x4a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
@@ -546,7 +573,8 @@ fbFetch_x4a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
#endif
static void
-fbFetch_a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
int i;
@@ -559,7 +587,8 @@ fbFetch_a4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_r1g2b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_r1g2b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -575,7 +604,8 @@ fbFetch_r1g2b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_b1g2r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_b1g2r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -591,7 +621,8 @@ fbFetch_b1g2r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a1r1g1b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a1r1g1b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t a,r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -608,7 +639,8 @@ fbFetch_a1r1g1b1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_a1b1g1r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a1b1g1r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
uint32_t a,r,g,b;
const uint32_t *bits = pict->bits + y*pict->rowstride;
@@ -625,7 +657,8 @@ fbFetch_a1b1g1r1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_c4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_c4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const pixman_indexed_t * indexed = pict->indexed;
@@ -639,7 +672,8 @@ fbFetch_c4 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
static void
-fbFetch_a1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_a1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
int i;
@@ -660,7 +694,8 @@ fbFetch_a1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_g1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch_g1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const pixman_indexed_t * indexed = pict->indexed;
@@ -679,7 +714,8 @@ fbFetch_g1 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
static void
-fbFetch_yuy2 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer)
+fbFetch_yuy2 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
int16_t y, u, v;
int32_t r, g, b;
@@ -708,7 +744,8 @@ fbFetch_yuy2 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer)
}
static void
-fbFetch_yv12 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer)
+fbFetch_yv12 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
YV12_SETUP(pict);
uint8_t *pY = YV12_Y (line);
@@ -2458,14 +2495,15 @@ fbStore64_generic (bits_image_t *image, int x, int y, int width, const uint32_t
free(argb8Pixels);
}
-/* Despite the type, this function expects a uint64_t buffer */
+/* Despite the type, this function expects both buffer and mask to be uint64_t */
static void
-fbFetch64_generic (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
+fbFetch64_generic (bits_image_t *pict, int x, int y, int width, uint32_t *buffer,
+ const uint32_t *mask, uint32_t mask_bits)
{
/* Fetch the pixels into the first half of buffer and then expand them in
* place.
*/
- pict->fetch_scanline_raw_32 (pict, x, y, width, buffer);
+ pict->fetch_scanline_raw_32 (pict, x, y, width, buffer, NULL, 0);
pixman_expand ((uint64_t *)buffer, buffer, pict->format, width);
}
diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c
index 17afb4a..e267962 100644
--- a/pixman/pixman-bits-image.c
+++ b/pixman/pixman-bits-image.c
@@ -656,9 +656,9 @@ bits_image_fetch_untransformed_repeat_none (bits_image_t *image, pixman_bool_t w
w = MIN (width, image->width - x);
if (wide)
- image->fetch_scanline_raw_64 (image, x, y, w, buffer);
+ image->fetch_scanline_raw_64 (image, x, y, w, buffer, NULL, 0);
else
- image->fetch_scanline_raw_32 (image, x, y, w, buffer);
+ image->fetch_scanline_raw_32 (image, x, y, w, buffer, NULL, 0);
width -= w;
buffer += w;
@@ -690,9 +690,9 @@ bits_image_fetch_untransformed_repeat_normal (bits_image_t *image, pixman_bool_t
w = MIN (width, image->width - x);
if (wide)
- image->fetch_scanline_raw_64 (image, x, y, w, buffer);
+ image->fetch_scanline_raw_64 (image, x, y, w, buffer, NULL, 0);
else
- image->fetch_scanline_raw_32 (image, x, y, w, buffer);
+ image->fetch_scanline_raw_32 (image, x, y, w, buffer, NULL, 0);
buffer += w;
x += w;
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index 48f9e44..b62bfa2 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -28,7 +28,9 @@ typedef struct circle circle_t;
typedef void (*fetch_scanline_t) (bits_image_t *pict,
int x, int y, int width,
- uint32_t *buffer);
+ uint32_t *buffer,
+ const uint32_t *mask,
+ uint32_t mask_bits);
typedef void (*fetch_pixels_t) (bits_image_t *image,
uint32_t *buffer, int n_pixels);
typedef void (*store_scanline_t) (bits_image_t *image,
commit d3bebaf731b4e1714653b50a4a861171f497b42f
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 21:10:52 2009 -0400
Rename fetchProc32 to fetch_scanline_t and fetch_pixels_32_t to fetch_pixels_t
diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c
index dc1c29c..1382488 100644
--- a/pixman/pixman-access.c
+++ b/pixman/pixman-access.c
@@ -2499,10 +2499,10 @@ fbFetchPixel32_generic_lossy (bits_image_t *pict, uint32_t *buffer, int n_pixels
typedef struct
{
pixman_format_code_t format;
- fetchProc32 fetch_scanline_raw_32;
- fetchProc32 fetch_scanline_raw_64;
- fetch_pixels_32_t fetch_pixels_raw_32;
- fetch_pixels_32_t fetch_pixels_raw_64;
+ fetch_scanline_t fetch_scanline_raw_32;
+ fetch_scanline_t fetch_scanline_raw_64;
+ fetch_pixels_t fetch_pixels_raw_32;
+ fetch_pixels_t fetch_pixels_raw_64;
store_scanline_t store_scanline_raw_32;
store_scanline_t store_scanline_raw_64;
} format_info_t;
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index 889493b..48f9e44 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -26,14 +26,15 @@ typedef struct radial_gradient radial_gradient_t;
typedef struct bits_image bits_image_t;
typedef struct circle circle_t;
+typedef void (*fetch_scanline_t) (bits_image_t *pict,
+ int x, int y, int width,
+ uint32_t *buffer);
+typedef void (*fetch_pixels_t) (bits_image_t *image,
+ uint32_t *buffer, int n_pixels);
typedef void (*store_scanline_t) (bits_image_t *image,
int x, int y, int width,
const uint32_t *values);
-typedef void (*fetchProc32) (bits_image_t *pict,
- int x, int y, int width,
- uint32_t *buffer);
-typedef void (*fetch_pixels_32_t) (bits_image_t *image,
- uint32_t *buffer, int n_pixels);
+
typedef void (*scanFetchProc) (pixman_image_t *,
int, int, int, uint32_t *,
uint32_t *, uint32_t);
@@ -159,12 +160,12 @@ struct bits_image
int rowstride; /* in number of uint32_t's */
/* Fetch raw pixels, with no regard for transformations, alpha map etc. */
- fetch_pixels_32_t fetch_pixels_raw_32;
- fetch_pixels_32_t fetch_pixels_raw_64;
+ fetch_pixels_t fetch_pixels_raw_32;
+ fetch_pixels_t fetch_pixels_raw_64;
/* Fetch raw scanlines, with no regard for transformations, alpha maps etc. */
- fetchProc32 fetch_scanline_raw_32;
- fetchProc32 fetch_scanline_raw_64;
+ fetch_scanline_t fetch_scanline_raw_32;
+ fetch_scanline_t fetch_scanline_raw_64;
/* Store scanlines with no regard for alpha maps */
store_scanline_t store_scanline_raw_32;
commit 6af8672c69b770ce229bd1d156f1fe70d74800f9
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 20:58:39 2009 -0400
Get rid of the 64 bit fetcher types.
It's simpler to just declare everything as 32 bit fetchers and do the
conversion in the few functions that actually need to know the size of
the pixel type.
diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c
index 06be966..dc1c29c 100644
--- a/pixman/pixman-access.c
+++ b/pixman/pixman-access.c
@@ -157,12 +157,15 @@ fbFetch_b8g8r8x8 (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
}
}
+/* Expects a uint64_t buffer */
static void
-fbFetch_a2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint64_t *buffer)
+fbFetch_a2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint32_t *pixel = bits + x;
const uint32_t *end = pixel + width;
+ uint64_t *buffer = (uint64_t *)b;
+
while (pixel < end) {
uint32_t p = READ(pict, pixel++);
uint64_t a = p >> 30;
@@ -183,12 +186,15 @@ fbFetch_a2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint64_t *buff
}
}
+/* Expects a uint64_t buffer */
static void
-fbFetch_x2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint64_t *buffer)
+fbFetch_x2b10g10r10 (bits_image_t *pict, int x, int y, int width, uint32_t *b)
{
const uint32_t *bits = pict->bits + y*pict->rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
const uint32_t *end = pixel + width;
+ uint64_t *buffer = (uint64_t *)b;
+
while (pixel < end) {
uint32_t p = READ(pict, pixel++);
uint64_t b = (p >> 20) & 0x3ff;
@@ -734,10 +740,12 @@ fbFetch_yv12 (bits_image_t *pict, int x, int line, int width, uint32_t *buffer)
/**************************** Pixel wise fetching *****************************/
+/* Despite the type, expects a uint64_t buffer */
static void
-fbFetchPixel_a2b10g10r10 (bits_image_t *pict, uint64_t *buffer, int n_pixels)
+fbFetchPixel_a2b10g10r10_64 (bits_image_t *pict, uint32_t *b, int n_pixels)
{
int i;
+ uint64_t *buffer = (uint64_t *)b;
for (i = 0; i < n_pixels; ++i)
{
@@ -771,9 +779,11 @@ fbFetchPixel_a2b10g10r10 (bits_image_t *pict, uint64_t *buffer, int n_pixels)
}
}
+/* Despite the type, this function expects a uint64_t buffer */
static void
-fbFetchPixel_x2b10g10r10 (bits_image_t *pict, uint64_t *buffer, int n_pixels)
+fbFetchPixel_x2b10g10r10_64 (bits_image_t *pict, uint32_t *b, int n_pixels)
{
+ uint64_t *buffer = (uint64_t *)b;
int i;
for (i = 0; i < n_pixels; ++i)
@@ -2448,23 +2458,25 @@ fbStore64_generic (bits_image_t *image, int x, int y, int width, const uint32_t
free(argb8Pixels);
}
+/* Despite the type, this function expects a uint64_t buffer */
static void
-fbFetch64_generic (bits_image_t *pict, int x, int y, int width, uint64_t *buffer)
+fbFetch64_generic (bits_image_t *pict, int x, int y, int width, uint32_t *buffer)
{
/* Fetch the pixels into the first half of buffer and then expand them in
* place.
*/
- pict->fetch_scanline_raw_32 (pict, x, y, width, (uint32_t*)buffer);
+ pict->fetch_scanline_raw_32 (pict, x, y, width, buffer);
- pixman_expand (buffer, (uint32_t*)buffer, pict->format, width);
+ pixman_expand ((uint64_t *)buffer, buffer, pict->format, width);
}
+/* Despite the type, this function expects a uint64_t *buffer */
static void
-fbFetchPixel64_generic (bits_image_t *pict, uint64_t *buffer, int n_pixels)
+fbFetchPixel64_generic (bits_image_t *pict, uint32_t *buffer, int n_pixels)
{
- pict->fetch_pixels_raw_32 (pict, (uint32_t *)buffer, n_pixels);
+ pict->fetch_pixels_raw_32 (pict, buffer, n_pixels);
- pixman_expand (buffer, (uint32_t *)buffer, pict->format, n_pixels);
+ pixman_expand ((uint64_t *)buffer, buffer, pict->format, n_pixels);
}
/*
@@ -2477,9 +2489,9 @@ static void
fbFetchPixel32_generic_lossy (bits_image_t *pict, uint32_t *buffer, int n_pixels)
{
/* Since buffer contains n_pixels coordinate pairs, it also has enough room for
- * n_pixels 64 bit pixels
+ * n_pixels 64 bit pixels.
*/
- pict->fetch_pixels_raw_64 (pict, (uint64_t *)buffer, n_pixels);
+ pict->fetch_pixels_raw_64 (pict, buffer, n_pixels);
pixman_contract (buffer, (uint64_t *)buffer, n_pixels);
}
@@ -2488,9 +2500,9 @@ typedef struct
{
pixman_format_code_t format;
fetchProc32 fetch_scanline_raw_32;
- fetchProc64 fetch_scanline_raw_64;
+ fetchProc32 fetch_scanline_raw_64;
fetch_pixels_32_t fetch_pixels_raw_32;
- fetch_pixels_64_t fetch_pixels_raw_64;
+ fetch_pixels_32_t fetch_pixels_raw_64;
store_scanline_t store_scanline_raw_32;
store_scanline_t store_scanline_raw_64;
} format_info_t;
@@ -2575,12 +2587,12 @@ static const format_info_t accessors[] =
{ PIXMAN_a2b10g10r10,
NULL, fbFetch_a2b10g10r10,
- fbFetchPixel32_generic_lossy, fbFetchPixel_a2b10g10r10,
+ fbFetchPixel32_generic_lossy, fbFetchPixel_a2b10g10r10_64,
NULL, fbStore_a2b10g10r10 },
{ PIXMAN_x2b10g10r10,
NULL, fbFetch_x2b10g10r10,
- fbFetchPixel32_generic_lossy, fbFetchPixel_x2b10g10r10,
+ fbFetchPixel32_generic_lossy, fbFetchPixel_x2b10g10r10_64,
NULL, fbStore_x2b10g10r10 },
/* YUV formats */
diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c
index 09491c8..17afb4a 100644
--- a/pixman/pixman-bits-image.c
+++ b/pixman/pixman-bits-image.c
@@ -620,7 +620,7 @@ bits_image_fetch_solid_64 (pixman_image_t * image,
coords[0] = 0;
coords[1] = 1;
- image->bits.fetch_pixels_raw_64 (&image->bits, (uint64_t *)color, 1);
+ image->bits.fetch_pixels_raw_64 (&image->bits, color, 1);
end = buffer + width;
while (buffer < end)
@@ -656,7 +656,7 @@ bits_image_fetch_untransformed_repeat_none (bits_image_t *image, pixman_bool_t w
w = MIN (width, image->width - x);
if (wide)
- image->fetch_scanline_raw_64 (image, x, y, w, (uint64_t *)buffer);
+ image->fetch_scanline_raw_64 (image, x, y, w, buffer);
else
image->fetch_scanline_raw_32 (image, x, y, w, buffer);
@@ -690,7 +690,7 @@ bits_image_fetch_untransformed_repeat_normal (bits_image_t *image, pixman_bool_t
w = MIN (width, image->width - x);
if (wide)
- image->fetch_scanline_raw_64 (image, x, y, w, (uint64_t *)buffer);
+ image->fetch_scanline_raw_64 (image, x, y, w, buffer);
else
image->fetch_scanline_raw_32 (image, x, y, w, buffer);
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index 6c8177e..889493b 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -32,13 +32,8 @@ typedef void (*store_scanline_t) (bits_image_t *image,
typedef void (*fetchProc32) (bits_image_t *pict,
int x, int y, int width,
uint32_t *buffer);
-typedef void (*fetchProc64) (bits_image_t *pict,
- int x, int y, int width,
- uint64_t *buffer);
typedef void (*fetch_pixels_32_t) (bits_image_t *image,
uint32_t *buffer, int n_pixels);
-typedef void (*fetch_pixels_64_t) (bits_image_t *image,
- uint64_t *buffer, int n_pixels);
typedef void (*scanFetchProc) (pixman_image_t *,
int, int, int, uint32_t *,
uint32_t *, uint32_t);
@@ -165,11 +160,11 @@ struct bits_image
/* Fetch raw pixels, with no regard for transformations, alpha map etc. */
fetch_pixels_32_t fetch_pixels_raw_32;
- fetch_pixels_64_t fetch_pixels_raw_64;
+ fetch_pixels_32_t fetch_pixels_raw_64;
/* Fetch raw scanlines, with no regard for transformations, alpha maps etc. */
fetchProc32 fetch_scanline_raw_32;
- fetchProc64 fetch_scanline_raw_64;
+ fetchProc32 fetch_scanline_raw_64;
/* Store scanlines with no regard for alpha maps */
store_scanline_t store_scanline_raw_32;
commit 70cba5cfa8a5d702c32170c511a7318766e45731
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 20:38:58 2009 -0400
Consolidate the three scanline store types into one.
The 64 bit storers do their own type conversion.
diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c
index 51dd5ef..06be966 100644
--- a/pixman/pixman-access.c
+++ b/pixman/pixman-access.c
@@ -1810,12 +1810,13 @@ fbFetchPixel_yv12 (bits_image_t *pict, uint32_t *buffer, int n_pixels)
#define Split(v) uint32_t r = ((v) >> 16) & 0xff, g = ((v) >> 8) & 0xff, b = (v) & 0xff
static void
-fbStore_a2b10g10r10 (pixman_image_t *image,
- uint32_t *bits, const uint64_t *values,
- int x, int width)
+fbStore_a2b10g10r10 (bits_image_t *image, int x, int y, int width, const uint32_t *v)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint32_t *pixel = bits + x;
+ uint64_t *values = (uint64_t *)v;
+ int i;
+
for (i = 0; i < width; ++i) {
WRITE(image, pixel++,
((values[i] >> 32) & 0xc0000000) | // A
@@ -1826,11 +1827,13 @@ fbStore_a2b10g10r10 (pixman_image_t *image,
}
static void
-fbStore_x2b10g10r10 (pixman_image_t *image,
- uint32_t *bits, const uint64_t *values, int x, int width)
+fbStore_x2b10g10r10 (bits_image_t *image, int x, int y, int width, const uint32_t *v)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
+ uint64_t *values = (uint64_t *)v;
uint32_t *pixel = bits + x;
+ int i;
+
for (i = 0; i < width; ++i) {
WRITE(image, pixel++,
((values[i] >> 38) & 0x3ff) | // R
@@ -1840,48 +1843,63 @@ fbStore_x2b10g10r10 (pixman_image_t *image,
}
static void
-fbStore_a8r8g8b8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a8r8g8b8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
+ uint32_t *bits = image->bits + image->rowstride * y;
+
MEMCPY_WRAPPED(image, ((uint32_t *)bits) + x, values, width*sizeof(uint32_t));
}
static void
-fbStore_x8r8g8b8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_x8r8g8b8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint32_t *pixel = (uint32_t *)bits + x;
+ int i;
+
for (i = 0; i < width; ++i)
WRITE(image, pixel++, values[i] & 0xffffff);
}
static void
-fbStore_a8b8g8r8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a8b8g8r8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint32_t *pixel = (uint32_t *)bits + x;
+ int i;
+
for (i = 0; i < width; ++i)
WRITE(image, pixel++, (values[i] & 0xff00ff00) | ((values[i] >> 16) & 0xff) | ((values[i] & 0xff) << 16));
}
static void
-fbStore_x8b8g8r8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_x8b8g8r8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint32_t *pixel = (uint32_t *)bits + x;
+ int i;
+
for (i = 0; i < width; ++i)
WRITE(image, pixel++, (values[i] & 0x0000ff00) | ((values[i] >> 16) & 0xff) | ((values[i] & 0xff) << 16));
}
static void
-fbStore_b8g8r8a8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_b8g8r8a8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint32_t *pixel = (uint32_t *)bits + x;
+ int i;
+
for (i = 0; i < width; ++i)
WRITE(image, pixel++,
((values[i] >> 24) & 0x000000ff) |
@@ -1891,11 +1909,14 @@ fbStore_b8g8r8a8 (pixman_image_t *image,
}
static void
-fbStore_b8g8r8x8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_b8g8r8x8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint32_t *pixel = (uint32_t *)bits + x;
+ int i;
+
for (i = 0; i < width; ++i)
WRITE(image, pixel++,
((values[i] >> 8) & 0x0000ff00) |
@@ -1904,11 +1925,14 @@ fbStore_b8g8r8x8 (pixman_image_t *image,
}
static void
-fbStore_r8g8b8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_r8g8b8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint8_t *pixel = ((uint8_t *) bits) + 3*x;
+ int i;
+
for (i = 0; i < width; ++i)
{
uint32_t val = values[i];
@@ -1925,11 +1949,14 @@ fbStore_r8g8b8 (pixman_image_t *image,
}
static void
-fbStore_b8g8r8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_b8g8r8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint8_t *pixel = ((uint8_t *) bits) + 3*x;
+ int i;
+
for (i = 0; i < width; ++i)
{
uint32_t val = values[i];
@@ -1946,11 +1973,14 @@ fbStore_b8g8r8 (pixman_image_t *image,
}
static void
-fbStore_r5g6b5 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_r5g6b5 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
uint32_t s = values[i];
WRITE(image, pixel++, ((s >> 3) & 0x001f) |
@@ -1960,11 +1990,14 @@ fbStore_r5g6b5 (pixman_image_t *image,
}
static void
-fbStore_b5g6r5 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_b5g6r5 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Split(values[i]);
WRITE(image, pixel++, ((b << 8) & 0xf800) |
@@ -1974,11 +2007,14 @@ fbStore_b5g6r5 (pixman_image_t *image,
}
static void
-fbStore_a1r5g5b5 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a1r5g5b5 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Splita(values[i]);
WRITE(image, pixel++, ((a << 8) & 0x8000) |
@@ -1989,11 +2025,14 @@ fbStore_a1r5g5b5 (pixman_image_t *image,
}
static void
-fbStore_x1r5g5b5 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_x1r5g5b5 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Split(values[i]);
WRITE(image, pixel++, ((r << 7) & 0x7c00) |
@@ -2003,11 +2042,14 @@ fbStore_x1r5g5b5 (pixman_image_t *image,
}
static void
-fbStore_a1b5g5r5 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a1b5g5r5 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Splita(values[i]);
WRITE(image, pixel++, ((a << 8) & 0x8000) |
@@ -2018,11 +2060,14 @@ fbStore_a1b5g5r5 (pixman_image_t *image,
}
static void
-fbStore_x1b5g5r5 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_x1b5g5r5 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Split(values[i]);
WRITE(image, pixel++, ((b << 7) & 0x7c00) |
@@ -2032,11 +2077,14 @@ fbStore_x1b5g5r5 (pixman_image_t *image,
}
static void
-fbStore_a4r4g4b4 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a4r4g4b4 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Splita(values[i]);
WRITE(image, pixel++, ((a << 8) & 0xf000) |
@@ -2047,11 +2095,14 @@ fbStore_a4r4g4b4 (pixman_image_t *image,
}
static void
-fbStore_x4r4g4b4 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_x4r4g4b4 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Split(values[i]);
WRITE(image, pixel++, ((r << 4) & 0x0f00) |
@@ -2061,11 +2112,14 @@ fbStore_x4r4g4b4 (pixman_image_t *image,
}
static void
-fbStore_a4b4g4r4 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a4b4g4r4 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Splita(values[i]);
WRITE(image, pixel++, ((a << 8) & 0xf000) |
@@ -2076,11 +2130,14 @@ fbStore_a4b4g4r4 (pixman_image_t *image,
}
static void
-fbStore_x4b4g4r4 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_x4b4g4r4 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint16_t *pixel = ((uint16_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Split(values[i]);
WRITE(image, pixel++, ((b << 4) & 0x0f00) |
@@ -2090,22 +2147,28 @@ fbStore_x4b4g4r4 (pixman_image_t *image,
}
static void
-fbStore_a8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint8_t *pixel = ((uint8_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
WRITE(image, pixel++, values[i] >> 24);
}
}
static void
-fbStore_r3g3b2 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_r3g3b2 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint8_t *pixel = ((uint8_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Split(values[i]);
WRITE(image, pixel++,
@@ -2116,11 +2179,14 @@ fbStore_r3g3b2 (pixman_image_t *image,
}
static void
-fbStore_b2g3r3 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_b2g3r3 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint8_t *pixel = ((uint8_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Split(values[i]);
WRITE(image, pixel++,
@@ -2131,11 +2197,14 @@ fbStore_b2g3r3 (pixman_image_t *image,
}
static void
-fbStore_a2r2g2b2 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a2r2g2b2 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint8_t *pixel = ((uint8_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Splita(values[i]);
WRITE(image, pixel++, ((a ) & 0xc0) |
@@ -2146,11 +2215,14 @@ fbStore_a2r2g2b2 (pixman_image_t *image,
}
static void
-fbStore_a2b2g2r2 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a2b2g2r2 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint8_t *pixel = ((uint8_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
Splita(values[i]);
*(pixel++) = ((a ) & 0xc0) |
@@ -2161,23 +2233,29 @@ fbStore_a2b2g2r2 (pixman_image_t *image,
}
static void
-fbStore_c8 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_c8 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- const pixman_indexed_t *indexed = image->bits.indexed;
+ uint32_t *bits = image->bits + image->rowstride * y;
+ uint8_t *pixel = ((uint8_t *) bits) + x;
+ const pixman_indexed_t *indexed = image->indexed;
int i;
- uint8_t *pixel = ((uint8_t *) bits) + x;
+
for (i = 0; i < width; ++i) {
WRITE(image, pixel++, miIndexToEnt24(indexed,values[i]));
}
}
static void
-fbStore_x4a4 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_x4a4 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- int i;
+ uint32_t *bits = image->bits + image->rowstride * y;
uint8_t *pixel = ((uint8_t *) bits) + x;
+ int i;
+
for (i = 0; i < width; ++i) {
WRITE(image, pixel++, values[i] >> 28);
}
@@ -2195,20 +2273,26 @@ fbStore_x4a4 (pixman_image_t *image,
#endif
static void
-fbStore_a4 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a4 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
+ uint32_t *bits = image->bits + image->rowstride * y;
int i;
+
for (i = 0; i < width; ++i) {
Store4(image, bits, i + x, values[i]>>28);
}
}
static void
-fbStore_r1g2b1 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_r1g2b1 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
+ uint32_t *bits = image->bits + image->rowstride * y;
int i;
+
for (i = 0; i < width; ++i) {
uint32_t pixel;
@@ -2221,10 +2305,13 @@ fbStore_r1g2b1 (pixman_image_t *image,
}
static void
-fbStore_b1g2r1 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_b1g2r1 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
+ uint32_t *bits = image->bits + image->rowstride * y;
int i;
+
for (i = 0; i < width; ++i) {
uint32_t pixel;
@@ -2237,10 +2324,13 @@ fbStore_b1g2r1 (pixman_image_t *image,
}
static void
-fbStore_a1r1g1b1 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a1r1g1b1 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
+ uint32_t *bits = image->bits + image->rowstride * y;
int i;
+
for (i = 0; i < width; ++i) {
uint32_t pixel;
Splita(values[i]);
@@ -2253,10 +2343,13 @@ fbStore_a1r1g1b1 (pixman_image_t *image,
}
static void
-fbStore_a1b1g1r1 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a1b1g1r1 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
+ uint32_t *bits = image->bits + image->rowstride * y;
int i;
+
for (i = 0; i < width; ++i) {
uint32_t pixel;
Splita(values[i]);
@@ -2269,11 +2362,14 @@ fbStore_a1b1g1r1 (pixman_image_t *image,
}
static void
-fbStore_c4 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_c4 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- const pixman_indexed_t *indexed = image->bits.indexed;
+ uint32_t *bits = image->bits + image->rowstride * y;
+ const pixman_indexed_t *indexed = image->indexed;
int i;
+
for (i = 0; i < width; ++i) {
uint32_t pixel;
@@ -2283,10 +2379,13 @@ fbStore_c4 (pixman_image_t *image,
}
static void
-fbStore_a1 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_a1 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
+ uint32_t *bits = image->bits + image->rowstride * y;
int i;
+
for (i = 0; i < width; ++i)
{
uint32_t *pixel = ((uint32_t *) bits) + ((i+x) >> 5);
@@ -2302,11 +2401,14 @@ fbStore_a1 (pixman_image_t *image,
}
static void
-fbStore_g1 (pixman_image_t *image,
- uint32_t *bits, const uint32_t *values, int x, int width)
+fbStore_g1 (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values)
{
- const pixman_indexed_t *indexed = image->bits.indexed;
+ uint32_t *bits = image->bits + image->rowstride * y;
+ const pixman_indexed_t *indexed = image->indexed;
int i;
+
for (i = 0; i < width; ++i)
{
uint32_t *pixel = ((uint32_t *) bits) + ((i+x) >> 5);
@@ -2323,11 +2425,10 @@ fbStore_g1 (pixman_image_t *image,
/*
* Contracts a 64bpp image to 32bpp and then stores it using a regular 32-bit
- * store proc.
+ * store proc. Despite the type, this function expects a uint64_t buffer.
*/
static void
-fbStore64_generic (pixman_image_t *image,
- uint32_t *bits, const uint64_t *values, int x, int width)
+fbStore64_generic (bits_image_t *image, int x, int y, int width, const uint32_t *values)
{
uint32_t *argb8Pixels;
@@ -2340,9 +2441,9 @@ fbStore64_generic (pixman_image_t *image,
/* Contract the scanline. We could do this in place if values weren't
* const.
*/
- pixman_contract(argb8Pixels, values, width);
+ pixman_contract(argb8Pixels, (uint64_t *)values, width);
- image->bits.store_scanline_raw_32 (image, bits, argb8Pixels, x, width);
+ image->store_scanline_raw_32 (image, x, y, width, argb8Pixels);
free(argb8Pixels);
}
@@ -2390,8 +2491,8 @@ typedef struct
fetchProc64 fetch_scanline_raw_64;
fetch_pixels_32_t fetch_pixels_raw_32;
fetch_pixels_64_t fetch_pixels_raw_64;
- storeProc32 store_scanline_raw_32;
- storeProc64 store_scanline_raw_64;
+ store_scanline_t store_scanline_raw_32;
+ store_scanline_t store_scanline_raw_64;
} format_info_t;
#define FORMAT_INFO(format) \
diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c
index 5ea2143..09491c8 100644
--- a/pixman/pixman-bits-image.c
+++ b/pixman/pixman-bits-image.c
@@ -40,16 +40,10 @@
static void
bits_image_store_scanline_32 (bits_image_t *image,
int x, int y,
- int width, uint32_t *buffer)
+ int width,
+ const uint32_t *buffer)
{
- uint32_t *bits;
- int32_t stride;
-
- bits = image->bits;
- stride = image->rowstride;
- bits += y*stride;
-
- image->store_scanline_raw_32 ((pixman_image_t *)image, bits, buffer, x, width);
+ image->store_scanline_raw_32 (image, x, y, width, buffer);
if (image->common.alpha_map)
{
@@ -63,17 +57,10 @@ bits_image_store_scanline_32 (bits_image_t *image,
static void
bits_image_store_scanline_64 (bits_image_t *image,
int x, int y,
- int width, uint32_t *buffer)
+ int width,
+ const uint32_t *buffer)
{
- uint32_t *bits;
- int32_t stride;
-
- bits = image->bits;
- stride = image->rowstride;
- bits += y*stride;
-
- image->store_scanline_raw_64 ((pixman_image_t *)image, bits,
- (uint64_t *)buffer, x, width);
+ image->store_scanline_raw_64 (image, x, y, width, buffer);
if (image->common.alpha_map)
{
@@ -86,14 +73,14 @@ bits_image_store_scanline_64 (bits_image_t *image,
void
_pixman_image_store_scanline_32 (bits_image_t *image, int x, int y, int width,
- uint32_t *buffer)
+ const uint32_t *buffer)
{
image->store_scanline_32 (image, x, y, width, buffer);
}
void
_pixman_image_store_scanline_64 (bits_image_t *image, int x, int y, int width,
- uint32_t *buffer)
+ const uint32_t *buffer)
{
image->store_scanline_64 (image, x, y, width, buffer);
}
diff --git a/pixman/pixman-general.c b/pixman/pixman-general.c
index 9c11788..62cb3e4 100644
--- a/pixman/pixman-general.c
+++ b/pixman/pixman-general.c
@@ -67,7 +67,7 @@ general_composite_rect (pixman_implementation_t *imp,
uint8_t *src_buffer, *mask_buffer, *dest_buffer;
scanFetchProc fetchSrc = NULL, fetchMask = NULL, fetchDest = NULL;
pixman_combine_32_func_t compose;
- scanStoreProc store;
+ store_scanline_t store;
source_pict_class_t srcClass, maskClass;
pixman_bool_t component_alpha;
uint32_t *bits;
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index 8942586..6c8177e 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -26,25 +26,19 @@ typedef struct radial_gradient radial_gradient_t;
typedef struct bits_image bits_image_t;
typedef struct circle circle_t;
+typedef void (*store_scanline_t) (bits_image_t *image,
+ int x, int y, int width,
+ const uint32_t *values);
typedef void (*fetchProc32) (bits_image_t *pict,
int x, int y, int width,
uint32_t *buffer);
-typedef void (*storeProc32) (pixman_image_t *, uint32_t *bits,
- const uint32_t *values,
- int x, int width);
typedef void (*fetchProc64) (bits_image_t *pict,
int x, int y, int width,
uint64_t *buffer);
-typedef void (*storeProc64) (pixman_image_t *, uint32_t *bits,
- const uint64_t *values,
- int x, int width);
typedef void (*fetch_pixels_32_t) (bits_image_t *image,
uint32_t *buffer, int n_pixels);
typedef void (*fetch_pixels_64_t) (bits_image_t *image,
uint64_t *buffer, int n_pixels);
-typedef void (*scanStoreProc) (bits_image_t *img,
- int x, int y, int width,
- uint32_t *buffer);
typedef void (*scanFetchProc) (pixman_image_t *,
int, int, int, uint32_t *,
uint32_t *, uint32_t);
@@ -178,12 +172,12 @@ struct bits_image
fetchProc64 fetch_scanline_raw_64;
/* Store scanlines with no regard for alpha maps */
- storeProc32 store_scanline_raw_32;
- storeProc64 store_scanline_raw_64;
+ store_scanline_t store_scanline_raw_32;
+ store_scanline_t store_scanline_raw_64;
/* Store a scanline, taking alpha maps into account */
- scanStoreProc store_scanline_32;
- scanStoreProc store_scanline_64;
+ store_scanline_t store_scanline_32;
+ store_scanline_t store_scanline_64;
/* Used for indirect access to the bits */
pixman_read_memory_func_t read_func;
@@ -238,7 +232,7 @@ _pixman_image_get_scanline_64 (pixman_image_t *image, int x, int y, int width,
void
_pixman_image_store_scanline_32 (bits_image_t *image, int x, int y, int width,
- uint32_t *buffer);
+ const uint32_t *buffer);
void
_pixman_image_fetch_pixels (bits_image_t *image, uint32_t *buffer,
int n_pixels);
@@ -248,7 +242,7 @@ _pixman_image_fetch_pixels (bits_image_t *image, uint32_t *buffer,
*/
void
_pixman_image_store_scanline_64 (bits_image_t *image, int x, int y, int width,
- uint32_t *buffer);
+ const uint32_t *buffer);
pixman_image_t *
_pixman_image_allocate (void);
commit 973ebf1631de695483fcb4b5e4c2b27e037ca3bf
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 19:03:11 2009 -0400
Get rid of remaining scanFetchProc casts
diff --git a/pixman/pixman-linear-gradient.c b/pixman/pixman-linear-gradient.c
index 947c66b..3e76b4d 100644
--- a/pixman/pixman-linear-gradient.c
+++ b/pixman/pixman-linear-gradient.c
@@ -219,8 +219,8 @@ linear_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
static void
linear_gradient_property_changed (pixman_image_t *image)
{
- image->common.get_scanline_32 = (scanFetchProc)linear_gradient_get_scanline_32;
- image->common.get_scanline_64 = (scanFetchProc)_pixman_image_get_scanline_64_generic;
+ image->common.get_scanline_32 = linear_gradient_get_scanline_32;
+ image->common.get_scanline_64 = _pixman_image_get_scanline_64_generic;
}
PIXMAN_EXPORT pixman_image_t *
diff --git a/pixman/pixman-solid-fill.c b/pixman/pixman-solid-fill.c
index 1805600..284b6d3 100644
--- a/pixman/pixman-solid-fill.c
+++ b/pixman/pixman-solid-fill.c
@@ -50,8 +50,8 @@ solid_fill_classify (pixman_image_t *image,
static void
solid_fill_property_changed (pixman_image_t *image)
{
- image->common.get_scanline_32 = (scanFetchProc)solid_fill_get_scanline_32;
- image->common.get_scanline_64 = (scanFetchProc)_pixman_image_get_scanline_64_generic;
+ image->common.get_scanline_32 = solid_fill_get_scanline_32;
+ image->common.get_scanline_64 = _pixman_image_get_scanline_64_generic;
}
static uint32_t
commit 24303475c26dada40474f5972b1abee2315ba8f9
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 19:02:10 2009 -0400
Get rid of scanFetchProc casts in pixman-radial-gradient.c
diff --git a/pixman/pixman-radial-gradient.c b/pixman/pixman-radial-gradient.c
index cb81173..80ac64d 100644
--- a/pixman/pixman-radial-gradient.c
+++ b/pixman/pixman-radial-gradient.c
@@ -272,8 +272,8 @@ radial_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
static void
radial_gradient_property_changed (pixman_image_t *image)
{
- image->common.get_scanline_32 = (scanFetchProc)radial_gradient_get_scanline_32;
- image->common.get_scanline_64 = (scanFetchProc)_pixman_image_get_scanline_64_generic;
+ image->common.get_scanline_32 = radial_gradient_get_scanline_32;
+ image->common.get_scanline_64 = _pixman_image_get_scanline_64_generic;
}
PIXMAN_EXPORT pixman_image_t *
commit 99780d3b2264f6e2bb210d3fdc1237c8fbfc3f25
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 19:00:52 2009 -0400
Get rid of scanFetchProc casts in pixman-conical-gradient.c
diff --git a/pixman/pixman-conical-gradient.c b/pixman/pixman-conical-gradient.c
index ba01509..ea6744f 100644
--- a/pixman/pixman-conical-gradient.c
+++ b/pixman/pixman-conical-gradient.c
@@ -29,8 +29,10 @@
#include "pixman-private.h"
static void
-conical_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
- uint32_t *buffer, uint32_t *mask, uint32_t maskBits)
+conical_gradient_get_scanline_32 (pixman_image_t *image,
+ int x, int y, int width,
+ uint32_t *buffer,
+ uint32_t *mask, uint32_t maskBits)
{
source_image_t *source = (source_image_t *)image;
gradient_t *gradient = (gradient_t *)source;
@@ -121,8 +123,8 @@ conical_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width
static void
conical_gradient_property_changed (pixman_image_t *image)
{
- image->common.get_scanline_32 = (scanFetchProc)conical_gradient_get_scanline_32;
- image->common.get_scanline_64 = (scanFetchProc)_pixman_image_get_scanline_64_generic;
+ image->common.get_scanline_32 = conical_gradient_get_scanline_32;
+ image->common.get_scanline_64 = _pixman_image_get_scanline_64_generic;
}
PIXMAN_EXPORT pixman_image_t *
commit 2d2d3a2625fcc1151f61d0dc1a6ff268d7491be8
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 18:58:39 2009 -0400
Get rid of casts to scanFetchProc in pixman-bits-image.c
Instead just declare the functions with the required type and do any
type conversions in the function itself.
diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c
index e2417b1..5ea2143 100644
--- a/pixman/pixman-bits-image.c
+++ b/pixman/pixman-bits-image.c
@@ -505,8 +505,9 @@ bits_image_fetch_filtered (bits_image_t *pict, uint32_t *buffer, int n_pixels)
}
static void
-bits_image_fetch_transformed (bits_image_t * pict, int x, int y, int width,
- uint32_t *buffer, uint32_t *mask, uint32_t maskBits)
+bits_image_fetch_transformed (pixman_image_t * pict, int x, int y, int width,
+ uint32_t *buffer, uint32_t *mask,
+ uint32_t maskBits)
{
uint32_t *bits;
int32_t stride;
@@ -517,8 +518,8 @@ bits_image_fetch_transformed (bits_image_t * pict, int x, int y, int width,
int32_t *coords;
int i;
- bits = pict->bits;
- stride = pict->rowstride;
+ bits = pict->bits.bits;
+ stride = pict->bits.rowstride;
/* reference point is the center of the pixel */
v.vector[0] = pixman_int_to_fixed(x) + pixman_fixed_1 / 2;
@@ -591,7 +592,7 @@ bits_image_fetch_transformed (bits_image_t * pict, int x, int y, int width,
v.vector[1] += unit.vector[1];
}
- bits_image_fetch_filtered (pict, tmp_buffer, n_pixels);
+ bits_image_fetch_filtered (&pict->bits, tmp_buffer, n_pixels);
for (j = 0; j < n_pixels; ++j)
buffer[i++] = tmp_buffer[j];
@@ -599,7 +600,7 @@ bits_image_fetch_transformed (bits_image_t * pict, int x, int y, int width,
}
static void
-bits_image_fetch_solid_32 (bits_image_t * image,
+bits_image_fetch_solid_32 (pixman_image_t * image,
int x, int y, int width,
uint32_t *buffer,
uint32_t *mask, uint32_t maskBits)
@@ -610,7 +611,7 @@ bits_image_fetch_solid_32 (bits_image_t * image,
color[0] = 0;
color[1] = 0;
- image->fetch_pixels_raw_32 (image, color, 1);
+ image->bits.fetch_pixels_raw_32 (&image->bits, color, 1);
end = buffer + width;
while (buffer < end)
@@ -618,18 +619,21 @@ bits_image_fetch_solid_32 (bits_image_t * image,
}
static void
-bits_image_fetch_solid_64 (bits_image_t * image,
+bits_image_fetch_solid_64 (pixman_image_t * image,
int x, int y, int width,
- uint64_t *buffer, void *unused, uint32_t unused2)
+ uint32_t *b,
+ uint32_t *unused,
+ uint32_t unused2)
{
uint32_t color[2];
- uint64_t *end;
uint32_t *coords = (uint32_t *)color;
-
+ uint64_t *buffer = (uint64_t *)b;
+ uint64_t *end;
+
coords[0] = 0;
coords[1] = 1;
- image->fetch_pixels_raw_64 (image, (uint64_t *)color, 1);
+ image->bits.fetch_pixels_raw_64 (&image->bits, (uint64_t *)color, 1);
end = buffer + width;
while (buffer < end)
@@ -710,30 +714,38 @@ bits_image_fetch_untransformed_repeat_normal (bits_image_t *image, pixman_bool_t
}
static void
-bits_image_fetch_untransformed_32 (bits_image_t * image,
+bits_image_fetch_untransformed_32 (pixman_image_t * image,
int x, int y, int width,
- uint32_t *buffer, uint32_t *mask, uint32_t maskBits)
+ uint32_t *buffer,
+ uint32_t *mask, uint32_t maskBits)
{
if (image->common.repeat == PIXMAN_REPEAT_NONE)
- bits_image_fetch_untransformed_repeat_none (image, FALSE, x, y, width, buffer);
+ {
+ bits_image_fetch_untransformed_repeat_none (
+ &image->bits, FALSE, x, y, width, buffer);
+ }
else
- bits_image_fetch_untransformed_repeat_normal (image, FALSE, x, y, width, buffer);
+ {
+ bits_image_fetch_untransformed_repeat_normal (
+ &image->bits, FALSE, x, y, width, buffer);
+ }
}
static void
-bits_image_fetch_untransformed_64 (bits_image_t * image,
+bits_image_fetch_untransformed_64 (pixman_image_t * image,
int x, int y, int width,
- uint64_t *buffer, void *unused, uint32_t unused2)
+ uint32_t *buffer,
+ uint32_t *unused, uint32_t unused2)
{
if (image->common.repeat == PIXMAN_REPEAT_NONE)
{
- bits_image_fetch_untransformed_repeat_none (image, TRUE, x, y,
- width, (uint32_t *)buffer);
+ bits_image_fetch_untransformed_repeat_none (
+ &image->bits, TRUE, x, y, width, buffer);
}
else
{
- bits_image_fetch_untransformed_repeat_normal (image, TRUE, x, y,
- width, (uint32_t *)buffer);
+ bits_image_fetch_untransformed_repeat_normal (
+ &image->bits, TRUE, x, y, width, buffer);
}
}
@@ -747,16 +759,16 @@ bits_image_property_changed (pixman_image_t *image)
if (bits->common.alpha_map)
{
image->common.get_scanline_64 =
- (scanFetchProc)_pixman_image_get_scanline_64_generic;
+ _pixman_image_get_scanline_64_generic;
image->common.get_scanline_32 =
- (scanFetchProc)bits_image_fetch_transformed;
+ bits_image_fetch_transformed;
}
else if ((bits->common.repeat != PIXMAN_REPEAT_NONE) &&
bits->width == 1 &&
bits->height == 1)
{
- image->common.get_scanline_64 = (scanFetchProc)bits_image_fetch_solid_64;
- image->common.get_scanline_32 = (scanFetchProc)bits_image_fetch_solid_32;
+ image->common.get_scanline_64 = bits_image_fetch_solid_64;
+ image->common.get_scanline_32 = bits_image_fetch_solid_32;
}
else if (!bits->common.transform &&
bits->common.filter != PIXMAN_FILTER_CONVOLUTION &&
@@ -764,16 +776,16 @@ bits_image_property_changed (pixman_image_t *image)
bits->common.repeat == PIXMAN_REPEAT_NORMAL))
{
image->common.get_scanline_64 =
- (scanFetchProc)bits_image_fetch_untransformed_64;
+ bits_image_fetch_untransformed_64;
image->common.get_scanline_32 =
- (scanFetchProc)bits_image_fetch_untransformed_32;
+ bits_image_fetch_untransformed_32;
}
else
{
image->common.get_scanline_64 =
- (scanFetchProc)_pixman_image_get_scanline_64_generic;
+ _pixman_image_get_scanline_64_generic;
image->common.get_scanline_32 =
- (scanFetchProc)bits_image_fetch_transformed;
+ bits_image_fetch_transformed;
}
bits->store_scanline_64 = bits_image_store_scanline_64;
diff --git a/pixman/pixman-image.c b/pixman/pixman-image.c
index 9558ccb..8793eca 100644
--- a/pixman/pixman-image.c
+++ b/pixman/pixman-image.c
@@ -59,23 +59,25 @@ _pixman_init_gradient (gradient_t *gradient,
/*
* By default, just evaluate the image at 32bpp and expand. Individual image
* types can plug in a better scanline getter if they want to. For example
- * we could produce smoother gradients by evaluating them at higher color depth, but
- * that's a project for the future.
+ * we could produce smoother gradients by evaluating them at higher color
+ * depth, but that's a project for the future.
*/
void
-_pixman_image_get_scanline_64_generic (pixman_image_t * pict, int x, int y, int width,
- uint64_t *buffer, uint64_t *mask, uint32_t maskBits)
+_pixman_image_get_scanline_64_generic (pixman_image_t * pict,
+ int x, int y, int width,
+ uint32_t *buffer,
+ uint32_t *mask, uint32_t maskBits)
{
uint32_t *mask8 = NULL;
- // Contract the mask image, if one exists, so that the 32-bit fetch function
- // can use it.
+ // Contract the mask image, if one exists, so that the 32-bit fetch
+ // function can use it.
if (mask) {
mask8 = pixman_malloc_ab(width, sizeof(uint32_t));
if (!mask8)
return;
- pixman_contract(mask8, mask, width);
+ pixman_contract (mask8, (uint64_t *)mask, width);
}
// Fetch the source image into the first half of buffer.
@@ -83,9 +85,9 @@ _pixman_image_get_scanline_64_generic (pixman_image_t * pict, int x, int y, int
maskBits);
// Expand from 32bpp to 64bpp in place.
- pixman_expand(buffer, (uint32_t*)buffer, PIXMAN_a8r8g8b8, width);
+ pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, width);
- free(mask8);
+ free (mask8);
}
pixman_image_t *
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index 643c979..8942586 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -212,8 +212,8 @@ _pixman_image_get_scanline_64_generic (pixman_image_t *pict,
int x,
int y,
int width,
- uint64_t *buffer,
- uint64_t *mask,
+ uint32_t *buffer,
+ uint32_t *mask,
uint32_t maskBits);
source_pict_class_t
commit 4597ad88d9ade51b5a0b4eb87503e1278b29ef56
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 18:44:01 2009 -0400
Fix bug where 64 bit pixel were fetched as 32 bit ones.
diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c
index e5d0bd0..e2417b1 100644
--- a/pixman/pixman-bits-image.c
+++ b/pixman/pixman-bits-image.c
@@ -727,12 +727,12 @@ bits_image_fetch_untransformed_64 (bits_image_t * image,
{
if (image->common.repeat == PIXMAN_REPEAT_NONE)
{
- bits_image_fetch_untransformed_repeat_none (image, FALSE, x, y,
+ bits_image_fetch_untransformed_repeat_none (image, TRUE, x, y,
width, (uint32_t *)buffer);
}
else
{
- bits_image_fetch_untransformed_repeat_normal (image, FALSE, x, y,
+ bits_image_fetch_untransformed_repeat_normal (image, TRUE, x, y,
width, (uint32_t *)buffer);
}
}
commit aa6adb646a2c61062d867cece2b0669f658abb39
Author: Søren Sandmann Pedersen <sandmann at redhat.com>
Date: Tue Jun 23 18:41:35 2009 -0400
Delete FbIntMult and FbIntDiv macros, and move FbIntAdd to pixman-combine.h
diff --git a/pixman/make-combine.pl b/pixman/make-combine.pl
index 3eb3d35..8f31259 100644
--- a/pixman/make-combine.pl
+++ b/pixman/make-combine.pl
@@ -1,4 +1,4 @@
-$usage = "Usage: combine.pl { 8 | 16 } < combine.inc";
+$usage = "Usage: combine.pl { 8 | 16 } < pixman-combine.c.template";
$#ARGV == 0 or die $usage;
diff --git a/pixman/pixman-combine.c.template b/pixman/pixman-combine.c.template
index 53edba0..582c63e 100644
--- a/pixman/pixman-combine.c.template
+++ b/pixman/pixman-combine.c.template
@@ -1056,6 +1056,11 @@ fbCombineConjointInPart (comp1_t a, comp1_t b)
return IntDiv(b,a); /* b/a */
}
+#define GetComp(v,i) ((comp2_t) (comp1_t) ((v) >> i))
+
+#define Add(x,y,i,t) ((t) = GetComp(x,i) + GetComp(y,i), \
+ (comp4_t) ((comp1_t) ((t) | (0 - ((t) >> G_SHIFT)))) << (i))
+
#define FbGen(x,y,i,ax,ay,t,u,v) ((t) = (IntMult(GetComp(y,i),ay,(u)) + \
IntMult(GetComp(x,i),ax,(v))), \
(comp4_t) ((comp1_t) ((t) | \
diff --git a/pixman/pixman-combine.h.template b/pixman/pixman-combine.h.template
index 9f64e85..35b4c18 100644
--- a/pixman/pixman-combine.h.template
+++ b/pixman/pixman-combine.h.template
@@ -23,11 +23,9 @@
#define IntMult(a,b,t) ( (t) = (a) * (b) + ONE_HALF, ( ( ( (t)>>G_SHIFT ) + (t) )>>G_SHIFT ) )
#define IntDiv(a,b) (((comp2_t) (a) * MASK) / (b))
-
-#define GetComp(v,i) ((comp2_t) (comp1_t) ((v) >> i))
-
-#define Add(x,y,i,t) ((t) = GetComp(x,i) + GetComp(y,i), \
- (comp4_t) ((comp1_t) ((t) | (0 - ((t) >> G_SHIFT)))) << (i))
+#define IntAdd(x,y,t) ( \
+ (t) = x + y, \
+ (comp4_t) (comp1_t) ((t) | (0 - ((t) >> G_SHIFT))))
#define DivOne(x) (((x) + ONE_HALF + (((x) + ONE_HALF) >> G_SHIFT)) >> G_SHIFT)
diff --git a/pixman/pixman-fast-path.c b/pixman/pixman-fast-path.c
index 7d3f0c0..8669ec2 100644
--- a/pixman/pixman-fast-path.c
+++ b/pixman/pixman-fast-path.c
@@ -204,7 +204,7 @@ fbCompositeSolidMaskIn_nx8x8 (pixman_implementation_t *imp,
}
else if (m != 0xff)
{
- *dst = FbIntMult(m, *dst, t);
+ *dst = IntMult(m, *dst, t);
}
dst++;
}
@@ -223,14 +223,14 @@ fbCompositeSolidMaskIn_nx8x8 (pixman_implementation_t *imp,
while (w--)
{
m = *mask++;
- m = FbIntMult(m, srca, t);
+ m = IntMult(m, srca, t);
if (m == 0)
{
*dst = 0;
}
else if (m != 0xff)
{
- *dst = FbIntMult(m, *dst, t);
+ *dst = IntMult(m, *dst, t);
}
dst++;
}
@@ -281,7 +281,7 @@ fbCompositeSrcIn_8x8 (pixman_implementation_t *imp,
}
else if (s != 0xff)
{
- *dst = FbIntMult(s, *dst, t);
+ *dst = IntMult(s, *dst, t);
}
dst++;
}
@@ -948,8 +948,8 @@ fbCompositeSrcAdd_8888x8x8 (pixman_implementation_t *imp,
a = *mask++;
d = *dst;
- m = FbIntMult (sa, a, tmp);
- r = FbIntAdd (m, d, tmp);
+ m = IntMult (sa, a, tmp);
+ r = IntAdd (m, d, tmp);
*dst++ = r;
}
diff --git a/pixman/pixman-mmx.c b/pixman/pixman-mmx.c
index 00480f6..1cf2f17 100644
--- a/pixman/pixman-mmx.c
+++ b/pixman/pixman-mmx.c
@@ -37,6 +37,7 @@
#include <mmintrin.h>
#include "pixman-private.h"
+#include "pixman-combine32.h"
#define noVERBOSE
@@ -671,7 +672,7 @@ mmxCombineSaturateU (pixman_implementation_t *imp, pixman_op_t op,
uint32_t da = ~d >> 24;
if (sa > da) {
- __m64 msa = load8888(FbIntDiv(da, sa) << 24);
+ __m64 msa = load8888(IntDiv(da, sa) << 24);
msa = expand_alpha(msa);
ms = pix_multiply(ms, msa);
}
@@ -2502,8 +2503,8 @@ fbCompositeIn_nx8x8mmx (pixman_implementation_t *imp,
a = *mask++;
d = *dst;
- m = FbIntMult (sa, a, tmp);
- d = FbIntMult (m, d, tmp);
+ m = IntMult (sa, a, tmp);
+ d = IntMult (m, d, tmp);
*dst++ = d;
}
@@ -2567,7 +2568,7 @@ fbCompositeIn_8x8mmx (pixman_implementation_t *imp,
s = *src;
d = *dst;
- *dst = FbIntMult (s, d, tmp);
+ *dst = IntMult (s, d, tmp);
src++;
dst++;
@@ -2646,8 +2647,8 @@ fbCompositeSrcAdd_8888x8x8mmx (pixman_implementation_t *imp,
a = *mask++;
d = *dst;
- m = FbIntMult (sa, a, tmp);
- r = FbIntAdd (m, d, tmp);
+ m = IntMult (sa, a, tmp);
+ r = IntAdd (m, d, tmp);
*dst++ = r;
}
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index 4f5931a..643c979 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -314,12 +314,6 @@ uint32_t
_pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker,
pixman_fixed_32_32_t x);
-#define FbIntMult(a,b,t) ((t) = (a) * (b) + 0x80, ((((t) >> 8) + (t)) >> 8))
-#define FbIntDiv(a,b) (((uint16_t) (a) * 255) / (b))
-#define FbIntAdd(x,y,t) ( \
- (t) = x + y, \
- (uint32_t) (uint8_t) ((t) | (0 - ((t) >> 8))))
-
/*
* Edges
*/
diff --git a/pixman/pixman-sse2.c b/pixman/pixman-sse2.c
index d39beae..9f60b6a 100644
--- a/pixman/pixman-sse2.c
+++ b/pixman/pixman-sse2.c
@@ -34,6 +34,7 @@
#include <xmmintrin.h> /* for _mm_shuffle_pi16 and _MM_SHUFFLE */
#include <emmintrin.h> /* for SSE2 intrinsics */
#include "pixman-private.h"
+#include "pixman-combine32.h"
#ifdef USE_SSE2
@@ -1330,7 +1331,7 @@ coreCombineSaturateUPixelsse2 (uint32_t src, uint32_t dst)
if (sa > da)
{
- ms = pixMultiply_1x64 (ms, expandAlpha_1x64 (unpack_32_1x64 (FbIntDiv(da, sa) << 24)));
+ ms = pixMultiply_1x64 (ms, expandAlpha_1x64 (unpack_32_1x64 (IntDiv(da, sa) << 24)));
}
return pack_1x64_32 (_mm_adds_pu16 (md, ms));
diff --git a/test/clip-test.c b/test/clip-test.c
index 90310f4..9000137 100644
--- a/test/clip-test.c
+++ b/test/clip-test.c
@@ -71,6 +71,7 @@ main (int argc, char **argv)
pixman_region32_init_rect (&clip_region, 50, 0, 100, 200);
pixman_image_set_clip_region32 (src_img, &clip_region);
pixman_image_set_source_clipping (src_img, TRUE);
+ pixman_image_set_has_client_clip (src_img, TRUE);
pixman_image_set_transform (src_img, &trans);
pixman_image_set_repeat (src_img, PIXMAN_REPEAT_NORMAL);
More information about the xorg-commit
mailing list