From: Søren Sandmann Pedersen <s...@redhat.com>
The 64 bit pipeline is not used anymore, so it can now be removed.
Don't generate pixman-combine64.[ch] anymore. Don't generate the
pixman-srgb.c anymore. Delete all the 64 bit fetchers in
pixman-access.c, all the 64 bit iterator functions in
pixman-bits-image.c and all the functions that expand from 8 to 16
bits.
---
.gitignore | 2 -
pixman/Makefile.am | 1 -
pixman/Makefile.sources | 14 --
pixman/pixman-access.c | 517 +++-----------------------------------------
pixman/pixman-bits-image.c | 49 +----
pixman/pixman-general.c | 1 -
pixman/pixman-private.h | 41 ----
pixman/pixman-solid-fill.c | 23 +-
pixman/pixman-utils.c | 116 ----------
9 files changed, 39 insertions(+), 725 deletions(-)
diff --git a/.gitignore b/.gitignore
index a4d9f99..a67da1d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -41,8 +41,6 @@ demos/trap-test
demos/tri-test
pixman/pixman-combine32.c
pixman/pixman-combine32.h
-pixman/pixman-combine64.c
-pixman/pixman-combine64.h
pixman/pixman-srgb.c
pixman/pixman-version.h
test/a1-trap-test
diff --git a/pixman/Makefile.am b/pixman/Makefile.am
index 270d65e..3060569 100644
--- a/pixman/Makefile.am
+++ b/pixman/Makefile.am
@@ -13,7 +13,6 @@ noinst_LTLIBRARIES =
EXTRA_DIST = \
Makefile.win32 \
make-combine.pl \
- make-srgb.pl \
pixman-combine.c.template \
pixman-combine.h.template \
pixman-region.c \
diff --git a/pixman/Makefile.sources b/pixman/Makefile.sources
index 96540ec..5be288d 100644
--- a/pixman/Makefile.sources
+++ b/pixman/Makefile.sources
@@ -4,7 +4,6 @@ libpixman_sources = \
pixman-access-accessors.c \
pixman-bits-image.c \
pixman-combine32.c \
- pixman-combine64.c \
pixman-combine-float.c \
pixman-conical-gradient.c \
pixman-x86.c \
@@ -26,7 +25,6 @@ libpixman_sources = \
pixman-region16.c \
pixman-region32.c \
pixman-solid-fill.c \
- pixman-srgb.c \
pixman-timer.c \
pixman-trap.c \
pixman-utils.c \
@@ -36,7 +34,6 @@ libpixman_headers = \
pixman.h \
pixman-accessor.h \
pixman-combine32.h \
- pixman-combine64.h \
pixman-compiler.h \
pixman-edge-imp.h \
pixman-inlines.h \
@@ -46,20 +43,9 @@ libpixman_headers = \
BUILT_SOURCES = \
pixman-combine32.c \
pixman-combine32.h \
- pixman-combine64.c \
- pixman-combine64.h \
- pixman-srgb.c \
$(NULL)
-pixman-srgb.c: make-srgb.pl
- $(PERL) $< > $@ || ($(RM) $@; exit 1)
-
pixman-combine32.c: pixman-combine.c.template make-combine.pl
$(PERL) $(lastword $+) 8 < $< > $@ || ($(RM) $@; exit 1)
pixman-combine32.h: pixman-combine.h.template make-combine.pl
$(PERL) $(lastword $+) 8 < $< > $@ || ($(RM) $@; exit 1)
-
-pixman-combine64.c: pixman-combine.c.template make-combine.pl
- $(PERL) $(lastword $+) 16 < $< > $@ || ($(RM) $@; exit 1)
-pixman-combine64.h: pixman-combine.h.template make-combine.pl
- $(PERL) $(lastword $+) 16 < $< > $@ || ($(RM) $@; exit 1)
diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c
index 1eef621..b5c8e40 100644
--- a/pixman/pixman-access.c
+++ b/pixman/pixman-access.c
@@ -507,135 +507,6 @@ MAKE_ACCESSORS(a1);
MAKE_ACCESSORS(g1);
/********************************** Fetch ************************************/
-
-/* Expects a uint64_t buffer */
-static void
-fetch_scanline_a2r10g10b10 (pixman_image_t *image,
- int x,
- int y,
- int width,
- uint32_t * b,
- const uint32_t *mask)
-{
- 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 (image, pixel++);
- uint64_t a = p >> 30;
- uint64_t r = (p >> 20) & 0x3ff;
- uint64_t g = (p >> 10) & 0x3ff;
- uint64_t b = p & 0x3ff;
-
- r = r << 6 | r >> 4;
- g = g << 6 | g >> 4;
- b = b << 6 | b >> 4;
-
- a <<= 14;
- a |= a >> 2;
- a |= a >> 4;
- a |= a >> 8;
-
- *buffer++ = a << 48 | r << 32 | g << 16 | b;
- }
-}
-
-/* Expects a uint64_t buffer */
-static void
-fetch_scanline_x2r10g10b10 (pixman_image_t *image,
- int x,
- int y,
- int width,
- uint32_t * b,
- const uint32_t *mask)
-{
- 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 (image, pixel++);
- uint64_t r = (p >> 20) & 0x3ff;
- uint64_t g = (p >> 10) & 0x3ff;
- uint64_t b = p & 0x3ff;
-
- r = r << 6 | r >> 4;
- g = g << 6 | g >> 4;
- b = b << 6 | b >> 4;
-
- *buffer++ = 0xffffULL << 48 | r << 32 | g << 16 | b;
- }
-}
-
-/* Expects a uint64_t buffer */
-static void
-fetch_scanline_a2b10g10r10 (pixman_image_t *image,
- int x,
- int y,
- int width,
- uint32_t * b,
- const uint32_t *mask)
-{
- 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 (image, pixel++);
- uint64_t a = p >> 30;
- uint64_t b = (p >> 20) & 0x3ff;
- uint64_t g = (p >> 10) & 0x3ff;
- uint64_t r = p & 0x3ff;
-
- r = r << 6 | r >> 4;
- g = g << 6 | g >> 4;
- b = b << 6 | b >> 4;
-
- a <<= 14;
- a |= a >> 2;
- a |= a >> 4;
- a |= a >> 8;
-
- *buffer++ = a << 48 | r << 32 | g << 16 | b;
- }
-}
-
-/* Expects a uint64_t buffer */
-static void
-fetch_scanline_x2b10g10r10 (pixman_image_t *image,
- int x,
- int y,
- int width,
- uint32_t * b,
- const uint32_t *mask)
-{
- 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 (image, pixel++);
- uint64_t b = (p >> 20) & 0x3ff;
- uint64_t g = (p >> 10) & 0x3ff;
- uint64_t r = p & 0x3ff;
-
- r = r << 6 | r >> 4;
- g = g << 6 | g >> 4;
- b = b << 6 | b >> 4;
-
- *buffer++ = 0xffffULL << 48 | r << 32 | g << 16 | b;
- }
-}
-
/* Table mapping sRGB-encoded 8 bit numbers to linearly encoded
* floating point numbers. We assume that single precision
* floating point follows the IEEE 754 format.
@@ -934,94 +805,6 @@ fetch_scanline_yv12 (pixman_image_t *image,
/**************************** Pixel wise fetching
*****************************/
-/* Despite the type, expects a uint64_t buffer */
-static uint64_t
-fetch_pixel_a2r10g10b10 (bits_image_t *image,
- int offset,
- int line)
-{
- uint32_t *bits = image->bits + line * image->rowstride;
- uint32_t p = READ (image, bits + offset);
- uint64_t a = p >> 30;
- uint64_t r = (p >> 20) & 0x3ff;
- uint64_t g = (p >> 10) & 0x3ff;
- uint64_t b = p & 0x3ff;
-
- r = r << 6 | r >> 4;
- g = g << 6 | g >> 4;
- b = b << 6 | b >> 4;
-
- a <<= 14;
- a |= a >> 2;
- a |= a >> 4;
- a |= a >> 8;
-
- return a << 48 | r << 32 | g << 16 | b;
-}
-
-/* Despite the type, this function expects a uint64_t buffer */
-static uint64_t
-fetch_pixel_x2r10g10b10 (bits_image_t *image,
- int offset,
- int line)
-{
- uint32_t *bits = image->bits + line * image->rowstride;
- uint32_t p = READ (image, bits + offset);
- uint64_t r = (p >> 20) & 0x3ff;
- uint64_t g = (p >> 10) & 0x3ff;
- uint64_t b = p & 0x3ff;
-
- r = r << 6 | r >> 4;
- g = g << 6 | g >> 4;
- b = b << 6 | b >> 4;
-
- return 0xffffULL << 48 | r << 32 | g << 16 | b;
-}
-
-/* Despite the type, expects a uint64_t buffer */
-static uint64_t
-fetch_pixel_a2b10g10r10 (bits_image_t *image,
- int offset,
- int line)
-{
- uint32_t *bits = image->bits + line * image->rowstride;
- uint32_t p = READ (image, bits + offset);
- uint64_t a = p >> 30;
- uint64_t b = (p >> 20) & 0x3ff;
- uint64_t g = (p >> 10) & 0x3ff;
- uint64_t r = p & 0x3ff;
-
- r = r << 6 | r >> 4;
- g = g << 6 | g >> 4;
- b = b << 6 | b >> 4;
-
- a <<= 14;
- a |= a >> 2;
- a |= a >> 4;
- a |= a >> 8;
-
- return a << 48 | r << 32 | g << 16 | b;
-}
-
-/* Despite the type, this function expects a uint64_t buffer */
-static uint64_t
-fetch_pixel_x2b10g10r10 (bits_image_t *image,
- int offset,
- int line)
-{
- uint32_t *bits = image->bits + line * image->rowstride;
- uint32_t p = READ (image, bits + offset);
- uint64_t b = (p >> 20) & 0x3ff;
- uint64_t g = (p >> 10) & 0x3ff;
- uint64_t r = p & 0x3ff;
-
- r = r << 6 | r >> 4;
- g = g << 6 | g >> 4;
- b = b << 6 | b >> 4;
-
- return 0xffffULL << 48 | r << 32 | g << 16 | b;
-}
-
static argb_t
fetch_pixel_x2r10g10b10_float (bits_image_t *image,
int offset,
@@ -1180,93 +963,6 @@ fetch_pixel_yv12 (bits_image_t *image,
/*********************************** Store
************************************/
static void
-store_scanline_a2r10g10b10 (bits_image_t * image,
- int x,
- int y,
- int width,
- const uint32_t *v)
-{
- 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) |
- ((values[i] >> 18) & 0x3ff00000) |
- ((values[i] >> 12) & 0xffc00) |
- ((values[i] >> 6) & 0x3ff));
- }
-}
-
-static void
-store_scanline_x2r10g10b10 (bits_image_t * image,
- int x,
- int y,
- int width,
- const uint32_t *v)
-{
- 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] >> 18) & 0x3ff00000) |
- ((values[i] >> 12) & 0xffc00) |
- ((values[i] >> 6) & 0x3ff));
- }
-}
-
-static void
-store_scanline_a2b10g10r10 (bits_image_t * image,
- int x,
- int y,
- int width,
- const uint32_t *v)
-{
- 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) |
- ((values[i] >> 38) & 0x3ff) |
- ((values[i] >> 12) & 0xffc00) |
- ((values[i] << 14) & 0x3ff00000));
- }
-}
-
-static void
-store_scanline_x2b10g10r10 (bits_image_t * image,
- int x,
- int y,
- int width,
- const uint32_t *v)
-{
- 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) |
- ((values[i] >> 12) & 0xffc00) |
- ((values[i] << 14) & 0x3ff00000));
- }
-}
-
-
-static void
store_scanline_a2r10g10b10_float (bits_image_t * image,
int x,
int y,
@@ -1395,35 +1091,6 @@ store_scanline_a8r8g8b8_sRGB_float (bits_image_t *
image,
}
/*
- * Contracts a 64bpp image to 32bpp and then stores it using a regular 32-bit
- * store proc. Despite the type, this function expects a uint64_t buffer.
- */
-static void
-store_scanline_generic_64 (bits_image_t * image,
- int x,
- int y,
- int width,
- const uint32_t *values)
-{
- uint32_t *argb8_pixels;
-
- assert (image->common.type == BITS);
-
- argb8_pixels = pixman_malloc_ab (width, sizeof(uint32_t));
- if (!argb8_pixels)
- return;
-
- /* Contract the scanline. We could do this in place if values weren't
- * const.
- */
- pixman_contract (argb8_pixels, (uint64_t *)values, width);
-
- image->store_scanline_32 (image, x, y, width, argb8_pixels);
-
- free (argb8_pixels);
-}
-
-/*
* Contracts a floating point image to 32bpp and then stores it using a
* regular 32-bit store proc. Despite the type, this function expects an
* argb_t buffer.
@@ -1453,39 +1120,6 @@ store_scanline_generic_float (bits_image_t * image,
free (argb8_pixels);
}
-/* Despite the type, this function expects both buffer
- * and mask to be uint64_t
- */
-static void
-fetch_scanline_generic_64 (pixman_image_t *image,
- int x,
- int y,
- int width,
- uint32_t * buffer,
- const uint32_t *mask)
-{
- pixman_format_code_t format;
-
- /* Fetch the pixels into the first half of buffer and then expand them in
- * place.
- */
- image->bits.fetch_scanline_32 (image, x, y, width, buffer, NULL);
-
- format = image->bits.format;
- if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_COLOR ||
- PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_GRAY)
- {
- /* Indexed formats are mapped to a8r8g8b8 with full
- * precision, so when expanding we shouldn't correct
- * for the width of the channels
- */
-
- format = PIXMAN_a8r8g8b8;
- }
-
- pixman_expand ((uint64_t *)buffer, buffer, format, width);
-}
-
static void
fetch_scanline_generic_float (pixman_image_t *image,
int x,
@@ -1499,33 +1133,6 @@ fetch_scanline_generic_float (pixman_image_t *image,
pixman_expand_to_float ((argb_t *)buffer, buffer, image->bits.format,
width);
}
-/* Despite the type, this function expects a uint64_t *buffer */
-static uint64_t
-fetch_pixel_generic_64 (bits_image_t *image,
- int offset,
- int line)
-{
- uint32_t pixel32 = image->fetch_pixel_32 (image, offset, line);
- uint64_t result;
- pixman_format_code_t format;
-
- format = image->format;
- if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_COLOR ||
- PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_GRAY)
- {
- /* Indexed formats are mapped to a8r8g8b8 with full
- * precision, so when expanding we shouldn't correct
- * for the width of the channels
- */
-
- format = PIXMAN_a8r8g8b8;
- }
-
- pixman_expand ((uint64_t *)&result, &pixel32, format, 1);
-
- return result;
-}
-
/* The 32_sRGB paths should be deleted after narrow processing
* is no longer invoked for formats that are considered wide.
* (Also see fetch_pixel_generic_lossy_32) */
@@ -1561,30 +1168,6 @@ fetch_scanline_a8r8g8b8_32_sRGB (pixman_image_t *image,
}
}
-static void
-fetch_scanline_a8r8g8b8_64_sRGB (pixman_image_t *image,
- int x,
- int y,
- int width,
- uint32_t *b,
- const uint32_t *mask)
-{
- 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;
- uint32_t tmp;
-
- while (pixel < end)
- {
- tmp = READ (image, pixel++);
- *buffer++ = (uint64_t) ((tmp >> 24) * 257) << 48
- | (uint64_t) srgb_to_linear[(tmp >> 16) & 0xff] << 32
- | (uint64_t) srgb_to_linear[(tmp >> 8) & 0xff] << 16
- | (uint64_t) srgb_to_linear[(tmp >> 0) & 0xff] << 0;
- }
-}
-
static uint32_t
fetch_pixel_a8r8g8b8_32_sRGB (bits_image_t *image,
int offset,
@@ -1606,19 +1189,6 @@ fetch_pixel_a8r8g8b8_32_sRGB (bits_image_t *image,
return (a << 24) | (r << 16) | (g << 8) | (b << 0);
}
-static uint64_t
-fetch_pixel_a8r8g8b8_64_sRGB (bits_image_t *image,
- int offset,
- int line)
-{
- uint32_t *bits = image->bits + line * image->rowstride;
- uint32_t tmp = READ (image, bits + offset);
- return (uint64_t) ((tmp >> 24) * 257) << 48
- | (uint64_t) srgb_to_linear[(tmp >> 16) & 0xff] << 32
- | (uint64_t) srgb_to_linear[(tmp >> 8) & 0xff] << 16
- | (uint64_t) srgb_to_linear[(tmp >> 0) & 0xff] << 0;
-}
-
static void
store_scanline_a8r8g8b8_32_sRGB (bits_image_t *image,
int x,
@@ -1651,30 +1221,6 @@ store_scanline_a8r8g8b8_32_sRGB (bits_image_t *image,
}
}
-static void
-store_scanline_a8r8g8b8_64_sRGB (bits_image_t *image,
- int x,
- int y,
- int width,
- const uint32_t *v)
-{
- uint32_t *bits = image->bits + image->rowstride * y;
- uint64_t *values = (uint64_t *)v;
- uint32_t *pixel = bits + x;
- uint64_t tmp;
- int i;
-
- for (i = 0; i < width; ++i)
- {
- tmp = values[i];
- WRITE (image, pixel++,
- ((uint32_t) (tmp >> 56) << 24)
- | (linear_to_srgb[(tmp >> 36) & 0xfff] << 16)
- | (linear_to_srgb[(tmp >> 20) & 0xfff] << 8)
- | (linear_to_srgb[(tmp >> 4) & 0xfff] << 0));
- }
-}
-
static argb_t
fetch_pixel_generic_float (bits_image_t *image,
int offset,
@@ -1699,10 +1245,10 @@ fetch_pixel_generic_lossy_32 (bits_image_t *image,
int offset,
int line)
{
- uint64_t pixel64 = image->fetch_pixel_64 (image, offset, line);
+ argb_t pixel64 = image->fetch_pixel_float (image, offset, line);
uint32_t result;
- pixman_contract (&result, &pixel64, 1);
+ pixman_contract_from_float (&result, &pixel64, 1);
return result;
}
@@ -1711,13 +1257,10 @@ typedef struct
{
pixman_format_code_t format;
fetch_scanline_t fetch_scanline_32;
- fetch_scanline_t fetch_scanline_64;
fetch_scanline_t fetch_scanline_float;
fetch_pixel_32_t fetch_pixel_32;
- fetch_pixel_64_t fetch_pixel_64;
fetch_pixel_float_t fetch_pixel_float;
store_scanline_t store_scanline_32;
- store_scanline_t store_scanline_64;
store_scanline_t store_scanline_float;
} format_info_t;
@@ -1725,13 +1268,10 @@ typedef struct
{ \
PIXMAN_ ## format, \
fetch_scanline_ ## format, \
- fetch_scanline_generic_64, \
fetch_scanline_generic_float, \
fetch_pixel_ ## format, \
- fetch_pixel_generic_64, \
fetch_pixel_generic_float, \
store_scanline_ ## format, \
- store_scanline_generic_64, \
store_scanline_generic_float \
}
@@ -1750,9 +1290,9 @@ static const format_info_t accessors[] =
/* sRGB formats */
{ PIXMAN_a8r8g8b8_sRGB,
- fetch_scanline_a8r8g8b8_32_sRGB, fetch_scanline_a8r8g8b8_64_sRGB,
fetch_scanline_a8r8g8b8_sRGB_float,
- fetch_pixel_a8r8g8b8_32_sRGB, fetch_pixel_a8r8g8b8_64_sRGB,
fetch_pixel_a8r8g8b8_sRGB_float,
- store_scanline_a8r8g8b8_32_sRGB, store_scanline_a8r8g8b8_64_sRGB,
store_scanline_a8r8g8b8_sRGB_float,
+ fetch_scanline_a8r8g8b8_32_sRGB, fetch_scanline_a8r8g8b8_sRGB_float,
+ fetch_pixel_a8r8g8b8_32_sRGB, fetch_pixel_a8r8g8b8_sRGB_float,
+ store_scanline_a8r8g8b8_32_sRGB, store_scanline_a8r8g8b8_sRGB_float,
},
/* 24bpp formats */
@@ -1813,34 +1353,34 @@ static const format_info_t accessors[] =
/* Wide formats */
{ PIXMAN_a2r10g10b10,
- NULL, fetch_scanline_a2r10g10b10, fetch_scanline_a2r10g10b10_float,
- fetch_pixel_generic_lossy_32, fetch_pixel_a2r10g10b10,
fetch_pixel_a2r10g10b10_float,
- NULL, store_scanline_a2r10g10b10, store_scanline_a2r10g10b10_float },
-
+ NULL, fetch_scanline_a2r10g10b10_float,
+ fetch_pixel_generic_lossy_32, fetch_pixel_a2r10g10b10_float,
+ NULL, store_scanline_a2r10g10b10_float },
+
{ PIXMAN_x2r10g10b10,
- NULL, fetch_scanline_x2r10g10b10, fetch_scanline_x2r10g10b10_float,
- fetch_pixel_generic_lossy_32, fetch_pixel_x2r10g10b10,
fetch_pixel_x2r10g10b10_float,
- NULL, store_scanline_x2r10g10b10, store_scanline_x2r10g10b10_float },
-
+ NULL, fetch_scanline_x2r10g10b10_float,
+ fetch_pixel_generic_lossy_32, fetch_pixel_x2r10g10b10_float,
+ NULL, store_scanline_x2r10g10b10_float },
+
{ PIXMAN_a2b10g10r10,
- NULL, fetch_scanline_a2b10g10r10, fetch_scanline_a2b10g10r10_float,
- fetch_pixel_generic_lossy_32, fetch_pixel_a2b10g10r10,
fetch_pixel_a2b10g10r10_float,
- NULL, store_scanline_a2b10g10r10, store_scanline_a2b10g10r10_float },
-
+ NULL, fetch_scanline_a2b10g10r10_float,
+ fetch_pixel_generic_lossy_32, fetch_pixel_a2b10g10r10_float,
+ NULL, store_scanline_a2b10g10r10_float },
+
{ PIXMAN_x2b10g10r10,
- NULL, fetch_scanline_x2b10g10r10, fetch_scanline_x2b10g10r10_float,
- fetch_pixel_generic_lossy_32, fetch_pixel_x2b10g10r10,
fetch_pixel_x2b10g10r10_float,
- NULL, store_scanline_x2b10g10r10, store_scanline_x2b10g10r10_float },
-
+ NULL, fetch_scanline_x2b10g10r10_float,
+ fetch_pixel_generic_lossy_32, fetch_pixel_x2b10g10r10_float,
+ NULL, store_scanline_x2b10g10r10_float },
+
/* YUV formats */
{ PIXMAN_yuy2,
- fetch_scanline_yuy2, fetch_scanline_generic_64,
fetch_scanline_generic_float,
- fetch_pixel_yuy2, fetch_pixel_generic_64, fetch_pixel_generic_float,
- NULL, NULL, NULL },
-
+ fetch_scanline_yuy2, fetch_scanline_generic_float,
+ fetch_pixel_yuy2, fetch_pixel_generic_float,
+ NULL, NULL },
+
{ PIXMAN_yv12,
- fetch_scanline_yv12, fetch_scanline_generic_64,
fetch_scanline_generic_float,
- fetch_pixel_yv12, fetch_pixel_generic_64, fetch_pixel_generic_float,
+ fetch_scanline_yv12, fetch_scanline_generic_float,
+ fetch_pixel_yv12, fetch_pixel_generic_float,
NULL, NULL },
{ PIXMAN_null },
@@ -1856,13 +1396,10 @@ setup_accessors (bits_image_t *image)
if (info->format == image->format)
{
image->fetch_scanline_32 = info->fetch_scanline_32;
- image->fetch_scanline_64 = info->fetch_scanline_64;
image->fetch_scanline_float = info->fetch_scanline_float;
image->fetch_pixel_32 = info->fetch_pixel_32;
- image->fetch_pixel_64 = info->fetch_pixel_64;
image->fetch_pixel_float = info->fetch_pixel_float;
image->store_scanline_32 = info->store_scanline_32;
- image->store_scanline_64 = info->store_scanline_64;
image->store_scanline_float = info->store_scanline_float;
return;
diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c
index 81a5a6f..38b7989 100644
--- a/pixman/pixman-bits-image.c
+++ b/pixman/pixman-bits-image.c
@@ -50,45 +50,6 @@ _pixman_image_get_scanline_generic_float (pixman_iter_t *
iter,
return iter->buffer;
}
-/*
- * 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.
- */
-static uint32_t *
-_pixman_image_get_scanline_generic_64 (pixman_iter_t * iter,
- const uint32_t *mask)
-{
- int width = iter->width;
- uint32_t * buffer = iter->buffer;
-
- pixman_iter_get_scanline_t fetch_32 = iter->data;
- uint32_t *mask8 = NULL;
-
- /* 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 buffer;
-
- pixman_contract (mask8, (uint64_t *)mask, width);
- }
-
- /* Fetch the source image into the first half of buffer. */
- fetch_32 (iter, mask8);
-
- /* Expand from 32bpp to 64bpp in place. */
- pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, width);
-
- free (mask8);
-
- return buffer;
-}
-
/* Fetch functions */
static force_inline uint32_t
@@ -1141,7 +1102,6 @@ typedef struct
pixman_format_code_t format;
uint32_t flags;
pixman_iter_get_scanline_t get_scanline_32;
- pixman_iter_get_scanline_t get_scanline_64;
pixman_iter_get_scanline_t get_scanline_float;
} fetcher_info_t;
@@ -1154,7 +1114,6 @@ static const fetcher_info_t fetcher_info[] =
FAST_PATH_NO_PAD_REPEAT |
FAST_PATH_NO_REFLECT_REPEAT),
bits_image_fetch_untransformed_32,
- NULL,
bits_image_fetch_untransformed_float
},
@@ -1171,14 +1130,12 @@ static const fetcher_info_t fetcher_info[] =
{ PIXMAN_a8r8g8b8,
FAST_BILINEAR_FLAGS,
bits_image_fetch_bilinear_no_repeat_8888,
- _pixman_image_get_scanline_generic_64,
_pixman_image_get_scanline_generic_float
},
{ PIXMAN_x8r8g8b8,
FAST_BILINEAR_FLAGS,
bits_image_fetch_bilinear_no_repeat_8888,
- _pixman_image_get_scanline_generic_64,
_pixman_image_get_scanline_generic_float
},
@@ -1200,15 +1157,13 @@ static const fetcher_info_t fetcher_info[] =
{ PIXMAN_ ## format, \
GENERAL_BILINEAR_FLAGS | FAST_PATH_ ## repeat ## _REPEAT,
\
bits_image_fetch_bilinear_affine_ ## name, \
- _pixman_image_get_scanline_generic_64, \
_pixman_image_get_scanline_generic_float \
},
#define NEAREST_AFFINE_FAST_PATH(name, format, repeat) \
{ PIXMAN_ ## format, \
GENERAL_NEAREST_FLAGS | FAST_PATH_ ## repeat ## _REPEAT, \
- bits_image_fetch_nearest_affine_ ## name, \
- _pixman_image_get_scanline_generic_64, \
+ bits_image_fetch_nearest_affine_ ## name,
\
_pixman_image_get_scanline_generic_float \
},
@@ -1237,7 +1192,6 @@ static const fetcher_info_t fetcher_info[] =
{ PIXMAN_any,
(FAST_PATH_NO_ALPHA_MAP | FAST_PATH_HAS_TRANSFORM |
FAST_PATH_AFFINE_TRANSFORM),
bits_image_fetch_affine_no_alpha,
- _pixman_image_get_scanline_generic_64,
_pixman_image_get_scanline_generic_float
},
@@ -1245,7 +1199,6 @@ static const fetcher_info_t fetcher_info[] =
{ PIXMAN_any,
0,
bits_image_fetch_general,
- _pixman_image_get_scanline_generic_64,
_pixman_image_get_scanline_generic_float
},
diff --git a/pixman/pixman-general.c b/pixman/pixman-general.c
index 12294e8..0bf91e4 100644
--- a/pixman/pixman-general.c
+++ b/pixman/pixman-general.c
@@ -220,7 +220,6 @@ _pixman_implementation_create_general (void)
pixman_implementation_t *imp = _pixman_implementation_create (NULL,
general_fast_path);
_pixman_setup_combiner_functions_32 (imp);
- _pixman_setup_combiner_functions_64 (imp);
_pixman_setup_combiner_functions_float (imp);
imp->src_iter_init = general_src_iter_init;
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index 9d77a72..492c584 100644
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -66,10 +66,6 @@ typedef uint32_t (*fetch_pixel_32_t) (bits_image_t *image,
int x,
int y);
-typedef uint64_t (*fetch_pixel_64_t) (bits_image_t *image,
- int x,
- int y);
-
typedef argb_t (*fetch_pixel_float_t) (bits_image_t *image,
int x,
int y);
@@ -128,7 +124,6 @@ struct solid_fill
pixman_color_t color;
uint32_t color_32;
- uint64_t color_64;
argb_t color_float;
};
@@ -188,10 +183,6 @@ struct bits_image
fetch_pixel_32_t fetch_pixel_32;
store_scanline_t store_scanline_32;
- fetch_scanline_t fetch_scanline_64;
- fetch_pixel_64_t fetch_pixel_64;
- store_scanline_t store_scanline_64;
-
fetch_scanline_t fetch_scanline_float;
fetch_pixel_float_t fetch_pixel_float;
store_scanline_t store_scanline_float;
@@ -433,13 +424,6 @@ typedef void (*pixman_combine_32_func_t)
(pixman_implementation_t *imp,
const uint32_t * mask,
int width);
-typedef void (*pixman_combine_64_func_t) (pixman_implementation_t *imp,
- pixman_op_t op,
- uint64_t * dest,
- const uint64_t * src,
- const uint64_t * mask,
- int width);
-
typedef void (*pixman_combine_float_func_t) (pixman_implementation_t *imp,
pixman_op_t op,
float * dest,
@@ -475,7 +459,6 @@ typedef pixman_bool_t (*pixman_iter_init_func_t)
(pixman_implementation_t *imp,
pixman_iter_t
*iter);
void _pixman_setup_combiner_functions_32 (pixman_implementation_t *imp);
-void _pixman_setup_combiner_functions_64 (pixman_implementation_t *imp);
void _pixman_setup_combiner_functions_float (pixman_implementation_t *imp);
typedef struct
@@ -503,8 +486,6 @@ struct pixman_implementation_t
pixman_combine_32_func_t combine_32[PIXMAN_N_OPERATORS];
pixman_combine_32_func_t combine_32_ca[PIXMAN_N_OPERATORS];
- pixman_combine_64_func_t combine_64[PIXMAN_N_OPERATORS];
- pixman_combine_64_func_t combine_64_ca[PIXMAN_N_OPERATORS];
pixman_combine_float_func_t combine_float[PIXMAN_N_OPERATORS];
pixman_combine_float_func_t combine_float_ca[PIXMAN_N_OPERATORS];
};
@@ -807,22 +788,12 @@ _pixman_addition_overflows_int (unsigned int a, unsigned
int b);
/* Compositing utilities */
void
-pixman_expand (uint64_t * dst,
- const uint32_t * src,
- pixman_format_code_t format,
- int width);
-void
pixman_expand_to_float (argb_t *dst,
const uint32_t *src,
pixman_format_code_t format,
int width);
void
-pixman_contract (uint32_t * dst,
- const uint64_t *src,
- int width);
-
-void
pixman_contract_from_float (uint32_t *dst,
const argb_t *src,
int width);
@@ -1149,18 +1120,6 @@ void pixman_timer_register (pixman_timer_t *timer);
#endif /* PIXMAN_TIMERS */
-/* sRGB<->linear conversion tables. Linear color space is the same
- * as sRGB but the components are in linear light (gamma 1.0).
- *
- * linear_to_srgb maps linear value from 0 to 4095 ([0.0, 1.0])
- * and returns 8-bit sRGB value.
- *
- * srgb_to_linear maps 8-bit sRGB value to 16-bit linear value
- * with range 0 to 65535 ([0.0, 1.0]).
- */
-extern const uint8_t linear_to_srgb[4096];
-extern const uint16_t srgb_to_linear[256];
-
#endif /* __ASSEMBLER__ */
#endif /* PIXMAN_PRIVATE_H */
diff --git a/pixman/pixman-solid-fill.c b/pixman/pixman-solid-fill.c
index 1b774d9..979b480 100644
--- a/pixman/pixman-solid-fill.c
+++ b/pixman/pixman-solid-fill.c
@@ -61,14 +61,17 @@ color_to_uint32 (const pixman_color_t *color)
(color->blue >> 8);
}
-static uint64_t
-color_to_uint64 (const pixman_color_t *color)
+static argb_t
+color_to_float (const pixman_color_t *color)
{
- return
- ((uint64_t)color->alpha << 48) |
- ((uint64_t)color->red << 32) |
- ((uint64_t)color->green << 16) |
- ((uint64_t)color->blue);
+ argb_t result;
+
+ result.a = pixman_unorm_to_float (color->alpha, 16);
+ result.r = pixman_unorm_to_float (color->red, 16);
+ result.g = pixman_unorm_to_float (color->green, 16);
+ result.b = pixman_unorm_to_float (color->blue, 16);
+
+ return result;
}
PIXMAN_EXPORT pixman_image_t *
@@ -82,11 +85,7 @@ pixman_image_create_solid_fill (pixman_color_t *color)
img->type = SOLID;
img->solid.color = *color;
img->solid.color_32 = color_to_uint32 (color);
- img->solid.color_64 = color_to_uint64 (color);
- img->solid.color_float.a = pixman_unorm_to_float (color->alpha, 16);
- img->solid.color_float.r = pixman_unorm_to_float (color->red, 16);
- img->solid.color_float.g = pixman_unorm_to_float (color->green, 16);
- img->solid.color_float.b = pixman_unorm_to_float (color->blue, 16);
+ img->solid.color_float = color_to_float (color);
return img;
}
diff --git a/pixman/pixman-utils.c b/pixman/pixman-utils.c
index 4f9db29..551f3f9 100644
--- a/pixman/pixman-utils.c
+++ b/pixman/pixman-utils.c
@@ -71,97 +71,6 @@ pixman_malloc_abc (unsigned int a,
return malloc (a * b * c);
}
-static void
-unorm_to_unorm_params (int in_width, int out_width, uint32_t *factor, int
*shift)
-{
- int w = 0;
-
- *factor = 0;
- while (in_width != 0 && w < out_width)
- {
- *factor |= 1 << w;
- w += in_width;
- }
-
- /* Did we generate too many bits? */
- *shift = w - out_width;
-}
-
-/*
- * This function expands images from ARGB8 format to ARGB16. To preserve
- * precision, it needs to know the original source format. For example, if the
- * source was PIXMAN_x1r5g5b5 and the red component contained bits 12345, then
- * the expanded value is 12345123. To correctly expand this to 16 bits, it
- * should be 1234512345123451 and not 1234512312345123.
- */
-void
-pixman_expand (uint64_t * dst,
- const uint32_t * src,
- pixman_format_code_t format,
- int width)
-{
- /*
- * Determine the sizes of each component and the masks and shifts
- * required to extract them from the source pixel.
- */
- const int a_size = PIXMAN_FORMAT_A (format),
- r_size = PIXMAN_FORMAT_R (format),
- g_size = PIXMAN_FORMAT_G (format),
- b_size = PIXMAN_FORMAT_B (format);
- const int a_shift = 32 - a_size,
- r_shift = 24 - r_size,
- g_shift = 16 - g_size,
- b_shift = 8 - b_size;
- const uint8_t a_mask = ~(~0 << a_size),
- r_mask = ~(~0 << r_size),
- g_mask = ~(~0 << g_size),
- b_mask = ~(~0 << b_size);
- uint32_t au_factor, ru_factor, gu_factor, bu_factor;
- int au_shift, ru_shift, gu_shift, bu_shift;
- int i;
-
- unorm_to_unorm_params (a_size, 16, &au_factor, &au_shift);
- unorm_to_unorm_params (r_size, 16, &ru_factor, &ru_shift);
- unorm_to_unorm_params (g_size, 16, &gu_factor, &gu_shift);
- unorm_to_unorm_params (b_size, 16, &bu_factor, &bu_shift);
-
- /* Start at the end so that we can do the expansion in place
- * when src == dst
- */
- for (i = width - 1; i >= 0; i--)
- {
- const uint32_t pixel = src[i];
- uint8_t a, r, g, b;
- uint64_t a16, r16, g16, b16;
-
- if (a_size)
- {
- a = (pixel >> a_shift) & a_mask;
- a16 = a * au_factor >> au_shift;
- }
- else
- {
- a16 = 0xffff;
- }
-
- if (r_size)
- {
- r = (pixel >> r_shift) & r_mask;
- g = (pixel >> g_shift) & g_mask;
- b = (pixel >> b_shift) & b_mask;
- r16 = r * ru_factor >> ru_shift;
- g16 = g * gu_factor >> gu_shift;
- b16 = b * bu_factor >> bu_shift;
- }
- else
- {
- r16 = g16 = b16 = 0;
- }
-
- dst[i] = a16 << 48 | r16 << 32 | g16 << 16 | b16;
- }
-}
-
static force_inline uint16_t
float_to_unorm (float f, int n_bits)
{
@@ -269,31 +178,6 @@ pixman_contract_from_float (uint32_t *dst,
}
}
-/*
- * Contracting is easier than expanding. We just need to truncate the
- * components.
- */
-void
-pixman_contract (uint32_t * dst,
- const uint64_t *src,
- int width)
-{
- int i;
-
- /* Start at the beginning so that we can do the contraction in
- * place when src == dst
- */
- for (i = 0; i < width; i++)
- {
- const uint8_t a = src[i] >> 56,
- r = src[i] >> 40,
- g = src[i] >> 24,
- b = src[i] >> 8;
-
- dst[i] = a << 24 | r << 16 | g << 8 | b;
- }
-}
-
uint32_t *
_pixman_iter_get_scanline_noop (pixman_iter_t *iter, const uint32_t *mask)
{
--
1.7.4
_______________________________________________
Pixman mailing list
Pixman@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/pixman
