svn merge ^/branches/released .

9 files changed, 175 insertions, 200 deletions

diff --git a/pixman/pixman/pixman-arm-neon-asm.S b/pixman/pixman/pixman-arm-neon-asm.S
index 108abacd1..8ddbefc87 100644
--- a/pixman/pixman/pixman-arm-neon-asm.S
+++ b/pixman/pixman/pixman-arm-neon-asm.S
@@ -388,6 +388,7 @@ generate_composite_function \
     vld1.16     {d4, d5}, [DST_R, :128]!

     vst1.16     {d28, d29}, [DST_W, :128]!

     pixman_composite_over_n_0565_process_pixblock_head

+    cache_preload 8, 8

 .endm

 

 .macro pixman_composite_over_n_0565_init

@@ -710,6 +711,7 @@ generate_composite_function_single_scanline \
     vld4.8      {d4, d5, d6, d7}, [DST_R, :128]!

     vst4.8      {d28, d29, d30, d31}, [DST_W, :128]!

     pixman_composite_over_8888_8888_process_pixblock_head

+    cache_preload 8, 8

 .endm

 

 .macro pixman_composite_over_n_8888_init

@@ -1870,3 +1872,104 @@ generate_composite_function \
     10,  /* dst_r_basereg */ \

     8,  /* src_basereg   */ \

     15  /* mask_basereg  */

+

+/******************************************************************************/

+

+.macro pixman_composite_add_0565_8_0565_process_pixblock_head

+    /* mask is in d15 */

+    convert_0565_to_x888 q4, d2, d1, d0

+    convert_0565_to_x888 q5, d6, d5, d4

+    /* source pixel data is in      {d0, d1, d2, XX} */

+    /* destination pixel data is in {d4, d5, d6, XX} */

+    vmull.u8    q6,  d15, d2

+    vmull.u8    q5,  d15, d1

+    vmull.u8    q4,  d15, d0

+    vrshr.u16   q12, q6,  #8

+    vrshr.u16   q11, q5,  #8

+    vrshr.u16   q10, q4,  #8

+    vraddhn.u16 d2,  q6,  q12

+    vraddhn.u16 d1,  q5,  q11

+    vraddhn.u16 d0,  q4,  q10

+.endm

+

+.macro pixman_composite_add_0565_8_0565_process_pixblock_tail

+    vqadd.u8    q0,  q0,  q2

+    vqadd.u8    q1,  q1,  q3

+    /* 32bpp result is in {d0, d1, d2, XX} */

+    convert_8888_to_0565 d2, d1, d0, q14, q15, q3

+.endm

+

+/* TODO: expand macros and do better instructions scheduling */

+.macro pixman_composite_add_0565_8_0565_process_pixblock_tail_head

+    vld1.8     {d15}, [MASK]!

+    pixman_composite_add_0565_8_0565_process_pixblock_tail

+    vld1.16    {d8, d9}, [SRC]!

+    vld1.16    {d10, d11}, [DST_R, :128]!

+    cache_preload 8, 8

+    pixman_composite_add_0565_8_0565_process_pixblock_head

+    vst1.16    {d28, d29}, [DST_W, :128]!

+.endm

+

+generate_composite_function \

+    pixman_composite_add_0565_8_0565_asm_neon, 16, 8, 16, \

+    FLAG_DST_READWRITE, \

+    8, /* number of pixels, processed in a single block */ \

+    5, /* prefetch distance */ \

+    default_init_need_all_regs, \

+    default_cleanup_need_all_regs, \

+    pixman_composite_add_0565_8_0565_process_pixblock_head, \

+    pixman_composite_add_0565_8_0565_process_pixblock_tail, \

+    pixman_composite_add_0565_8_0565_process_pixblock_tail_head, \

+    28, /* dst_w_basereg */ \

+    10, /* dst_r_basereg */ \

+    8,  /* src_basereg   */ \

+    15  /* mask_basereg  */

+

+/******************************************************************************/

+

+.macro pixman_composite_out_reverse_8_0565_process_pixblock_head

+    /* mask is in d15 */

+    convert_0565_to_x888 q5, d6, d5, d4

+    /* destination pixel data is in {d4, d5, d6, xx} */

