pixman git: update to 0.17.10 + ~alexl/alex-scaler2 + overlapped blt

10 files changed, 962 insertions, 11 deletions

diff --git a/recipes/xorg-lib/pixman/0001-Add-CONVERT_0565_TO_8888-macro.patch b/recipes/xorg-lib/pixman/0001-Add-CONVERT_0565_TO_8888-macro.patch
new file mode 100644
index 0000000000..4caf6393fc
--- /dev/null
+++ b/recipes/xorg-lib/pixman/0001-Add-CONVERT_0565_TO_8888-macro.patch
@@ -0,0 +1,27 @@
+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
+
diff --git a/recipes/xorg-lib/pixman/0002-Add-CONVERT_8888_TO_8888-and-CONVERT_0565_TO_0565-ma.patch b/recipes/xorg-lib/pixman/0002-Add-CONVERT_8888_TO_8888-and-CONVERT_0565_TO_0565-ma.patch
new file mode 100644
index 0000000000..871ce75078
--- /dev/null
+++ b/recipes/xorg-lib/pixman/0002-Add-CONVERT_8888_TO_8888-and-CONVERT_0565_TO_0565-ma.patch
@@ -0,0 +1,28 @@
+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
+
diff --git a/recipes/xorg-lib/pixman/0003-Add-FAST_PATH_NO_NONE_REPEAT-flag.patch b/recipes/xorg-lib/pixman/0003-Add-FAST_PATH_NO_NONE_REPEAT-flag.patch
new file mode 100644
index 0000000000..d9a79985a8
--- /dev/null
+++ b/recipes/xorg-lib/pixman/0003-Add-FAST_PATH_NO_NONE_REPEAT-flag.patch
@@ -0,0 +1,53 @@
+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
+
diff --git a/recipes/xorg-lib/pixman/0004-Add-FAST_PATH_SAMPLES_COVER_CLIP-and-FAST_PATH_16BIT.patch b/recipes/xorg-lib/pixman/0004-Add-FAST_PATH_SAMPLES_COVER_CLIP-and-FAST_PATH_16BIT.patch
new file mode 100644
index 0000000000..eb388475d9
--- /dev/null
+++ b/recipes/xorg-lib/pixman/0004-Add-FAST_PATH_SAMPLES_COVER_CLIP-and-FAST_PATH_16BIT.patch
@@ -0,0 +1,167 @@
+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 (&region);
+     
+-    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
+
diff --git a/recipes/xorg-lib/pixman/0005-Add-specialized-fast-nearest-scalers.patch b/recipes/xorg-lib/pixman/0005-Add-specialized-fast-nearest-scalers.patch
new file mode 100644
index 0000000000..6be7b9312c
--- /dev/null
+++ b/recipes/xorg-lib/pixman/0005-Add-specialized-fast-nearest-scalers.patch
@@ -0,0 +1,284 @@
+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
+
diff --git a/recipes/xorg-lib/pixman/0006-Generic-C-implementation-of-pixman_blt-with-overlapp.patch b/recipes/xorg-lib/pixman/0006-Generic-C-implementation-of-pixman_blt-with-overlapp.patch
new file mode 100644
index 0000000000..8b265c0d74
--- /dev/null
+++ b/recipes/xorg-lib/pixman/0006-Generic-C-implementation-of-pixman_blt-with-overlapp.patch
@@ -0,0 +1,114 @@
+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
+
diff --git a/recipes/xorg-lib/pixman/0007-Support-of-overlapping-src-dst-for-pixman_blt_mmx.patch b/recipes/xorg-lib/pixman/0007-Support-of-overlapping-src-dst-for-pixman_blt_mmx.patch
new file mode 100644
index 0000000000..f9a812e376
--- /dev/null
+++ b/recipes/xorg-lib/pixman/0007-Support-of-overlapping-src-dst-for-pixman_blt_mmx.patch
@@ -0,0 +1,91 @@
+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
+
diff --git a/recipes/xorg-lib/pixman/0008-Support-of-overlapping-src-dst-for-pixman_blt_sse2.patch b/recipes/xorg-lib/pixman/0008-Support-of-overlapping-src-dst-for-pixman_blt_sse2.patch
new file mode 100644
index 0000000000..5b311fe81f
--- /dev/null
+++ b/recipes/xorg-lib/pixman/0008-Support-of-overlapping-src-dst-for-pixman_blt_sse2.patch
@@ -0,0 +1,91 @@
+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
+
diff --git a/recipes/xorg-lib/pixman/0009-Support-of-overlapping-src-dst-for-pixman_blt_neon.patch b/recipes/xorg-lib/pixman/0009-Support-of-overlapping-src-dst-for-pixman_blt_neon.patch
new file mode 100644
index 0000000000..ae7b043194
--- /dev/null
+++ b/recipes/xorg-lib/pixman/0009-Support-of-overlapping-src-dst-for-pixman_blt_neon.patch
@@ -0,0 +1,94 @@
+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
+
diff --git a/recipes/xorg-lib/pixman_git.bb b/recipes/xorg-lib/pixman_git.bb
index b15fc355f7..5080438cbc 100644
--- a/recipes/xorg-lib/pixman_git.bb
+++ b/recipes/xorg-lib/pixman_git.bb
@@ -3,24 +3,26 @@ PRIORITY = "optional"
 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 \
 "