--- /dev/null
+From deb3b0ab6a97f4584fe37b3ef708dcad59ceddde Mon Sep 17 00:00:00 2001
+From: Alexander Larsson <alexl@redhat.com>
+Date: Fri, 12 Mar 2010 16:23:42 +0100
+Subject: [PATCH 1/9] Add CONVERT_0565_TO_8888 macro
+
+This lets us simplify some fast paths since we get a consistent
+naming that always has 8888 and gets some value for alpha.
+---
+ pixman/pixman-private.h | 2 ++
+ 1 files changed, 2 insertions(+), 0 deletions(-)
+
+diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
+index 9dcdca7..d0bec39 100644
+--- a/pixman/pixman-private.h
++++ b/pixman/pixman-private.h
+@@ -704,6 +704,8 @@ pixman_region16_copy_from_region32 (pixman_region16_t *dst,
+ ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) | \
+ ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))
+
++#define CONVERT_0565_TO_8888(s) (CONVERT_0565_TO_0888(s) | 0xff000000)
++
+ #define PIXMAN_FORMAT_IS_WIDE(f) \
+ (PIXMAN_FORMAT_A (f) > 8 || \
+ PIXMAN_FORMAT_R (f) > 8 || \
+--
+1.6.6.1
+
--- /dev/null
+From 7c2da7f27c2dd04d9ed3db5fd13f1da26cebfa3a Mon Sep 17 00:00:00 2001
+From: Alexander Larsson <alexl@redhat.com>
+Date: Tue, 16 Mar 2010 14:18:29 +0100
+Subject: [PATCH 2/9] Add CONVERT_8888_TO_8888 and CONVERT_0565_TO_0565 macros
+
+These are useful for macroization
+---
+ pixman/pixman-private.h | 4 ++++
+ 1 files changed, 4 insertions(+), 0 deletions(-)
+
+diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
+index d0bec39..bc41249 100644
+--- a/pixman/pixman-private.h
++++ b/pixman/pixman-private.h
+@@ -706,6 +706,10 @@ pixman_region16_copy_from_region32 (pixman_region16_t *dst,
+
+ #define CONVERT_0565_TO_8888(s) (CONVERT_0565_TO_0888(s) | 0xff000000)
+
++/* Trivial versions that are useful in macros */
++#define CONVERT_8888_TO_8888(s) (s)
++#define CONVERT_0565_TO_0565(s) (s)
++
+ #define PIXMAN_FORMAT_IS_WIDE(f) \
+ (PIXMAN_FORMAT_A (f) > 8 || \
+ PIXMAN_FORMAT_R (f) > 8 || \
+--
+1.6.6.1
+
--- /dev/null
+From 6e80b9148a7f43b7b40235a57c1066fe64e371e5 Mon Sep 17 00:00:00 2001
+From: Alexander Larsson <alexl@redhat.com>
+Date: Fri, 12 Mar 2010 15:40:07 +0100
+Subject: [PATCH 3/9] Add FAST_PATH_NO_NONE_REPEAT flag
+
+---
+ pixman/pixman-image.c | 10 +++++++---
+ pixman/pixman-private.h | 1 +
+ 2 files changed, 8 insertions(+), 3 deletions(-)
+
+diff --git a/pixman/pixman-image.c b/pixman/pixman-image.c
+index d09d193..df5b457 100644
+--- a/pixman/pixman-image.c
++++ b/pixman/pixman-image.c
+@@ -335,16 +335,20 @@ compute_image_info (pixman_image_t *image)
+ /* Repeat mode */
+ switch (image->common.repeat)
+ {
++ case PIXMAN_REPEAT_NONE:
++ flags |= FAST_PATH_NO_REFLECT_REPEAT | FAST_PATH_NO_PAD_REPEAT;
++ break;
++
+ case PIXMAN_REPEAT_REFLECT:
+- flags |= FAST_PATH_NO_PAD_REPEAT;
++ flags |= FAST_PATH_NO_PAD_REPEAT | FAST_PATH_NO_NONE_REPEAT;
+ break;
+
+ case PIXMAN_REPEAT_PAD:
+- flags |= FAST_PATH_NO_REFLECT_REPEAT;
++ flags |= FAST_PATH_NO_REFLECT_REPEAT | FAST_PATH_NO_NONE_REPEAT;
+ break;
+
+ default:
+- flags |= (FAST_PATH_NO_REFLECT_REPEAT | FAST_PATH_NO_PAD_REPEAT);
++ flags |= FAST_PATH_NO_REFLECT_REPEAT | FAST_PATH_NO_PAD_REPEAT | FAST_PATH_NO_NONE_REPEAT;
+ break;
+ }
+
+diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
+index bc41249..65314b9 100644
+--- a/pixman/pixman-private.h
++++ b/pixman/pixman-private.h
+@@ -579,6 +579,7 @@ _pixman_choose_implementation (void);
+ #define FAST_PATH_SIMPLE_REPEAT (1 << 12)
+ #define FAST_PATH_IS_OPAQUE (1 << 13)
+ #define FAST_PATH_NEEDS_WORKAROUND (1 << 14)
++#define FAST_PATH_NO_NONE_REPEAT (1 << 15)
+
+ #define _FAST_PATH_STANDARD_FLAGS \
+ (FAST_PATH_ID_TRANSFORM | \
+--
+1.6.6.1
+
--- /dev/null
+From 8e7e8e3f96b094616f37fdf8a35043d7c5f64417 Mon Sep 17 00:00:00 2001
+From: Alexander Larsson <alexl@redhat.com>
+Date: Fri, 12 Mar 2010 15:41:01 +0100
+Subject: [PATCH 4/9] Add FAST_PATH_SAMPLES_COVER_CLIP and FAST_PATH_16BIT_SAFE
+
+FAST_PATH_SAMPLES_COVER_CLIP:
+
+This is set of the source sample grid, unrepeated but transformed
+completely completely covers the clip destination. If this is set
+you can use a simple scaled that doesn't have to care about the repeat
+mode.
+
+FAST_PATH_16BIT_SAFE:
+
+This signifies two things:
+1) The size of the src/mask fits in a 16.16 fixed point, so something like:
+
+ max_vx = src_image->bits.width << 16;
+
+ Is allowed and is guaranteed to not overflow max_vx
+
+2) When stepping the source space we're guaranteed to never overflow
+ a 16.16 bit fix point variable, even if we step one extra step
+ in the destination space. This means that a loop doing:
+
+ x = vx >> 16;
+ vx += unit_x; d = src_row[x];
+
+ will never overflow vx causing x to be negative.
+
+ And additionally, if you track vx like above and apply NORMAL repeat
+ after the vx addition with something like:
+
+ while (vx >= max_vx) vx -= max_vx;
+
+ This will never overflow the vx even on the final increment that
+ takes vx one past the end of where we will read, which makes the
+ repeat loop safe.
+---
+ pixman/pixman-private.h | 2 +
+ pixman/pixman.c | 84 +++++++++++++++++++++++++++++++++++++---------
+ 2 files changed, 69 insertions(+), 17 deletions(-)
+
+diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
+index 65314b9..0cf9113 100644
+--- a/pixman/pixman-private.h
++++ b/pixman/pixman-private.h
+@@ -580,6 +580,8 @@ _pixman_choose_implementation (void);
+ #define FAST_PATH_IS_OPAQUE (1 << 13)
+ #define FAST_PATH_NEEDS_WORKAROUND (1 << 14)
+ #define FAST_PATH_NO_NONE_REPEAT (1 << 15)
++#define FAST_PATH_SAMPLES_COVER_CLIP (1 << 16)
++#define FAST_PATH_16BIT_SAFE (1 << 17)
+
+ #define _FAST_PATH_STANDARD_FLAGS \
+ (FAST_PATH_ID_TRANSFORM | \
+diff --git a/pixman/pixman.c b/pixman/pixman.c
+index c71617e..e967e34 100644
+--- a/pixman/pixman.c
++++ b/pixman/pixman.c
+@@ -479,24 +479,75 @@ walk_region_internal (pixman_implementation_t *imp,
+ }
+ }
+
+-static force_inline pixman_bool_t
+-image_covers (pixman_image_t *image,
+- pixman_box32_t *extents,
+- int x,
+- int y)
++#define IS_16BIT(x) (((x) >= INT16_MIN) && ((x) <= INT16_MAX))
++
++static force_inline uint32_t
++compute_src_extents_flags (pixman_image_t *image,
++ pixman_box32_t *extents,
++ int x,
++ int y)
+ {
+- if (image->common.type == BITS &&
+- image->common.repeat == PIXMAN_REPEAT_NONE)
++ pixman_box16_t extents16;
++ uint32_t flags;
++
++ flags = FAST_PATH_COVERS_CLIP;
++
++ if (image->common.type != BITS)
++ return flags;
++
++ if (image->common.repeat == PIXMAN_REPEAT_NONE &&
++ (x > extents->x1 || y > extents->y1 ||
++ x + image->bits.width < extents->x2 ||
++ y + image->bits.height < extents->y2))
++ {
++ flags &= ~FAST_PATH_COVERS_CLIP;
++ }
++
++ if (IS_16BIT (extents->x1 - x) &&
++ IS_16BIT (extents->y1 - y) &&
++ IS_16BIT (extents->x2 - x) &&
++ IS_16BIT (extents->y2 - y))
+ {
+- if (x > extents->x1 || y > extents->y1 ||
+- x + image->bits.width < extents->x2 ||
+- y + image->bits.height < extents->y2)
++ extents16.x1 = extents->x1 - x;
++ extents16.y1 = extents->y1 - y;
++ extents16.x2 = extents->x2 - x;
++ extents16.y2 = extents->y2 - y;
++
++ if (!image->common.transform ||
++ pixman_transform_bounds (image->common.transform, &extents16))
+ {
+- return FALSE;
++ if (extents16.x1 >= 0 && extents16.y1 >= 0 &&
++ extents16.x2 <= image->bits.width &&
++ extents16.y2 <= image->bits.height)
++ {
++ flags |= FAST_PATH_SAMPLES_COVER_CLIP;
++ }
+ }
+ }
+
+- return TRUE;
++ if (IS_16BIT (extents->x1 - x - 1) &&
++ IS_16BIT (extents->y1 - y - 1) &&
++ IS_16BIT (extents->x2 - x + 1) &&
++ IS_16BIT (extents->y2 - y + 1))
++ {
++ extents16.x1 = extents->x1 - x - 1;
++ extents16.y1 = extents->y1 - y - 1;
++ extents16.x2 = extents->x2 - x + 1;
++ extents16.y2 = extents->y2 - y + 1;
++
++ if (/* src space expanded by one in dest space fits in 16 bit */
++ (!image->common.transform ||
++ pixman_transform_bounds (image->common.transform, &extents16)) &&
++ /* And src image size can be used as 16.16 fixed point */
++ image->bits.width < 0x7fff &&
++ image->bits.height < 0x7fff)
++ {
++ /* Then we're "16bit safe" */
++ flags |= FAST_PATH_16BIT_SAFE;
++ }
++ }
++
++ return flags;
+ }
+
+ static void
+@@ -581,11 +632,10 @@ do_composite (pixman_implementation_t *imp,
+
+ extents = pixman_region32_extents (®ion);
+
+- if (image_covers (src, extents, dest_x - src_x, dest_y - src_y))
+- src_flags |= FAST_PATH_COVERS_CLIP;
+-
+- if (mask && image_covers (mask, extents, dest_x - mask_x, dest_y - mask_y))
+- mask_flags |= FAST_PATH_COVERS_CLIP;
++ src_flags |= compute_src_extents_flags (src, extents, dest_x - src_x, dest_y - src_y);
++
++ if (mask)
++ mask_flags |= compute_src_extents_flags (mask, extents, dest_x - mask_x, dest_y - mask_y);
+
+ /*
+ * Check if we can replace our operator by a simpler one
+--
+1.6.6.1
+
--- /dev/null
+From def20085302693c032e81456d975454acd356acd Mon Sep 17 00:00:00 2001
+From: Alexander Larsson <alexl@redhat.com>
+Date: Fri, 12 Mar 2010 15:45:04 +0100
+Subject: [PATCH 5/9] Add specialized fast nearest scalers
+
+This is a macroized version of SRC/OVER repeat normal/unneeded nearest
+neighbour scaling instantiated for some common 8888 and 565 formats.
+
+Based on work by Siarhei Siamashka
+---
+ pixman/pixman-fast-path.c | 243 +++++++++++++++++++++++++++++++++++++++++++++
+ 1 files changed, 243 insertions(+), 0 deletions(-)
+
+diff --git a/pixman/pixman-fast-path.c b/pixman/pixman-fast-path.c
+index 4d26b0f..6607a47 100644
+--- a/pixman/pixman-fast-path.c
++++ b/pixman/pixman-fast-path.c
+@@ -27,6 +27,7 @@
+ #include <config.h>
+ #endif
+ #include <string.h>
++#include <stdlib.h>
+ #include "pixman-private.h"
+ #include "pixman-combine32.h"
+
+@@ -1373,6 +1374,208 @@ repeat (pixman_repeat_t repeat, int *c, int size)
+ return TRUE;
+ }
+
++/* A macroified version of specialized nearest scalers for some
++ * common 8888 and 565 formats. It supports SRC and OVER ops.
++ *
++ * There are two repeat versions, one that handles repeat normal,
++ * and one without repeat handling that only works if the src region
++ * used is completely covered by the pre-repeated source samples.
++ *
++ * The loops are unrolled to process two pixels per iteration for better
++ * performance on most CPU architectures (superscalar processors
++ * can issue several operations simultaneously, other processors can hide
++ * instructions latencies by pipelining operations). Unrolling more
++ * does not make much sense because the compiler will start running out
++ * of spare registers soon.
++ */
++
++#define GET_8888_ALPHA(s) ((s) >> 24)
++ /* This is not actually used since we don't have an OVER with
++ 565 source, but it is needed to build. */
++#define GET_0565_ALPHA(s) 0xff
++
++#define FAST_NEAREST(scale_func_name, SRC_FORMAT, DST_FORMAT, \
++ src_type_t, dst_type_t, OP, do_repeat) \
++static void \
++fast_composite_scaled_nearest_ ## scale_func_name ## _ ## OP (pixman_implementation_t *imp, \
++ pixman_op_t op, \
++ pixman_image_t * src_image, \
++ pixman_image_t * mask_image, \
++ pixman_image_t * dst_image, \
++ int32_t src_x, \
++ int32_t src_y, \
++ int32_t mask_x, \
++ int32_t mask_y, \
++ int32_t dst_x, \
++ int32_t dst_y, \
++ int32_t width, \
++ int32_t height) \
++{ \
++ dst_type_t *dst_line; \
++ src_type_t *src_first_line; \
++ uint32_t d; \
++ src_type_t s1, s2; \
++ uint8_t a1, a2; \
++ int w; \
++ int x1, x2, y; \
++ pixman_fixed_t orig_vx; \
++ pixman_fixed_t max_vx, max_vy; \
++ pixman_vector_t v; \
++ pixman_fixed_t vx, vy; \
++ pixman_fixed_t unit_x, unit_y; \
++ \
++ src_type_t *src; \
++ dst_type_t *dst; \
++ int src_stride, dst_stride; \
++ \
++ if (PIXMAN_OP_ ## OP != PIXMAN_OP_SRC && PIXMAN_OP_ ## OP != PIXMAN_OP_OVER) \
++ abort(); \
++ \
++ PIXMAN_IMAGE_GET_LINE (dst_image, dst_x, dst_y, dst_type_t, dst_stride, dst_line, 1); \
++ /* pass in 0 instead of src_x and src_y because src_x and src_y need to be \
++ * transformed from destination space to source space */ \
++ PIXMAN_IMAGE_GET_LINE (src_image, 0, 0, src_type_t, src_stride, src_first_line, 1); \
++ \
++ /* reference point is the center of the pixel */ \
++ v.vector[0] = pixman_int_to_fixed (src_x) + pixman_fixed_1 / 2; \
++ v.vector[1] = pixman_int_to_fixed (src_y) + pixman_fixed_1 / 2; \
++ v.vector[2] = pixman_fixed_1; \
++ \
++ if (!pixman_transform_point_3d (src_image->common.transform, &v)) \
++ return; \
++ \
++ unit_x = src_image->common.transform->matrix[0][0]; \
++ unit_y = src_image->common.transform->matrix[1][1]; \
++ \
++ /* Round down to closest integer, ensuring that 0.5 rounds to 0, not 1 */ \
++ v.vector[0] -= pixman_fixed_e; \
++ v.vector[1] -= pixman_fixed_e; \
++ \
++ vx = v.vector[0]; \
++ vy = v.vector[1]; \
++ \
++ if (do_repeat) \
++ { \
++ /* Clamp repeating positions inside the actual samples */ \
++ max_vx = src_image->bits.width << 16; \
++ max_vy = src_image->bits.height << 16; \
++ \
++ repeat (PIXMAN_REPEAT_NORMAL, &vx, max_vx); \
++ repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); \
++ } \
++ \
++ orig_vx = vx; \
++ \
++ while (--height >= 0) \
++ { \
++ dst = dst_line; \
++ dst_line += dst_stride; \
++ \
++ y = vy >> 16; \
++ vy += unit_y; \
++ if (do_repeat) \
++ repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); \
++ \
++ src = src_first_line + src_stride * y; \
++ \
++ w = width; \
++ vx = orig_vx; \
++ while ((w -= 2) >= 0) \
++ { \
++ x1 = vx >> 16; \
++ vx += unit_x; \
++ if (do_repeat) \
++ repeat (PIXMAN_REPEAT_NORMAL, &vx, max_vx); \
++ s1 = src[x1]; \
++ \
++ x2 = vx >> 16; \
++ vx += unit_x; \
++ if (do_repeat) \
++ repeat (PIXMAN_REPEAT_NORMAL, &vx, max_vx); \
++ s2 = src[x2]; \
++ \
++ if (PIXMAN_OP_ ## OP == PIXMAN_OP_OVER) \
++ { \
++ a1 = GET_ ## SRC_FORMAT ## _ALPHA(s1); \
++ a2 = GET_ ## SRC_FORMAT ## _ALPHA(s2); \
++ \
++ if (a1 == 0xff) \
++ { \
++ *dst = CONVERT_ ## SRC_FORMAT ## _TO_ ## DST_FORMAT (s1); \
++ } \
++ else if (s1) \
++ { \
++ d = CONVERT_## DST_FORMAT ## _TO_8888 (*dst); \
++ a1 ^= 0xff; \
++ UN8x4_MUL_UN8_ADD_UN8x4 (d, a1, s1); \
++ *dst = CONVERT_8888_TO_ ## DST_FORMAT (d); \
++ } \
++ dst++; \
++ \
++ if (a2 == 0xff) \
++ { \
++ *dst = CONVERT_ ## SRC_FORMAT ## _TO_ ## DST_FORMAT (s2); \
++ } \
++ else if (s2) \
++ { \
++ d = CONVERT_## DST_FORMAT ## _TO_8888 (*dst); \
++ a2 ^= 0xff; \
++ UN8x4_MUL_UN8_ADD_UN8x4 (d, a2, s2); \
++ *dst = CONVERT_8888_TO_ ## DST_FORMAT (d); \
++ } \
++ dst++; \
++ } \
++ else /* PIXMAN_OP_SRC */ \
++ { \
++ *dst++ = CONVERT_ ## SRC_FORMAT ## _TO_ ## DST_FORMAT (s1); \
++ *dst++ = CONVERT_ ## SRC_FORMAT ## _TO_ ## DST_FORMAT (s2); \
++ } \
++ } \
++ \
++ if (w & 1) \
++ { \
++ x1 = vx >> 16; \
++ vx += unit_x; \
++ if (do_repeat) \
++ repeat (PIXMAN_REPEAT_NORMAL, &vx, max_vx); \
++ s1 = src[x1]; \
++ \
++ if (PIXMAN_OP_ ## OP == PIXMAN_OP_OVER) \
++ { \
++ a1 = GET_ ## SRC_FORMAT ## _ALPHA(s1); \
++ \
++ if (a1 == 0xff) \
++ { \
++ *dst = CONVERT_ ## SRC_FORMAT ## _TO_ ## DST_FORMAT (s1); \
++ } \
++ else if (s1) \
++ { \
++ d = CONVERT_## DST_FORMAT ## _TO_8888 (*dst); \
++ a1 ^= 0xff; \
++ UN8x4_MUL_UN8_ADD_UN8x4 (d, a1, s1); \
++ *dst = CONVERT_8888_TO_ ## DST_FORMAT (d); \
++ } \
++ dst++; \
++ } \
++ else /* PIXMAN_OP_SRC */ \
++ { \
++ *dst++ = CONVERT_ ## SRC_FORMAT ## _TO_ ## DST_FORMAT (s1); \
++ } \
++ } \
++ } \
++}
++
++FAST_NEAREST(x888_x888_none, 8888, 8888, uint32_t, uint32_t, SRC, /*repeat: */ 0);
++FAST_NEAREST(x888_x888_normal, 8888, 8888, uint32_t, uint32_t, SRC, /*repeat: */ 1);
++FAST_NEAREST(x888_x888_none, 8888, 8888, uint32_t, uint32_t, OVER, /*repeat: */ 0);
++FAST_NEAREST(x888_x888_normal, 8888, 8888, uint32_t, uint32_t, OVER, /*repeat: */ 1);
++FAST_NEAREST(x888_565_none, 8888, 0565, uint32_t, uint16_t, SRC, /*repeat: */ 0);
++FAST_NEAREST(x888_565_normal, 8888, 0565, uint32_t, uint16_t, SRC, /*repeat: */ 1);
++FAST_NEAREST(565_565_none, 0565, 0565, uint16_t, uint16_t, SRC, /*repeat: */ 0);
++FAST_NEAREST(565_565_normal, 0565, 0565, uint16_t, uint16_t, SRC, /*repeat: */ 1);
++FAST_NEAREST(8888_565_none, 8888, 0565, uint32_t, uint16_t, OVER, /*repeat: */ 0);
++FAST_NEAREST(8888_565_normal, 8888, 0565, uint32_t, uint16_t, OVER, /*repeat: */ 1);
++
+ static force_inline uint32_t
+ fetch_nearest (pixman_repeat_t src_repeat,
+ pixman_format_code_t format,
+@@ -1595,6 +1798,46 @@ static const pixman_fast_path_t c_fast_paths[] =
+ FAST_PATH_NO_ACCESSORS | \
+ FAST_PATH_NO_WIDE_FORMAT)
+
++#define HAS_NORMAL_REPEAT_FLAGS \
++ (FAST_PATH_NO_REFLECT_REPEAT | \
++ FAST_PATH_NO_PAD_REPEAT | \
++ FAST_PATH_NO_NONE_REPEAT)
++
++#define SIMPLE_NEAREST_FAST_PATH(op,s,d,func) \
++ { PIXMAN_OP_ ## op, \
++ PIXMAN_ ## s, \
++ SCALED_NEAREST_FLAGS | HAS_NORMAL_REPEAT_FLAGS | FAST_PATH_16BIT_SAFE, \
++ PIXMAN_null, 0, \
++ PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS, \
++ fast_composite_scaled_nearest_ ## func ## _normal ## _ ## op, \
++ }, \
++ { PIXMAN_OP_ ## op, \
++ PIXMAN_ ## s, \
++ SCALED_NEAREST_FLAGS | FAST_PATH_SAMPLES_COVER_CLIP, \
++ PIXMAN_null, 0, \
++ PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS, \
++ fast_composite_scaled_nearest_ ## func ## _none ## _ ## op, \
++ }
++ SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8, x888_x888),
++ SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8, x888_x888),
++ SIMPLE_NEAREST_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8, x888_x888),
++ SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8, x888_x888),
++
++ SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8, x888_x888),
++ SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8, x888_x888),
++
++ SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, r5g6b5, x888_565),
++ SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, r5g6b5, x888_565),
++
++ SIMPLE_NEAREST_FAST_PATH (SRC, r5g6b5, r5g6b5, 565_565),
++
++ SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, x888_x888),
++ SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, x888_x888),
++ SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, x888_x888),
++ SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, x888_x888),
++
++ SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, r5g6b5, 8888_565),
++
+ #define NEAREST_FAST_PATH(op,s,d) \
+ { PIXMAN_OP_ ## op, \
+ PIXMAN_ ## s, SCALED_NEAREST_FLAGS, \
+--
+1.6.6.1
+
--- /dev/null
+From 8d1125fd6a25a0d1d758fd93384bf1baf07bcdf0 Mon Sep 17 00:00:00 2001
+From: Siarhei Siamashka <siarhei.siamashka@nokia.com>
+Date: Tue, 16 Mar 2010 16:55:28 +0100
+Subject: [PATCH 6/9] Generic C implementation of pixman_blt with overlapping support
+
+Uses memcpy/memmove functions to copy pixels, can handle the
+case when both source and destination areas are in the same
+image (this is useful for scrolling).
+
+It is assumed that copying direction is only important when
+using the same image for both source and destination (and
+src_stride == dst_stride). Copying direction is undefined
+for the images with different source and destination stride
+which happen to be in the overlapped areas (but this is an
+unrealistic case anyway).
+---
+ pixman/pixman-general.c | 21 ++++++++++++++++++---
+ pixman/pixman-private.h | 43 +++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 61 insertions(+), 3 deletions(-)
+
+diff --git a/pixman/pixman-general.c b/pixman/pixman-general.c
+index bddf79a..f525744 100644
+--- a/pixman/pixman-general.c
++++ b/pixman/pixman-general.c
+@@ -285,9 +285,24 @@ general_blt (pixman_implementation_t *imp,
+ int width,
+ int height)
+ {
+- /* We can't blit unless we have sse2 or mmx */
+-
+- return FALSE;
++ uint8_t *dst_bytes = (uint8_t *)dst_bits;
++ uint8_t *src_bytes = (uint8_t *)src_bits;
++ int bpp;
++
++ if (src_bpp != dst_bpp || src_bpp & 7)
++ return FALSE;
++
++ bpp = src_bpp >> 3;
++ width *= bpp;
++ src_stride *= 4;
++ dst_stride *= 4;
++ pixman_blt_helper (src_bytes + src_y * src_stride + src_x * bpp,
++ dst_bytes + dst_y * dst_stride + dst_x * bpp,
++ src_stride,
++ dst_stride,
++ width,
++ height);
++ return TRUE;
+ }
+
+ static pixman_bool_t
+diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
+index 0cf9113..3478e1b 100644
+--- a/pixman/pixman-private.h
++++ b/pixman/pixman-private.h
+@@ -10,6 +10,7 @@
+
+ #include "pixman.h"
+ #include <time.h>
++#include <string.h>
+ #include <assert.h>
+ #include <stdio.h>
+ #include <string.h>
+@@ -866,4 +867,46 @@ void pixman_timer_register (pixman_timer_t *timer);
+
+ #endif /* PIXMAN_TIMERS */
+
++/* a helper function, can blit 8-bit images with src/dst overlapping support */
++static inline void
++pixman_blt_helper (uint8_t *src_bytes,
++ uint8_t *dst_bytes,
++ int src_stride,
++ int dst_stride,
++ int width,
++ int height)
++{
++ /*
++ * The second part of this check is not strictly needed, but it prevents
++ * unnecessary upside-down processing of areas which belong to different
++ * images. Upside-down processing can be slower with fixed-distance-ahead
++ * prefetch and perceived as having more tearing.
++ */
++ if (src_bytes < dst_bytes + width &&
++ src_bytes + src_stride * height > dst_bytes)
++ {
++ src_bytes += src_stride * height - src_stride;
++ dst_bytes += dst_stride * height - dst_stride;
++ dst_stride = -dst_stride;
++ src_stride = -src_stride;
++ /* Horizontal scrolling to the left needs memmove */
++ if (src_bytes + width > dst_bytes)
++ {
++ while (--height >= 0)
++ {
++ memmove (dst_bytes, src_bytes, width);
++ dst_bytes += dst_stride;
++ src_bytes += src_stride;
++ }
++ return;
++ }
++ }
++ while (--height >= 0)
++ {
++ memcpy (dst_bytes, src_bytes, width);
++ dst_bytes += dst_stride;
++ src_bytes += src_stride;
++ }
++}
++
+ #endif /* PIXMAN_PRIVATE_H */
+--
+1.6.6.1
+
--- /dev/null
+From ac9b18e8aefad1992c3057dc3cf7c309f14544d2 Mon Sep 17 00:00:00 2001
+From: Siarhei Siamashka <siarhei.siamashka@nokia.com>
+Date: Thu, 22 Oct 2009 05:45:47 +0300
+Subject: [PATCH 7/9] Support of overlapping src/dst for pixman_blt_mmx
+
+---
+ pixman/pixman-mmx.c | 55 +++++++++++++++++++++++++++++---------------------
+ 1 files changed, 32 insertions(+), 23 deletions(-)
+
+diff --git a/pixman/pixman-mmx.c b/pixman/pixman-mmx.c
+index e084e7f..6212b31 100644
+--- a/pixman/pixman-mmx.c
++++ b/pixman/pixman-mmx.c
+@@ -2994,34 +2994,43 @@ pixman_blt_mmx (uint32_t *src_bits,
+ {
+ uint8_t * src_bytes;
+ uint8_t * dst_bytes;
+- int byte_width;
++ int bpp;
+
+- if (src_bpp != dst_bpp)
++ if (src_bpp != dst_bpp || src_bpp & 7)
+ return FALSE;
+
+- if (src_bpp == 16)
+- {
+- src_stride = src_stride * (int) sizeof (uint32_t) / 2;
+- dst_stride = dst_stride * (int) sizeof (uint32_t) / 2;
+- src_bytes = (uint8_t *)(((uint16_t *)src_bits) + src_stride * (src_y) + (src_x));
+- dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+- byte_width = 2 * width;
+- src_stride *= 2;
+- dst_stride *= 2;
+- }
+- else if (src_bpp == 32)
++ bpp = src_bpp >> 3;
++ width *= bpp;
++ src_stride *= 4;
++ dst_stride *= 4;
++ src_bytes = (uint8_t *)src_bits + src_y * src_stride + src_x * bpp;
++ dst_bytes = (uint8_t *)dst_bits + dst_y * dst_stride + dst_x * bpp;
++
++ if (src_bpp != 16 && src_bpp != 32)
+ {
+- src_stride = src_stride * (int) sizeof (uint32_t) / 4;
+- dst_stride = dst_stride * (int) sizeof (uint32_t) / 4;
+- src_bytes = (uint8_t *)(((uint32_t *)src_bits) + src_stride * (src_y) + (src_x));
+- dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+- byte_width = 4 * width;
+- src_stride *= 4;
+- dst_stride *= 4;
++ pixman_blt_helper (src_bytes, dst_bytes, src_stride, dst_stride,
++ width, height);
++ return TRUE;
+ }
+- else
++
++ if (src_bytes < dst_bytes && src_bytes + src_stride * height > dst_bytes)
+ {
+- return FALSE;
++ src_bytes += src_stride * height - src_stride;
++ dst_bytes += dst_stride * height - dst_stride;
++ dst_stride = -dst_stride;
++ src_stride = -src_stride;
++
++ if (src_bytes + width > dst_bytes)
++ {
++ /* TODO: reverse scanline copy using MMX */
++ while (--height >= 0)
++ {
++ memmove (dst_bytes, src_bytes, width);
++ dst_bytes += dst_stride;
++ src_bytes += src_stride;
++ }
++ return TRUE;
++ }
+ }
+
+ while (height--)
+@@ -3031,7 +3040,7 @@ pixman_blt_mmx (uint32_t *src_bits,
+ uint8_t *d = dst_bytes;
+ src_bytes += src_stride;
+ dst_bytes += dst_stride;
+- w = byte_width;
++ w = width;
+
+ while (w >= 2 && ((unsigned long)d & 3))
+ {
+--
+1.6.6.1
+
--- /dev/null
+From f6d6ad1063e29a95bad4c4a2e43f3ecf90344ef7 Mon Sep 17 00:00:00 2001
+From: Siarhei Siamashka <siarhei.siamashka@nokia.com>
+Date: Thu, 22 Oct 2009 05:45:54 +0300
+Subject: [PATCH 8/9] Support of overlapping src/dst for pixman_blt_sse2
+
+---
+ pixman/pixman-sse2.c | 55 +++++++++++++++++++++++++++++--------------------
+ 1 files changed, 32 insertions(+), 23 deletions(-)
+
+diff --git a/pixman/pixman-sse2.c b/pixman/pixman-sse2.c
+index 946e7ba..66053ae 100644
+--- a/pixman/pixman-sse2.c
++++ b/pixman/pixman-sse2.c
+@@ -5299,34 +5299,43 @@ pixman_blt_sse2 (uint32_t *src_bits,
+ {
+ uint8_t * src_bytes;
+ uint8_t * dst_bytes;
+- int byte_width;
++ int bpp;
+
+- if (src_bpp != dst_bpp)
++ if (src_bpp != dst_bpp || src_bpp & 7)
+ return FALSE;
+
+- if (src_bpp == 16)
+- {
+- src_stride = src_stride * (int) sizeof (uint32_t) / 2;
+- dst_stride = dst_stride * (int) sizeof (uint32_t) / 2;
+- src_bytes =(uint8_t *)(((uint16_t *)src_bits) + src_stride * (src_y) + (src_x));
+- dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+- byte_width = 2 * width;
+- src_stride *= 2;
+- dst_stride *= 2;
+- }
+- else if (src_bpp == 32)
++ bpp = src_bpp >> 3;
++ width *= bpp;
++ src_stride *= 4;
++ dst_stride *= 4;
++ src_bytes = (uint8_t *)src_bits + src_y * src_stride + src_x * bpp;
++ dst_bytes = (uint8_t *)dst_bits + dst_y * dst_stride + dst_x * bpp;
++
++ if (src_bpp != 16 && src_bpp != 32)
+ {
+- src_stride = src_stride * (int) sizeof (uint32_t) / 4;
+- dst_stride = dst_stride * (int) sizeof (uint32_t) / 4;
+- src_bytes = (uint8_t *)(((uint32_t *)src_bits) + src_stride * (src_y) + (src_x));
+- dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+- byte_width = 4 * width;
+- src_stride *= 4;
+- dst_stride *= 4;
++ pixman_blt_helper (src_bytes, dst_bytes, src_stride, dst_stride,
++ width, height);
++ return TRUE;
+ }
+- else
++
++ if (src_bytes < dst_bytes && src_bytes + src_stride * height > dst_bytes)
+ {
+- return FALSE;
++ src_bytes += src_stride * height - src_stride;
++ dst_bytes += dst_stride * height - dst_stride;
++ dst_stride = -dst_stride;
++ src_stride = -src_stride;
++
++ if (src_bytes + width > dst_bytes)
++ {
++ /* TODO: reverse scanline copy using SSE2 */
++ while (--height >= 0)
++ {
++ memmove (dst_bytes, src_bytes, width);
++ dst_bytes += dst_stride;
++ src_bytes += src_stride;
++ }
++ return TRUE;
++ }
+ }
+
+ cache_prefetch ((__m128i*)src_bytes);
+@@ -5339,7 +5348,7 @@ pixman_blt_sse2 (uint32_t *src_bits,
+ uint8_t *d = dst_bytes;
+ src_bytes += src_stride;
+ dst_bytes += dst_stride;
+- w = byte_width;
++ w = width;
+
+ cache_prefetch_next ((__m128i*)s);
+ cache_prefetch_next ((__m128i*)d);
+--
+1.6.6.1
+
--- /dev/null
+From 41572ca5aa9e50e4d1000b3da1e6ee43c6f4088a Mon Sep 17 00:00:00 2001
+From: Siarhei Siamashka <siarhei.siamashka@nokia.com>
+Date: Wed, 18 Nov 2009 06:08:48 +0200
+Subject: [PATCH 9/9] Support of overlapping src/dst for pixman_blt_neon
+
+---
+ pixman/pixman-arm-neon.c | 62 +++++++++++++++++++++++++++++++++++++--------
+ 1 files changed, 51 insertions(+), 11 deletions(-)
+
+diff --git a/pixman/pixman-arm-neon.c b/pixman/pixman-arm-neon.c
+index 24ceeeb..134493d 100644
+--- a/pixman/pixman-arm-neon.c
++++ b/pixman/pixman-arm-neon.c
+@@ -360,26 +360,66 @@ pixman_blt_neon (uint32_t *src_bits,
+ int width,
+ int height)
+ {
+- if (src_bpp != dst_bpp)
++ uint8_t * src_bytes;
++ uint8_t * dst_bytes;
++ int bpp;
++
++ if (src_bpp != dst_bpp || src_bpp & 7)
+ return FALSE;
+
++ bpp = src_bpp >> 3;
++ width *= bpp;
++ src_stride *= 4;
++ dst_stride *= 4;
++ src_bytes = (uint8_t *)src_bits + src_y * src_stride + src_x * bpp;
++ dst_bytes = (uint8_t *)dst_bits + dst_y * dst_stride + dst_x * bpp;
++
++ if (src_bpp != 16 && src_bpp != 32)
++ {
++ pixman_blt_helper (src_bytes, dst_bytes, src_stride, dst_stride,
++ width, height);
++ return TRUE;
++ }
++
++ if (src_bytes < dst_bytes && src_bytes + src_stride * height > dst_bytes)
++ {
++ src_bytes += src_stride * height - src_stride;
++ dst_bytes += dst_stride * height - dst_stride;
++ dst_stride = -dst_stride;
++ src_stride = -src_stride;
++
++ if (src_bytes + width > dst_bytes)
++ {
++ /* TODO: reverse scanline copy using NEON */
++ while (--height >= 0)
++ {
++ memmove (dst_bytes, src_bytes, width);
++ dst_bytes += dst_stride;
++ src_bytes += src_stride;
++ }
++ return TRUE;
++ }
++ }
++
+ switch (src_bpp)
+ {
+ case 16:
+ pixman_composite_src_0565_0565_asm_neon (
+- width, height,
+- (uint16_t *)(((char *) dst_bits) +
+- dst_y * dst_stride * 4 + dst_x * 2), dst_stride * 2,
+- (uint16_t *)(((char *) src_bits) +
+- src_y * src_stride * 4 + src_x * 2), src_stride * 2);
++ width >> 1,
++ height,
++ (uint16_t *) dst_bytes,
++ dst_stride >> 1,
++ (uint16_t *) src_bytes,
++ src_stride >> 1);
+ return TRUE;
+ case 32:
+ pixman_composite_src_8888_8888_asm_neon (
+- width, height,
+- (uint32_t *)(((char *) dst_bits) +
+- dst_y * dst_stride * 4 + dst_x * 4), dst_stride,
+- (uint32_t *)(((char *) src_bits) +
+- src_y * src_stride * 4 + src_x * 4), src_stride);
++ width >> 2,
++ height,
++ (uint32_t *) dst_bytes,
++ dst_stride >> 2,
++ (uint32_t *) src_bytes,
++ src_stride >> 2);
+ return TRUE;
+ default:
+ return FALSE;
+--
+1.6.6.1
+
DESCRIPTION = "Low-level pixel manipulation library."
LICENSE = "X11"
-PV = "0.17.8"
-PR = "r8"
+PV = "0.17.10"
+PR = "r0"
PR_append = "+gitr${SRCREV}"
BBCLASSEXTEND="native"
-SRCREV = "7a15fa25ddb88ebb4ac00772854271f102f06e81"
+SRCREV = "313353f1fb9d40d0c3aaf7cfb99ca978b29003a4"
DEFAULT_PREFERENCE = "-1"
-SRC_URI = "git://anongit.freedesktop.org/~sandmann/pixman;protocol=git;branch=flags \
- file://0003-Generic-C-implementation-of-pixman_blt-with-overlapp.patch;patch=1 \
- file://0004-Support-of-overlapping-src-dst-for-pixman_blt_mmx.patch;patch=1 \
- file://0005-Support-of-overlapping-src-dst-for-pixman_blt_sse2.patch;patch=1 \
- file://0006-Support-of-overlapping-src-dst-for-pixman_blt_neon.patch;patch=1 \
- file://1-composite.patch;patch=1 \
- file://2-composite.patch;patch=1 \
- file://3-composite.patch;patch=1 \
+SRC_URI = "git://anongit.freedesktop.org/pixman;protocol=git;branch=master \
+ file://0001-Add-CONVERT_0565_TO_8888-macro.patch;patch=1 \
+ file://0002-Add-CONVERT_8888_TO_8888-and-CONVERT_0565_TO_0565-ma.patch;patch=1 \
+ file://0003-Add-FAST_PATH_NO_NONE_REPEAT-flag.patch;patch=1 \
+ file://0004-Add-FAST_PATH_SAMPLES_COVER_CLIP-and-FAST_PATH_16BIT.patch;patch=1 \
+ file://0005-Add-specialized-fast-nearest-scalers.patch;patch=1 \
+ file://0006-Generic-C-implementation-of-pixman_blt-with-overlapp.patch;patch=1 \
+ file://0007-Support-of-overlapping-src-dst-for-pixman_blt_mmx.patch;patch=1 \
+ file://0008-Support-of-overlapping-src-dst-for-pixman_blt_sse2.patch;patch=1 \
+ file://0009-Support-of-overlapping-src-dst-for-pixman_blt_neon.patch;patch=1 \
file://over-n-8-0565.patch;patch=1 \
file://src-8888-0565.patch;patch=1 \
"
git.openpandora.org / openembedded.git / commitdiff