+    vmvn.8      d24, d15 /* get inverted alpha */

+    /* now do alpha blending */

+    vmull.u8    q8, d24, d4

+    vmull.u8    q9, d24, d5

+    vmull.u8    q10, d24, d6

+.endm

+

+.macro pixman_composite_out_reverse_8_0565_process_pixblock_tail

+    vrshr.u16   q14, q8, #8

+    vrshr.u16   q15, q9, #8

+    vrshr.u16   q12, q10, #8

+    vraddhn.u16 d0, q14, q8

+    vraddhn.u16 d1, q15, q9

+    vraddhn.u16 d2, q12, q10

+    /* 32bpp result is in {d0, d1, d2, XX} */

+    convert_8888_to_0565 d2, d1, d0, q14, q15, q3

+.endm

+

+/* TODO: expand macros and do better instructions scheduling */

+.macro pixman_composite_out_reverse_8_0565_process_pixblock_tail_head

+    vld1.8     {d15}, [SRC]!

+    pixman_composite_out_reverse_8_0565_process_pixblock_tail

+    vld1.16    {d10, d11}, [DST_R, :128]!

+    cache_preload 8, 8

+    pixman_composite_out_reverse_8_0565_process_pixblock_head

+    vst1.16    {d28, d29}, [DST_W, :128]!

+.endm

+

+generate_composite_function \

+    pixman_composite_out_reverse_8_0565_asm_neon, 8, 0, 16, \

+    FLAG_DST_READWRITE, \

+    8, /* number of pixels, processed in a single block */ \

+    5, /* prefetch distance */ \

+    default_init_need_all_regs, \

+    default_cleanup_need_all_regs, \

+    pixman_composite_out_reverse_8_0565_process_pixblock_head, \

+    pixman_composite_out_reverse_8_0565_process_pixblock_tail, \

+    pixman_composite_out_reverse_8_0565_process_pixblock_tail_head, \

+    28, /* dst_w_basereg */ \

+    10, /* dst_r_basereg */ \

+    15, /* src_basereg   */ \

+    0   /* mask_basereg  */

diff --git a/pixman/pixman/pixman-arm-neon.c b/pixman/pixman/pixman-arm-neon.c
index 231a183aa..40f7b6a60 100644
--- a/pixman/pixman/pixman-arm-neon.c
+++ b/pixman/pixman/pixman-arm-neon.c
@@ -60,6 +60,8 @@ PIXMAN_ARM_BIND_FAST_PATH_SRC_DST (neon, over_8888_0565,
                                    uint32_t, 1, uint16_t, 1)

 PIXMAN_ARM_BIND_FAST_PATH_SRC_DST (neon, over_8888_8888,

                                    uint32_t, 1, uint32_t, 1)

+PIXMAN_ARM_BIND_FAST_PATH_SRC_DST (neon, out_reverse_8_0565,

+                                   uint8_t, 1, uint16_t, 1)

 

 PIXMAN_ARM_BIND_FAST_PATH_N_DST (neon, over_n_0565,

                                  uint16_t, 1)

@@ -82,6 +84,8 @@ PIXMAN_ARM_BIND_FAST_PATH_SRC_N_DST (neon, over_8888_n_8888,
 

 PIXMAN_ARM_BIND_FAST_PATH_SRC_MASK_DST (neon, add_8_8_8,

                                         uint8_t, 1, uint8_t, 1, uint8_t, 1)

+PIXMAN_ARM_BIND_FAST_PATH_SRC_MASK_DST (neon, add_0565_8_0565,

+                                        uint16_t, 1, uint8_t, 1, uint16_t, 1)

 PIXMAN_ARM_BIND_FAST_PATH_SRC_MASK_DST (neon, add_8888_8888_8888,

                                         uint32_t, 1, uint32_t, 1, uint32_t, 1)

 PIXMAN_ARM_BIND_FAST_PATH_SRC_MASK_DST (neon, over_8888_8_8888,

@@ -256,12 +260,16 @@ static const pixman_fast_path_t arm_neon_fast_paths[] =
     PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, null,     a8b8g8r8, neon_composite_src_x888_8888),

     PIXMAN_STD_FAST_PATH (ADD,  solid,    a8,       a8,       neon_composite_add_n_8_8),

     PIXMAN_STD_FAST_PATH (ADD,  a8,       a8,       a8,       neon_composite_add_8_8_8),

+    PIXMAN_STD_FAST_PATH (ADD,  r5g6b5,   a8,       r5g6b5,   neon_composite_add_0565_8_0565),

+    PIXMAN_STD_FAST_PATH (ADD,  b5g6r5,   a8,       b5g6r5,   neon_composite_add_0565_8_0565),

     PIXMAN_STD_FAST_PATH (ADD,  a8r8g8b8, a8r8g8b8, a8r8g8b8, neon_composite_add_8888_8888_8888),

     PIXMAN_STD_FAST_PATH (ADD,  a8,       null,     a8,       neon_composite_add_8_8),

     PIXMAN_STD_FAST_PATH (ADD,  a8r8g8b8, null,     a8r8g8b8, neon_composite_add_8888_8888),

     PIXMAN_STD_FAST_PATH (ADD,  a8b8g8r8, null,     a8b8g8r8, neon_composite_add_8888_8888),

     PIXMAN_STD_FAST_PATH (OVER_REVERSE, solid, null, a8r8g8b8, neon_composite_over_reverse_n_8888),

     PIXMAN_STD_FAST_PATH (OVER_REVERSE, solid, null, a8b8g8r8, neon_composite_over_reverse_n_8888),

+    PIXMAN_STD_FAST_PATH (OUT_REVERSE,  a8,    null, r5g6b5,   neon_composite_out_reverse_8_0565),

+    PIXMAN_STD_FAST_PATH (OUT_REVERSE,  a8,    null, b5g6r5,   neon_composite_out_reverse_8_0565),

 

     { PIXMAN_OP_NONE },

 };

diff --git a/pixman/pixman/pixman-bits-image.c b/pixman/pixman/pixman-bits-image.c
index 1f023b826..1a3a3ea76 100644
--- a/pixman/pixman/pixman-bits-image.c
+++ b/pixman/pixman/pixman-bits-image.c
@@ -944,7 +944,8 @@ convert_r5g6b5 (const uint8_t *row, int x)
 					  convert_ ## format,		\

 					  PIXMAN_ ## format,		\

 					  repeat_mode);			\

-    }

+    }									\

+    extern int no_such_variable

 

 MAKE_BILINEAR_FETCHER (pad_a8r8g8b8,     a8r8g8b8, PIXMAN_REPEAT_PAD);

 MAKE_BILINEAR_FETCHER (none_a8r8g8b8,    a8r8g8b8, PIXMAN_REPEAT_NONE);

diff --git a/pixman/pixman/pixman-compiler.h b/pixman/pixman/pixman-compiler.h
index 0fe30a79c..340b402a3 100644
--- a/pixman/pixman/pixman-compiler.h
+++ b/pixman/pixman/pixman-compiler.h
@@ -203,7 +203,8 @@ extern int __stdcall ReleaseMutex (void *);
 		value = tls_ ## name ## _alloc ();			\

 	}								\

 	return value;							\

-    }

+    }									\

+    extern int no_such_variable						

 

 #   define PIXMAN_GET_THREAD_LOCAL(name)				\

     tls_ ## name ## _get ()

diff --git a/pixman/pixman/pixman-fast-path.h b/pixman/pixman/pixman-fast-path.h
index 5de0e1ee0..0273cd33b 100644
--- a/pixman/pixman/pixman-fast-path.h
+++ b/pixman/pixman/pixman-fast-path.h
@@ -381,7 +381,9 @@ fast_composite_scaled_nearest_ ## scale_func_name (pixman_implementation_t *imp,
 			  OP, repeat_mode)						\

     FAST_NEAREST_MAINLOOP(scale_func_name##_##OP,					\

 			  scaled_nearest_scanline_ ## scale_func_name ## _ ## OP,	\

-			  src_type_t, dst_type_t, repeat_mode)

+			  src_type_t, dst_type_t, repeat_mode)				\

+											\

+    extern int no_such_variable

 

 

 #define SCALED_NEAREST_FLAGS						\

diff --git a/pixman/pixman/pixman-image.c b/pixman/pixman/pixman-image.c
index 1b243979a..17d87216e 100644
--- a/pixman/pixman/pixman-image.c
+++ b/pixman/pixman/pixman-image.c
@@ -363,24 +363,21 @@ compute_image_info (pixman_image_t *image)
 	flags |=

 	    FAST_PATH_NO_PAD_REPEAT		|

 	    FAST_PATH_NO_NONE_REPEAT		|

-	    FAST_PATH_NO_NORMAL_REPEAT		|

-	    FAST_PATH_COVERS_CLIP;

+	    FAST_PATH_NO_NORMAL_REPEAT;

 	break;

 

     case PIXMAN_REPEAT_PAD:

 	flags |=

 	    FAST_PATH_NO_REFLECT_REPEAT		|

 	    FAST_PATH_NO_NONE_REPEAT		|

-	    FAST_PATH_NO_NORMAL_REPEAT		|

-	    FAST_PATH_COVERS_CLIP;

+	    FAST_PATH_NO_NORMAL_REPEAT;

 	break;

 

     default:

 	flags |=

 	    FAST_PATH_NO_REFLECT_REPEAT		|

 	    FAST_PATH_NO_PAD_REPEAT		|

-	    FAST_PATH_NO_NONE_REPEAT		|

-	    FAST_PATH_COVERS_CLIP;

+	    FAST_PATH_NO_NONE_REPEAT;

 	break;

     }

 

@@ -400,8 +397,6 @@ compute_image_info (pixman_image_t *image)
 

 	if (image->solid.color.alpha == 0xffff)

 	    flags |= FAST_PATH_IS_OPAQUE;

-

-	flags |= FAST_PATH_COVERS_CLIP;

 	break;

 

     case BITS:

@@ -414,12 +409,6 @@ compute_image_info (pixman_image_t *image)
 	else

 	{

 	    code = image->bits.format;

-

-	    if (!image->common.transform &&

-		image->common.repeat == PIXMAN_REPEAT_NORMAL)

-	    {

-		flags |= FAST_PATH_SIMPLE_REPEAT;

-	    }

 	}

 

 	if (!PIXMAN_FORMAT_A (image->bits.format)				&&

diff --git a/pixman/pixman/pixman-private.h b/pixman/pixman/pixman-private.h
index 8c68304dc..8250d1f7a 100644
--- a/pixman/pixman/pixman-private.h
+++ b/pixman/pixman/pixman-private.h
@@ -554,13 +554,13 @@ _pixman_choose_implementation (void);
 #define FAST_PATH_NO_PAD_REPEAT			(1 <<  3)

 #define FAST_PATH_NO_REFLECT_REPEAT		(1 <<  4)

 #define FAST_PATH_NO_ACCESSORS			(1 <<  5)

-#define FAST_PATH_NARROW_FORMAT		(1 <<  6)

-#define FAST_PATH_COVERS_CLIP			(1 <<  7)

+#define FAST_PATH_NARROW_FORMAT			(1 <<  6)

 #define FAST_PATH_COMPONENT_ALPHA		(1 <<  8)

+#define FAST_PATH_SAMPLES_OPAQUE		(1 <<  7)

 #define FAST_PATH_UNIFIED_ALPHA			(1 <<  9)

 #define FAST_PATH_SCALE_TRANSFORM		(1 << 10)

 #define FAST_PATH_NEAREST_FILTER		(1 << 11)

-#define FAST_PATH_SIMPLE_REPEAT			(1 << 12)

+#define FAST_PATH_HAS_TRANSFORM			(1 << 12)

 #define FAST_PATH_IS_OPAQUE			(1 << 13)

 #define FAST_PATH_NEEDS_WORKAROUND		(1 << 14)

 #define FAST_PATH_NO_NONE_REPEAT		(1 << 15)

@@ -570,8 +570,6 @@ _pixman_choose_implementation (void);
 #define FAST_PATH_Y_UNIT_ZERO			(1 << 19)

 #define FAST_PATH_BILINEAR_FILTER		(1 << 20)

 #define FAST_PATH_NO_NORMAL_REPEAT		(1 << 21)

-#define FAST_PATH_HAS_TRANSFORM			(1 << 22)

-#define FAST_PATH_SAMPLES_OPAQUE		(1 << 23)

 

 #define FAST_PATH_PAD_REPEAT						\

     (FAST_PATH_NO_NONE_REPEAT		|				\

@@ -593,29 +591,25 @@ _pixman_choose_implementation (void);
      FAST_PATH_NO_NORMAL_REPEAT		|				\

      FAST_PATH_NO_PAD_REPEAT)

 

-#define _FAST_PATH_STANDARD_FLAGS					\

-    (FAST_PATH_ID_TRANSFORM		|				\

-     FAST_PATH_NO_ALPHA_MAP		|				\

-     FAST_PATH_NO_CONVOLUTION_FILTER	|				\

-     FAST_PATH_NO_PAD_REPEAT		|				\

-     FAST_PATH_NO_REFLECT_REPEAT	|				\

+#define FAST_PATH_STANDARD_FLAGS					\

+    (FAST_PATH_NO_CONVOLUTION_FILTER	|				\

      FAST_PATH_NO_ACCESSORS		|				\

-     FAST_PATH_NARROW_FORMAT		|				\

-     FAST_PATH_COVERS_CLIP)

-

-#define FAST_PATH_STD_SRC_FLAGS						\

-    _FAST_PATH_STANDARD_FLAGS

-#define FAST_PATH_STD_MASK_U_FLAGS					\

-    (_FAST_PATH_STANDARD_FLAGS		|				\

-     FAST_PATH_UNIFIED_ALPHA)

-#define FAST_PATH_STD_MASK_CA_FLAGS					\

-    (_FAST_PATH_STANDARD_FLAGS		|				\

-     FAST_PATH_COMPONENT_ALPHA)

+     FAST_PATH_NO_ALPHA_MAP		|				\

+     FAST_PATH_NARROW_FORMAT)

+

 #define FAST_PATH_STD_DEST_FLAGS					\

     (FAST_PATH_NO_ACCESSORS		|				\

      FAST_PATH_NO_ALPHA_MAP		|				\

      FAST_PATH_NARROW_FORMAT)

 

+#define SOURCE_FLAGS(format)						\

+    (FAST_PATH_STANDARD_FLAGS |						\

+     ((PIXMAN_ ## format == PIXMAN_solid) ?				\

+      0 : (FAST_PATH_SAMPLES_COVER_CLIP | FAST_PATH_ID_TRANSFORM)))

+

+#define MASK_FLAGS(format, extra)					\

+    ((PIXMAN_ ## format == PIXMAN_null) ? 0 : (SOURCE_FLAGS (format) | extra))

+

 #define FAST_PATH(op, src, src_flags, mask, mask_flags, dest, dest_flags, func) \

     PIXMAN_OP_ ## op,							\

     PIXMAN_ ## src,							\

@@ -628,19 +622,19 @@ _pixman_choose_implementation (void);
 

 #define PIXMAN_STD_FAST_PATH(op, src, mask, dest, func)			\

     { FAST_PATH (							\

-	  op,								\

-	  src, FAST_PATH_STD_SRC_FLAGS,					\

-	  mask, (PIXMAN_ ## mask) ? FAST_PATH_STD_MASK_U_FLAGS : 0,	\

-	  dest, FAST_PATH_STD_DEST_FLAGS,				\

-	  func) }

+	    op,								\

+	    src,  SOURCE_FLAGS (src),					\

+	    mask, MASK_FLAGS (mask, FAST_PATH_UNIFIED_ALPHA),		\

+	    dest, FAST_PATH_STD_DEST_FLAGS,				\

+	    func) }

 

 #define PIXMAN_STD_FAST_PATH_CA(op, src, mask, dest, func)		\

     { FAST_PATH (							\

-	  op,								\

-	  src, FAST_PATH_STD_SRC_FLAGS,					\

-	  mask, FAST_PATH_STD_MASK_CA_FLAGS,				\

-	  dest, FAST_PATH_STD_DEST_FLAGS,				\

-	  func) }

+	    op,								\

+	    src,  SOURCE_FLAGS (src),					\

+	    mask, MASK_FLAGS (mask, FAST_PATH_COMPONENT_ALPHA),		\

+	    dest, FAST_PATH_STD_DEST_FLAGS,				\

+	    func) }

 

 /* Memory allocation helpers */

 void *

diff --git a/pixman/pixman/pixman.c b/pixman/pixman/pixman.c
index f2565ca01..4857e30ce 100644
--- a/pixman/pixman/pixman.c
+++ b/pixman/pixman/pixman.c
@@ -377,126 +377,6 @@ pixman_compute_composite_region32 (pixman_region32_t * region,
     return TRUE;

 }

 

-static void

-walk_region_internal (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                  dest_x,

-                      int32_t                  dest_y,

-                      int32_t                  width,

-                      int32_t                  height,

-                      pixman_bool_t            src_repeat,

-                      pixman_bool_t            mask_repeat,

-                      pixman_region32_t *      region,

-                      pixman_composite_func_t  composite_rect)

-{

-    int w, h, w_this, h_this;

-    int x_msk, y_msk, x_src, y_src, x_dst, y_dst;

-    int src_dy = src_y - dest_y;

-    int src_dx = src_x - dest_x;

-    int mask_dy = mask_y - dest_y;

-    int mask_dx = mask_x - dest_x;

-    const pixman_box32_t *pbox;

-    int n;

-

-    pbox = pixman_region32_rectangles (region, &n);

-

-    /* Fast path for non-repeating sources */

-    if (!src_repeat && !mask_repeat)

-    {

-       while (n--)

-       {

-           (*composite_rect) (imp, op,

-                              src_image, mask_image, dst_image,

-                              pbox->x1 + src_dx,

-                              pbox->y1 + src_dy,

-                              pbox->x1 + mask_dx,

-                              pbox->y1 + mask_dy,

-                              pbox->x1,

-                              pbox->y1,

-                              pbox->x2 - pbox->x1,

-                              pbox->y2 - pbox->y1);

-           

-           pbox++;

-       }

-

-       return;

-    }

-    

-    while (n--)

-    {

-	h = pbox->y2 - pbox->y1;

-	y_src = pbox->y1 + src_dy;

-	y_msk = pbox->y1 + mask_dy;

-	y_dst = pbox->y1;

-

-	while (h)

-	{

-	    h_this = h;

-	    w = pbox->x2 - pbox->x1;

-	    x_src = pbox->x1 + src_dx;

-	    x_msk = pbox->x1 + mask_dx;

-	    x_dst = pbox->x1;

-

-	    if (mask_repeat)

-	    {

-		y_msk = MOD (y_msk, mask_image->bits.height);

-		if (h_this > mask_image->bits.height - y_msk)

-		    h_this = mask_image->bits.height - y_msk;

-	    }

-

-	    if (src_repeat)

-	    {

-		y_src = MOD (y_src, src_image->bits.height);

-		if (h_this > src_image->bits.height - y_src)

-		    h_this = src_image->bits.height - y_src;

-	    }

-

-	    while (w)

-	    {

-		w_this = w;

-

-		if (mask_repeat)

-		{

-		    x_msk = MOD (x_msk, mask_image->bits.width);

-		    if (w_this > mask_image->bits.width - x_msk)

-			w_this = mask_image->bits.width - x_msk;

-		}

-

-		if (src_repeat)

-		{

-		    x_src = MOD (x_src, src_image->bits.width);

-		    if (w_this > src_image->bits.width - x_src)

-			w_this = src_image->bits.width - x_src;

-		}

-

-		(*composite_rect) (imp, op,

-				   src_image, mask_image, dst_image,

-				   x_src, y_src, x_msk, y_msk, x_dst, y_dst,

-				   w_this, h_this);

-		w -= w_this;

-

-		x_src += w_this;

-		x_msk += w_this;

-		x_dst += w_this;

-	    }

-

-	    h -= h_this;

-	    y_src += h_this;

-	    y_msk += h_this;

-	    y_dst += h_this;

-	}

-

-	pbox++;

-    }

-}

-

 #define N_CACHED_FAST_PATHS 8

 

 typedef struct

@@ -746,7 +626,7 @@ analyze_extent (pixman_image_t *image, int x, int y,
 	    extents->x2 - x <= image->bits.width &&

 	    extents->y2 - y <= image->bits.height)

 	{

-	    *flags |= (FAST_PATH_SAMPLES_COVER_CLIP | FAST_PATH_COVERS_CLIP);

+	    *flags |= FAST_PATH_SAMPLES_COVER_CLIP;

 	    return TRUE;

 	}

     

@@ -789,7 +669,7 @@ analyze_extent (pixman_image_t *image, int x, int y,
 	    ex.x1 >= 0 && ex.y1 >= 0 &&

 	    ex.x2 <= image->bits.width && ex.y2 <= image->bits.height)

 	{

-	    *flags |= (FAST_PATH_SAMPLES_COVER_CLIP | FAST_PATH_COVERS_CLIP);

+	    *flags |= FAST_PATH_SAMPLES_COVER_CLIP;

 	}

     }

     else

@@ -949,14 +829,26 @@ pixman_image_composite32 (pixman_op_t      op,
 				   dest_format, dest_flags,

 				   &imp, &func))

     {

-	walk_region_internal (imp, op,

-			      src, mask, dest,

-			      src_x, src_y, mask_x, mask_y,

-			      dest_x, dest_y,

-			      width, height,

-			      (src_flags & FAST_PATH_SIMPLE_REPEAT),

-			      (mask_flags & FAST_PATH_SIMPLE_REPEAT),

-			      &region, func);

+	const pixman_box32_t *pbox;

+	int n;

+

+	pbox = pixman_region32_rectangles (&region, &n);

+	

+	while (n--)

+	{

+	    func (imp, op,

+		  src, mask, dest,

+		  pbox->x1 + src_x - dest_x,

+		  pbox->y1 + src_y - dest_y,

+		  pbox->x1 + mask_x - dest_x,

+		  pbox->y1 + mask_y - dest_y,

+		  pbox->x1,

+		  pbox->y1,

+		  pbox->x2 - pbox->x1,

+		  pbox->y2 - pbox->y1);

+	    

+	    pbox++;

+	}

     }

 

 out:

diff --git a/pixman/test/utils.c b/pixman/test/utils.c
index d7038a36e..acf494938 100644
--- a/pixman/test/utils.c
+++ b/pixman/test/utils.c
@@ -243,7 +243,7 @@ fence_malloc (uint32_t len)
     addr = mmap (NULL, n_bytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,

 		 -1, 0);

 

-    if (addr == (void *)MAP_FAILED)

+    if (addr == MAP_FAILED)

     {

 	printf ("mmap failed on %u %u\n", len, n_bytes);

 	return NULL;

@@ -259,20 +259,12 @@ fence_malloc (uint32_t len)
     ((info_t *)initial_page)->trailing = trailing_protected;

     ((info_t *)initial_page)->n_bytes = n_bytes;

 

-    if (mprotect (leading_protected, N_LEADING_PROTECTED * page_size,

-		  PROT_NONE) == -1)

+    if ((mprotect (leading_protected, N_LEADING_PROTECTED * page_size,

+		  PROT_NONE) == -1) ||

+	(mprotect (trailing_protected, N_TRAILING_PROTECTED * page_size,

+		  PROT_NONE) == -1))

     {

-	free (addr);

-	return NULL;

-    }

-

-    if (mprotect (trailing_protected, N_TRAILING_PROTECTED * page_size,

-		  PROT_NONE) == -1)

-    {

-	mprotect (leading_protected, N_LEADING_PROTECTED * page_size,

-		  PROT_READ | PROT_WRITE);

-

-	free (addr);

+	munmap (addr, n_bytes);

 	return NULL;

     }

 

@@ -287,13 +279,6 @@ fence_free (void *data)
     uint8_t *leading_protected = payload - N_LEADING_PROTECTED * page_size;

     uint8_t *initial_page = leading_protected - page_size;

     info_t *info = (info_t *)initial_page;

-    uint8_t *trailing_protected = info->trailing;

-

-    mprotect (leading_protected, N_LEADING_PROTECTED * page_size,

-	      PROT_READ | PROT_WRITE);

-

-    mprotect (trailing_protected, N_LEADING_PROTECTED * page_size,

-	      PROT_READ | PROT_WRITE);

 

     munmap (info->addr, info->n_bytes);

 }