libX11 mesa pixman git update 9 nov 2011

17 files changed, 782 insertions, 798 deletions

diff --git a/pixman/test/a1-trap-test.c b/pixman/test/a1-trap-test.c
index 6163e7c61..93c6caa14 100644
--- a/pixman/test/a1-trap-test.c
+++ b/pixman/test/a1-trap-test.c
@@ -2,7 +2,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "pixman.h"
+#include "utils.h"
 
 int
 main (int argc, char **argv)
diff --git a/pixman/test/alphamap.c b/pixman/test/alphamap.c
index 554b309fb..24a350ed7 100644
--- a/pixman/test/alphamap.c
+++ b/pixman/test/alphamap.c
@@ -139,8 +139,6 @@ get_alpha (pixman_image_t *image, int x, int y, int orig_x, int orig_y)
     return r;
 }
 
-#define ARRAY_LENGTH(A) ((int) (sizeof (A) / sizeof ((A) [0])))
-
 static int
 run_test (int s, int d, int sa, int da, int soff, int doff)
 {
diff --git a/pixman/test/blitters-test.c b/pixman/test/blitters-test.c
index 4f931c440..55b6c735c 100644
--- a/pixman/test/blitters-test.c
+++ b/pixman/test/blitters-test.c
@@ -5,7 +5,6 @@
  * Script 'fuzzer-find-diff.pl' can be used to narrow down the problem in
  * the case of test failure.
  */
-#include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "utils.h"
@@ -281,7 +280,7 @@ test_composite (int testnum, int verbose)
 
     lcg_srand (testnum);
 
-    op = op_list[lcg_rand_n (sizeof (op_list) / sizeof (op_list[0]))];
+    op = op_list[lcg_rand_n (ARRAY_LENGTH (op_list))];
 
     if (lcg_rand_n (8))
     {
diff --git a/pixman/test/composite-traps-test.c b/pixman/test/composite-traps-test.c
index fa6d8a988..ff03b50d9 100644
--- a/pixman/test/composite-traps-test.c
+++ b/pixman/test/composite-traps-test.c
@@ -1,6 +1,5 @@
 /* Based loosely on scaling-test */
 
-#include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "utils.h"
diff --git a/pixman/test/composite.c b/pixman/test/composite.c
index 408c363a3..fe59eae3c 100644
--- a/pixman/test/composite.c
+++ b/pixman/test/composite.c
@@ -22,8 +22,6 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-#define PIXMAN_USE_INTERNAL_API
-#include <pixman.h>
 #include <stdio.h>
 #include <stdlib.h> /* abort() */
 #include <math.h>
diff --git a/pixman/test/fetch-test.c b/pixman/test/fetch-test.c
index 9f80eec1b..04e8cc583 100644
--- a/pixman/test/fetch-test.c
+++ b/pixman/test/fetch-test.c
@@ -1,11 +1,7 @@
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include "pixman.h"
+#include "utils.h"
 
 #define SIZE 1024
 
@@ -107,7 +103,7 @@ static testcase_t testcases[] =
     },
 };
 
-int n_test_cases = sizeof(testcases)/sizeof(testcases[0]);
+int n_test_cases = ARRAY_LENGTH (testcases);
 
 
 static uint32_t
diff --git a/pixman/test/gradient-crash-test.c b/pixman/test/gradient-crash-test.c
index 35b25b2cb..73e5bbcd5 100644
--- a/pixman/test/gradient-crash-test.c
+++ b/pixman/test/gradient-crash-test.c
@@ -1,158 +1,158 @@
-#include <stdio.h>

-#include <stdlib.h>

-#include "utils.h"

-

-int

-main (int argc, char **argv)

-{

-#define WIDTH 400

-#define HEIGHT 200

-    

-    uint32_t *dest = malloc (WIDTH * HEIGHT * 4);

-    pixman_image_t *src_img;

-    pixman_image_t *dest_img;

-    int i, j, k, p;

-

-    typedef struct

-    {

-	pixman_point_fixed_t p0;

-	pixman_point_fixed_t p1;

-    } point_pair_t;

-    

-    pixman_gradient_stop_t onestop[1] =

-	{

-	    { pixman_int_to_fixed (1), { 0xffff, 0xeeee, 0xeeee, 0xeeee } },

-	};

-

-    pixman_gradient_stop_t subsetstops[2] =

-	{

-	    { pixman_int_to_fixed (1), { 0xffff, 0xeeee, 0xeeee, 0xeeee } },

-	    { pixman_int_to_fixed (1), { 0xffff, 0xeeee, 0xeeee, 0xeeee } },

-	};

-

-    pixman_gradient_stop_t stops01[2] =

-	{

-	    { pixman_int_to_fixed (0), { 0xffff, 0xeeee, 0xeeee, 0xeeee } },

-	    { pixman_int_to_fixed (1), { 0xffff, 0x1111, 0x1111, 0x1111 } }

-	};

-

-    point_pair_t point_pairs [] =

-	{ { { pixman_double_to_fixed (0), 0 },

-	    { pixman_double_to_fixed (WIDTH / 8.), pixman_int_to_fixed (0) } },

-	  { { pixman_double_to_fixed (WIDTH / 2.0), pixman_double_to_fixed (HEIGHT / 2.0) },

-	    { pixman_double_to_fixed (WIDTH / 2.0), pixman_double_to_fixed (HEIGHT / 2.0) } }

-	};

-    

-    pixman_transform_t transformations[] = {

-	{

-	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (0.5), pixman_double_to_fixed (-100), },

-	      { pixman_double_to_fixed (0), pixman_double_to_fixed (3), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (0), pixman_double_to_fixed (0.000), pixman_double_to_fixed (1.0) } 

-	    }

-	},

-	{

-	    { { pixman_double_to_fixed (1), pixman_double_to_fixed (0), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (0), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (0), pixman_double_to_fixed (0.000), pixman_double_to_fixed (1.0) } 

-	    }

-	},

-	{

-	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (1), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (2), pixman_double_to_fixed (1.000), pixman_double_to_fixed (1.0) } 

-	    }

-	},

-	{

-	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (1), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (0), pixman_double_to_fixed (0), pixman_double_to_fixed (0) } 

-	    }

-	},

-	{

-	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (1), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (2), pixman_double_to_fixed (-1), pixman_double_to_fixed (0) } 

-	    }

-	},

-	{

-	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (1), pixman_double_to_fixed (3), },

-	      { pixman_double_to_fixed (1), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },

-	      { pixman_double_to_fixed (2), pixman_double_to_fixed (-1), pixman_double_to_fixed (0) } 

-	    }

-	},

-    };

-    

-    pixman_fixed_t r_inner;

-    pixman_fixed_t r_outer;

-

-    enable_fp_exceptions();

-    

-    for (i = 0; i < WIDTH * HEIGHT; ++i)

-	dest[i] = 0x4f00004f; /* pale blue */

-    

-    dest_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,

-					 WIDTH, HEIGHT, 

-					 dest,

-					 WIDTH * 4);

-

-    r_inner = 0;

-    r_outer = pixman_double_to_fixed (50.0);

-    

-    for (i = 0; i < 3; ++i)

-    {

-	pixman_gradient_stop_t *stops;

-        int num_stops;

-

-	if (i == 0)

-	{

-	    stops = onestop;

-	    num_stops = sizeof(onestop) / sizeof(onestop[0]);

-	}

-	else if (i == 1)

-	{

-	    stops = subsetstops;

-	    num_stops = sizeof(subsetstops) / sizeof(subsetstops[0]);

-	}

-	else

-	{

-	    stops = stops01;

-	    num_stops = sizeof(stops01) / sizeof(stops01[0]);

-	}

-	

-	for (j = 0; j < 3; ++j)

-	{

-	    for (p = 0; p < ARRAY_LENGTH (point_pairs); ++p)

-	    {

-		point_pair_t *pair = &(point_pairs[p]);

-

-		if (j == 0)

-		    src_img = pixman_image_create_conical_gradient (&(pair->p0), r_inner,

-								    stops, num_stops);

-		else if (j == 1)

-		    src_img = pixman_image_create_radial_gradient  (&(pair->p0), &(pair->p1),

-								    r_inner, r_outer,

-								    stops, num_stops);

-		else

-		    src_img = pixman_image_create_linear_gradient  (&(pair->p0), &(pair->p1),

-								    stops, num_stops);

-		

-		for (k = 0; k < ARRAY_LENGTH (transformations); ++k)

-		{

-		    pixman_image_set_transform (src_img, &transformations[k]);

-		    

-		    pixman_image_set_repeat (src_img, PIXMAN_REPEAT_NONE);

-		    pixman_image_composite (PIXMAN_OP_OVER, src_img, NULL, dest_img,

-					    0, 0, 0, 0, 0, 0, 10 * WIDTH, HEIGHT);

-		}

-

-		pixman_image_unref (src_img);

-	    }

-

-	}

-    }

-

-    pixman_image_unref (dest_img);

-    free (dest);

-    

-    return 0;

-}

+#include <stdio.h>
+#include <stdlib.h>
+#include "utils.h"
+
+int
+main (int argc, char **argv)
+{
+#define WIDTH 400
+#define HEIGHT 200
+    
+    uint32_t *dest = malloc (WIDTH * HEIGHT * 4);
+    pixman_image_t *src_img;
+    pixman_image_t *dest_img;
+    int i, j, k, p;
+
+    typedef struct
+    {
+	pixman_point_fixed_t p0;
+	pixman_point_fixed_t p1;
+    } point_pair_t;
+    
+    pixman_gradient_stop_t onestop[1] =
+	{
+	    { pixman_int_to_fixed (1), { 0xffff, 0xeeee, 0xeeee, 0xeeee } },
+	};
+
+    pixman_gradient_stop_t subsetstops[2] =
+	{
+	    { pixman_int_to_fixed (1), { 0xffff, 0xeeee, 0xeeee, 0xeeee } },
+	    { pixman_int_to_fixed (1), { 0xffff, 0xeeee, 0xeeee, 0xeeee } },
+	};
+
+    pixman_gradient_stop_t stops01[2] =
+	{
+	    { pixman_int_to_fixed (0), { 0xffff, 0xeeee, 0xeeee, 0xeeee } },
+	    { pixman_int_to_fixed (1), { 0xffff, 0x1111, 0x1111, 0x1111 } }
+	};
+
+    point_pair_t point_pairs [] =
+	{ { { pixman_double_to_fixed (0), 0 },
+	    { pixman_double_to_fixed (WIDTH / 8.), pixman_int_to_fixed (0) } },
+	  { { pixman_double_to_fixed (WIDTH / 2.0), pixman_double_to_fixed (HEIGHT / 2.0) },
+	    { pixman_double_to_fixed (WIDTH / 2.0), pixman_double_to_fixed (HEIGHT / 2.0) } }
+	};
+    
+    pixman_transform_t transformations[] = {
+	{
+	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (0.5), pixman_double_to_fixed (-100), },
+	      { pixman_double_to_fixed (0), pixman_double_to_fixed (3), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (0), pixman_double_to_fixed (0.000), pixman_double_to_fixed (1.0) } 
+	    }
+	},
+	{
+	    { { pixman_double_to_fixed (1), pixman_double_to_fixed (0), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (0), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (0), pixman_double_to_fixed (0.000), pixman_double_to_fixed (1.0) } 
+	    }
+	},
+	{
+	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (1), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (2), pixman_double_to_fixed (1.000), pixman_double_to_fixed (1.0) } 
+	    }
+	},
+	{
+	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (1), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (0), pixman_double_to_fixed (0), pixman_double_to_fixed (0) } 
+	    }
+	},
+	{
+	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (1), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (2), pixman_double_to_fixed (-1), pixman_double_to_fixed (0) } 
+	    }
+	},
+	{
+	    { { pixman_double_to_fixed (2), pixman_double_to_fixed (1), pixman_double_to_fixed (3), },
+	      { pixman_double_to_fixed (1), pixman_double_to_fixed (1), pixman_double_to_fixed (0), },
+	      { pixman_double_to_fixed (2), pixman_double_to_fixed (-1), pixman_double_to_fixed (0) } 
+	    }
+	},
+    };
+    
+    pixman_fixed_t r_inner;
+    pixman_fixed_t r_outer;
+
+    enable_fp_exceptions();
+    
+    for (i = 0; i < WIDTH * HEIGHT; ++i)
+	dest[i] = 0x4f00004f; /* pale blue */
+    
+    dest_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,
+					 WIDTH, HEIGHT, 
+					 dest,
+					 WIDTH * 4);
+
+    r_inner = 0;
+    r_outer = pixman_double_to_fixed (50.0);
+    
+    for (i = 0; i < 3; ++i)
+    {
+	pixman_gradient_stop_t *stops;
+        int num_stops;
+
+	if (i == 0)
+	{
+	    stops = onestop;
+	    num_stops = ARRAY_LENGTH (onestop);
+	}
+	else if (i == 1)
+	{
+	    stops = subsetstops;
+	    num_stops = ARRAY_LENGTH (subsetstops);
+	}
+	else
+	{
+	    stops = stops01;
+	    num_stops = ARRAY_LENGTH (stops01);
+	}
+	
+	for (j = 0; j < 3; ++j)
+	{
+	    for (p = 0; p < ARRAY_LENGTH (point_pairs); ++p)
+	    {
+		point_pair_t *pair = &(point_pairs[p]);
+
+		if (j == 0)
+		    src_img = pixman_image_create_conical_gradient (&(pair->p0), r_inner,
+								    stops, num_stops);
+		else if (j == 1)
+		    src_img = pixman_image_create_radial_gradient  (&(pair->p0), &(pair->p1),
+								    r_inner, r_outer,
+								    stops, num_stops);
+		else
+		    src_img = pixman_image_create_linear_gradient  (&(pair->p0), &(pair->p1),
+								    stops, num_stops);
+		
+		for (k = 0; k < ARRAY_LENGTH (transformations); ++k)
+		{
+		    pixman_image_set_transform (src_img, &transformations[k]);
+		    
+		    pixman_image_set_repeat (src_img, PIXMAN_REPEAT_NONE);
+		    pixman_image_composite (PIXMAN_OP_OVER, src_img, NULL, dest_img,
+					    0, 0, 0, 0, 0, 0, 10 * WIDTH, HEIGHT);
+		}
+
+		pixman_image_unref (src_img);
+	    }
+
+	}
+    }
+
+    pixman_image_unref (dest_img);
+    free (dest);
+    
+    return 0;
+}
diff --git a/pixman/test/lowlevel-blt-bench.c b/pixman/test/lowlevel-blt-bench.c
index bdafb3592..ba7f30716 100644
--- a/pixman/test/lowlevel-blt-bench.c
+++ b/pixman/test/lowlevel-blt-bench.c
@@ -25,10 +25,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
-#define PIXMAN_USE_INTERNAL_API
-#include <pixman.h>
-
 #include "utils.h"
 
 #define SOLID_FLAG 1
@@ -707,7 +703,7 @@ main (int argc, char *argv[])
             x / 1000000., x / 4000000);
     printf ("---\n");
 
-    for (i = 0; i < sizeof(tests_tbl) / sizeof(tests_tbl[0]); i++)
+    for (i = 0; i < ARRAY_LENGTH (tests_tbl); i++)
     {
 	if (strcmp (pattern, "all") == 0 || strstr (tests_tbl[i].testname, pattern))
 	{
diff --git a/pixman/test/oob-test.c b/pixman/test/oob-test.c
index 4f9e5a244..0d19b504a 100644
--- a/pixman/test/oob-test.c
+++ b/pixman/test/oob-test.c
@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include "pixman.h"
+#include "utils.h"
 
 typedef struct
 {
@@ -94,7 +94,7 @@ main (int argc, char **argv)
 {
     int i;
 
-    for (i = 0; i < sizeof (info) / sizeof (info[0]); ++i)
+    for (i = 0; i < ARRAY_LENGTH (info); ++i)
 	test_composite (&info[i]);
     
     return 0;
diff --git a/pixman/test/region-contains-test.c b/pixman/test/region-contains-test.c
index b660fdf0b..2372686fc 100644
--- a/pixman/test/region-contains-test.c
+++ b/pixman/test/region-contains-test.c
@@ -1,4 +1,3 @@
-#include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include "utils.h"
diff --git a/pixman/test/region-translate-test.c b/pixman/test/region-translate-test.c
index 7c63df966..5a03027e8 100644
--- a/pixman/test/region-translate-test.c
+++ b/pixman/test/region-translate-test.c
@@ -1,30 +1,30 @@
-#include <pixman.h>

-#include <assert.h>

-

-/* Pixman had a bug where 32bit regions where clipped to 16bit sizes when

- * pixman_region32_translate() was called. This test exercises that bug.

- */

-

-#define LARGE 32000

-

-int

-main (int argc, char **argv)

-{

-  pixman_box32_t rect = { -LARGE, -LARGE, LARGE, LARGE };

-  pixman_region32_t r1, r2;

-

-  pixman_region32_init_rects (&r1, &rect, 1);

-  pixman_region32_init_rect (&r2, rect.x1, rect.y1, rect.x2 - rect.x1, rect.y2 - rect.y1);

-

-  assert (pixman_region32_equal (&r1,  &r2));

-

-  pixman_region32_translate (&r1, -LARGE, LARGE);

-  pixman_region32_translate (&r1, LARGE, -LARGE);

-

-  assert (pixman_region32_equal (&r1,  &r2));

-

-  pixman_region32_fini (&r1);

-  pixman_region32_fini (&r2);

-

-  return 0;

-}

+#include <assert.h>
+#include "utils.h"
+
+/* Pixman had a bug where 32bit regions where clipped to 16bit sizes when
+ * pixman_region32_translate() was called. This test exercises that bug.
+ */
+
+#define LARGE 32000
+
+int
+main (int argc, char **argv)
+{
+  pixman_box32_t rect = { -LARGE, -LARGE, LARGE, LARGE };
+  pixman_region32_t r1, r2;
+
+  pixman_region32_init_rects (&r1, &rect, 1);
+  pixman_region32_init_rect (&r2, rect.x1, rect.y1, rect.x2 - rect.x1, rect.y2 - rect.y1);
+
+  assert (pixman_region32_equal (&r1,  &r2));
+
+  pixman_region32_translate (&r1, -LARGE, LARGE);
+  pixman_region32_translate (&r1, LARGE, -LARGE);
+
+  assert (pixman_region32_equal (&r1,  &r2));
+
+  pixman_region32_fini (&r1);
+  pixman_region32_fini (&r2);
+
+  return 0;
+}
diff --git a/pixman/test/scaling-crash-test.c b/pixman/test/scaling-crash-test.c
index 23ee8c6be..ed57ae024 100644
--- a/pixman/test/scaling-crash-test.c
+++ b/pixman/test/scaling-crash-test.c
@@ -1,217 +1,216 @@
-#include <assert.h>

-#include <stdlib.h>

-#include <stdio.h>

-#include <string.h>

-#include "pixman.h"

-

-/*

- * We have a source image filled with solid color, set NORMAL or PAD repeat,

- * and some transform which results in nearest neighbour scaling.

- *

- * The expected result is either that the destination image filled with this solid

- * color or, if the transformation is such that we can't composite anything at

- * all, that nothing has changed in the destination.

- *

- * The surrounding memory of the source image is a different solid color so that

- * we are sure to get failures if we access it.

- */

-static int

-run_test (int32_t		dst_width,

-	  int32_t		dst_height,

-	  int32_t		src_width,

-	  int32_t		src_height,

-	  int32_t		src_x,

-	  int32_t		src_y,

-	  int32_t		scale_x,

-	  int32_t		scale_y,

-	  pixman_filter_t	filter,

-	  pixman_repeat_t	repeat)

-{

-    pixman_image_t *   src_img;

-    pixman_image_t *   dst_img;

-    pixman_transform_t transform;

-    uint32_t *         srcbuf;

-    uint32_t *         dstbuf;

-    pixman_box32_t     box = { 0, 0, src_width, src_height };

-    pixman_color_t     color_cc = { 0xcccc, 0xcccc, 0xcccc, 0xcccc };

-    int result;

-    int i;

-

-    static const pixman_fixed_t kernel[] =

-    {

-#define D(f)	(pixman_double_to_fixed (f) + 0x0001)

-

-	pixman_int_to_fixed (5),

-	pixman_int_to_fixed (5),

-	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0),

-	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0),

-	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0),

-	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0),

-	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0)

-    };

-

-    result = 0;

-

-    srcbuf = (uint32_t *)malloc ((src_width + 10) * (src_height + 10) * 4);

-    dstbuf = (uint32_t *)malloc (dst_width * dst_height * 4);

-

-    memset (srcbuf, 0x88, src_width * src_height * 4);

-    memset (dstbuf, 0x33, dst_width * dst_height * 4);

-

-    src_img = pixman_image_create_bits (

-        PIXMAN_a8r8g8b8, src_width, src_height,

-	srcbuf + (src_width + 10) * 5 + 5, (src_width + 10) * 4);

-

-    pixman_image_fill_boxes (PIXMAN_OP_SRC, src_img, &color_cc, 1, &box);

-

-    dst_img = pixman_image_create_bits (

-        PIXMAN_a8r8g8b8, dst_width, dst_height, dstbuf, dst_width * 4);

-

-    pixman_transform_init_scale (&transform, scale_x, scale_y);

-    pixman_image_set_transform (src_img, &transform);

-    pixman_image_set_repeat (src_img, repeat);

-    if (filter == PIXMAN_FILTER_CONVOLUTION)

-	pixman_image_set_filter (src_img, filter, kernel, 27);

-    else

-	pixman_image_set_filter (src_img, filter, NULL, 0);

-

-    pixman_image_composite (PIXMAN_OP_SRC, src_img, NULL, dst_img,

-                            src_x, src_y, 0, 0, 0, 0, dst_width, dst_height);

-

-    pixman_image_unref (src_img);

-    pixman_image_unref (dst_img);

-

-    for (i = 0; i < dst_width * dst_height; i++)

-    {

-	if (dstbuf[i] != 0xCCCCCCCC && dstbuf[i] != 0x33333333)

-	{

-	    result = 1;

-	    break;

-	}

-    }

-

-    free (srcbuf);

-    free (dstbuf);

-    return result;

-}

-

-typedef struct filter_info_t filter_info_t;

-struct filter_info_t

-{

-    pixman_filter_t value;

-    char name[28];

-};

-

-static const filter_info_t filters[] =

-{

-    { PIXMAN_FILTER_NEAREST, "NEAREST" },

-    { PIXMAN_FILTER_BILINEAR, "BILINEAR" },

-    { PIXMAN_FILTER_CONVOLUTION, "CONVOLUTION" },

-};

-

-typedef struct repeat_info_t repeat_info_t;

-struct repeat_info_t

-{

-    pixman_repeat_t value;

-    char name[28];

-};

-

-

-static const repeat_info_t repeats[] =

-{

-    { PIXMAN_REPEAT_PAD, "PAD" },

-    { PIXMAN_REPEAT_REFLECT, "REFLECT" },

-    { PIXMAN_REPEAT_NORMAL, "NORMAL" }

-};

-

-static int

-do_test (int32_t		dst_size,

-	 int32_t		src_size,

-	 int32_t		src_offs,

-	 int32_t		scale_factor)

-{

-#define N_ELEMENTS(a)	(sizeof (a) / sizeof ((a)[0]))

-    int i, j;

-

-    for (i = 0; i < N_ELEMENTS(filters); ++i)

-    {

-	for (j = 0; j < N_ELEMENTS (repeats); ++j)

-	{

-	    /* horizontal test */

-	    if (run_test (dst_size, 1,

-			  src_size, 1,

-			  src_offs, 0,

-			  scale_factor, 65536,

-			  filters[i].value,

-			  repeats[j].value) != 0)

-	    {

-		printf ("Vertical test failed with %s filter and repeat mode %s\n",

-			filters[i].name, repeats[j].name);

-

-		return 1;

-	    }

-

-	    /* vertical test */

-	    if (run_test (1, dst_size,

-			  1, src_size,

-			  0, src_offs,

-			  65536, scale_factor,

-			  filters[i].value,

-			  repeats[j].value) != 0)

-	    {

-		printf ("Vertical test failed with %s filter and repeat mode %s\n",

-			filters[i].name, repeats[j].name);

-

-		return 1;

-	    }

-	}

-    }

-

-    return 0;

-}

-

-int

-main (int argc, char *argv[])

-{

-    int i;

-

-    pixman_disable_out_of_bounds_workaround ();

-

-    /* can potentially crash */

-    assert (do_test (

-		48000, 32767, 1, 65536 * 128) == 0);

-

-    /* can potentially get into a deadloop */

-    assert (do_test (

-		16384, 65536, 32, 32768) == 0);

-

-    /* can potentially access memory outside source image buffer */

-    assert (do_test (

-		10, 10, 0, 1) == 0);

-    assert (do_test (

-		10, 10, 0, 0) == 0);

-

-    for (i = 0; i < 100; ++i)

-    {

-	pixman_fixed_t one_seventh =

-	    (((pixman_fixed_48_16_t)pixman_fixed_1) << 16) / (7 << 16);

-

-	assert (do_test (

-		    1, 7, 3, one_seventh + i - 50) == 0);

-    }

-

-    for (i = 0; i < 100; ++i)

-    {

-	pixman_fixed_t scale =

-	    (((pixman_fixed_48_16_t)pixman_fixed_1) << 16) / (32767 << 16);

-

-	assert (do_test (

-		    1, 32767, 16383, scale + i - 50) == 0);

-    }

-

-    /* can potentially provide invalid results (out of range matrix stuff) */

-    assert (do_test (

-	48000, 32767, 16384, 65536 * 128) == 0);

-

-    return 0;

-}

+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "utils.h"
+
+/*
+ * We have a source image filled with solid color, set NORMAL or PAD repeat,
+ * and some transform which results in nearest neighbour scaling.
+ *
+ * The expected result is either that the destination image filled with this solid
+ * color or, if the transformation is such that we can't composite anything at
+ * all, that nothing has changed in the destination.
+ *
+ * The surrounding memory of the source image is a different solid color so that
+ * we are sure to get failures if we access it.
+ */
+static int
+run_test (int32_t		dst_width,
+	  int32_t		dst_height,
+	  int32_t		src_width,
+	  int32_t		src_height,
+	  int32_t		src_x,
+	  int32_t		src_y,
+	  int32_t		scale_x,
+	  int32_t		scale_y,
+	  pixman_filter_t	filter,
+	  pixman_repeat_t	repeat)
+{
+    pixman_image_t *   src_img;
+    pixman_image_t *   dst_img;
+    pixman_transform_t transform;
+    uint32_t *         srcbuf;
+    uint32_t *         dstbuf;
+    pixman_box32_t     box = { 0, 0, src_width, src_height };
+    pixman_color_t     color_cc = { 0xcccc, 0xcccc, 0xcccc, 0xcccc };
+    int result;
+    int i;
+
+    static const pixman_fixed_t kernel[] =
+    {
+#define D(f)	(pixman_double_to_fixed (f) + 0x0001)
+
+	pixman_int_to_fixed (5),
+	pixman_int_to_fixed (5),
+	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0),
+	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0),
+	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0),
+	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0),
+	D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0), D(1/25.0)
+    };
+
+    result = 0;
+
+    srcbuf = (uint32_t *)malloc ((src_width + 10) * (src_height + 10) * 4);
+    dstbuf = (uint32_t *)malloc (dst_width * dst_height * 4);
+
+    memset (srcbuf, 0x88, src_width * src_height * 4);
+    memset (dstbuf, 0x33, dst_width * dst_height * 4);
+
+    src_img = pixman_image_create_bits (
+        PIXMAN_a8r8g8b8, src_width, src_height,
+	srcbuf + (src_width + 10) * 5 + 5, (src_width + 10) * 4);
+
+    pixman_image_fill_boxes (PIXMAN_OP_SRC, src_img, &color_cc, 1, &box);
+
+    dst_img = pixman_image_create_bits (
+        PIXMAN_a8r8g8b8, dst_width, dst_height, dstbuf, dst_width * 4);
+
+    pixman_transform_init_scale (&transform, scale_x, scale_y);
+    pixman_image_set_transform (src_img, &transform);
+    pixman_image_set_repeat (src_img, repeat);
+    if (filter == PIXMAN_FILTER_CONVOLUTION)
+	pixman_image_set_filter (src_img, filter, kernel, 27);
+    else
+	pixman_image_set_filter (src_img, filter, NULL, 0);
+
+    pixman_image_composite (PIXMAN_OP_SRC, src_img, NULL, dst_img,
+                            src_x, src_y, 0, 0, 0, 0, dst_width, dst_height);
+
+    pixman_image_unref (src_img);
+    pixman_image_unref (dst_img);
+
+    for (i = 0; i < dst_width * dst_height; i++)
+    {
+	if (dstbuf[i] != 0xCCCCCCCC && dstbuf[i] != 0x33333333)
+	{
+	    result = 1;
+	    break;
+	}
+    }
+
+    free (srcbuf);
+    free (dstbuf);
+    return result;
+}
+
+typedef struct filter_info_t filter_info_t;
+struct filter_info_t
+{
+    pixman_filter_t value;
+    char name[28];
+};
+
+static const filter_info_t filters[] =
+{
+    { PIXMAN_FILTER_NEAREST, "NEAREST" },
+    { PIXMAN_FILTER_BILINEAR, "BILINEAR" },
+    { PIXMAN_FILTER_CONVOLUTION, "CONVOLUTION" },
+};
+
+typedef struct repeat_info_t repeat_info_t;
+struct repeat_info_t
+{
+    pixman_repeat_t value;
+    char name[28];
+};
+
+
+static const repeat_info_t repeats[] =
+{
+    { PIXMAN_REPEAT_PAD, "PAD" },
+    { PIXMAN_REPEAT_REFLECT, "REFLECT" },
+    { PIXMAN_REPEAT_NORMAL, "NORMAL" }
+};
+
+static int
+do_test (int32_t		dst_size,
+	 int32_t		src_size,
+	 int32_t		src_offs,
+	 int32_t		scale_factor)
+{
+    int i, j;
+
+    for (i = 0; i < ARRAY_LENGTH (filters); ++i)
+    {
+	for (j = 0; j < ARRAY_LENGTH (repeats); ++j)
+	{
+	    /* horizontal test */
+	    if (run_test (dst_size, 1,
+			  src_size, 1,
+			  src_offs, 0,
+			  scale_factor, 65536,
+			  filters[i].value,
+			  repeats[j].value) != 0)
+	    {
+		printf ("Vertical test failed with %s filter and repeat mode %s\n",
+			filters[i].name, repeats[j].name);
+
+		return 1;
+	    }
+
+	    /* vertical test */
+	    if (run_test (1, dst_size,
+			  1, src_size,
+			  0, src_offs,
+			  65536, scale_factor,
+			  filters[i].value,
+			  repeats[j].value) != 0)
+	    {
+		printf ("Vertical test failed with %s filter and repeat mode %s\n",
+			filters[i].name, repeats[j].name);
+
+		return 1;
+	    }
+	}
+    }
+
+    return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+    int i;
+
+    pixman_disable_out_of_bounds_workaround ();
+
+    /* can potentially crash */
+    assert (do_test (
+		48000, 32767, 1, 65536 * 128) == 0);
+
+    /* can potentially get into a deadloop */
+    assert (do_test (
+		16384, 65536, 32, 32768) == 0);
+
+    /* can potentially access memory outside source image buffer */
+    assert (do_test (
+		10, 10, 0, 1) == 0);
+    assert (do_test (
+		10, 10, 0, 0) == 0);
+
+    for (i = 0; i < 100; ++i)
+    {
+	pixman_fixed_t one_seventh =
+	    (((pixman_fixed_48_16_t)pixman_fixed_1) << 16) / (7 << 16);
+
+	assert (do_test (
+		    1, 7, 3, one_seventh + i - 50) == 0);
+    }
+
+    for (i = 0; i < 100; ++i)
+    {
+	pixman_fixed_t scale =
+	    (((pixman_fixed_48_16_t)pixman_fixed_1) << 16) / (32767 << 16);
+
+	assert (do_test (
+		    1, 32767, 16383, scale + i - 50) == 0);
+    }
+
+    /* can potentially provide invalid results (out of range matrix stuff) */
+    assert (do_test (
+	48000, 32767, 16384, 65536 * 128) == 0);
+
+    return 0;
+}
diff --git a/pixman/test/scaling-test.c b/pixman/test/scaling-test.c
index f247e1e9a..6f2da1432 100644
--- a/pixman/test/scaling-test.c
+++ b/pixman/test/scaling-test.c
@@ -1,368 +1,367 @@
-/*

- * Test program, which can detect some problems with nearest neighbour

- * and bilinear scaling in pixman. Testing is done by running lots

- * of random SRC and OVER compositing operations a8r8g8b8, x8a8r8g8b8

- * and r5g6b5 color formats.

- *

- * Script 'fuzzer-find-diff.pl' can be used to narrow down the problem in

- * the case of test failure.

- */

-#include <assert.h>

-#include <stdlib.h>

-#include <stdio.h>

-#include "utils.h"

-

-#define MAX_SRC_WIDTH  48

-#define MAX_SRC_HEIGHT 8

-#define MAX_DST_WIDTH  48

-#define MAX_DST_HEIGHT 8

-#define MAX_STRIDE     4

-

-/*

- * Composite operation with pseudorandom images

- */

-uint32_t

-test_composite (int      testnum,

-		int      verbose)

-{

-    int                i;

-    pixman_image_t *   src_img;

-    pixman_image_t *   mask_img;

-    pixman_image_t *   dst_img;

-    pixman_transform_t transform;

-    pixman_region16_t  clip;

-    int                src_width, src_height;

-    int                mask_width, mask_height;

-    int                dst_width, dst_height;

-    int                src_stride, mask_stride, dst_stride;

-    int                src_x, src_y;

-    int                mask_x, mask_y;

-    int                dst_x, dst_y;

-    int                src_bpp;

-    int                mask_bpp = 1;

-    int                dst_bpp;

-    int                w, h;

-    pixman_fixed_t     scale_x = 65536, scale_y = 65536;

-    pixman_fixed_t     translate_x = 0, translate_y = 0;

-    pixman_fixed_t     mask_scale_x = 65536, mask_scale_y = 65536;

-    pixman_fixed_t     mask_translate_x = 0, mask_translate_y = 0;

-    pixman_op_t        op;

-    pixman_repeat_t    repeat = PIXMAN_REPEAT_NONE;

-    pixman_repeat_t    mask_repeat = PIXMAN_REPEAT_NONE;

-    pixman_format_code_t src_fmt, dst_fmt;

-    uint32_t *         srcbuf;

-    uint32_t *         dstbuf;

-    uint32_t *         maskbuf;

-    uint32_t           crc32;

-    FLOAT_REGS_CORRUPTION_DETECTOR_START ();

-

-    lcg_srand (testnum);

-

-    src_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;

-    dst_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;

-    switch (lcg_rand_n (3))

-    {

-    case 0:

-	op = PIXMAN_OP_SRC;

-	break;

-    case 1:

-	op = PIXMAN_OP_OVER;

-	break;

-    default:

-	op = PIXMAN_OP_ADD;

-	break;

-    }

-

-    src_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;

-    src_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;

-

-    if (lcg_rand_n (2))

-    {

-	mask_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;

-	mask_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;

-    }

-    else

-    {

-	mask_width = mask_height = 1;

-    }

-

-    dst_width = lcg_rand_n (MAX_DST_WIDTH) + 1;

-    dst_height = lcg_rand_n (MAX_DST_HEIGHT) + 1;

-    src_stride = src_width * src_bpp + lcg_rand_n (MAX_STRIDE) * src_bpp;

-    mask_stride = mask_width * mask_bpp + lcg_rand_n (MAX_STRIDE) * mask_bpp;

-    dst_stride = dst_width * dst_bpp + lcg_rand_n (MAX_STRIDE) * dst_bpp;

-

-    if (src_stride & 3)

-	src_stride += 2;

-

-    if (mask_stride & 1)

-	mask_stride += 1;

-    if (mask_stride & 2)

-	mask_stride += 2;

-

-    if (dst_stride & 3)

-	dst_stride += 2;

-

-    src_x = -(src_width / 4) + lcg_rand_n (src_width * 3 / 2);

-    src_y = -(src_height / 4) + lcg_rand_n (src_height * 3 / 2);

-    mask_x = -(mask_width / 4) + lcg_rand_n (mask_width * 3 / 2);

-    mask_y = -(mask_height / 4) + lcg_rand_n (mask_height * 3 / 2);

-    dst_x = -(dst_width / 4) + lcg_rand_n (dst_width * 3 / 2);

-    dst_y = -(dst_height / 4) + lcg_rand_n (dst_height * 3 / 2);

-    w = lcg_rand_n (dst_width * 3 / 2 - dst_x);

-    h = lcg_rand_n (dst_height * 3 / 2 - dst_y);

-

-    srcbuf = (uint32_t *)malloc (src_stride * src_height);

-    maskbuf = (uint32_t *)malloc (mask_stride * mask_height);

-    dstbuf = (uint32_t *)malloc (dst_stride * dst_height);

-

-    for (i = 0; i < src_stride * src_height; i++)

-	*((uint8_t *)srcbuf + i) = lcg_rand_n (256);

-

-    for (i = 0; i < mask_stride * mask_height; i++)

-	*((uint8_t *)maskbuf + i) = lcg_rand_n (256);

-

-    for (i = 0; i < dst_stride * dst_height; i++)

-	*((uint8_t *)dstbuf + i) = lcg_rand_n (256);

-

-    src_fmt = src_bpp == 4 ? (lcg_rand_n (2) == 0 ?

-                              PIXMAN_a8r8g8b8 : PIXMAN_x8r8g8b8) : PIXMAN_r5g6b5;

-

-    dst_fmt = dst_bpp == 4 ? (lcg_rand_n (2) == 0 ?

-                              PIXMAN_a8r8g8b8 : PIXMAN_x8r8g8b8) : PIXMAN_r5g6b5;

-

-    src_img = pixman_image_create_bits (

-        src_fmt, src_width, src_height, srcbuf, src_stride);

-

-    mask_img = pixman_image_create_bits (

-        PIXMAN_a8, mask_width, mask_height, maskbuf, mask_stride);

-

-    dst_img = pixman_image_create_bits (

-        dst_fmt, dst_width, dst_height, dstbuf, dst_stride);

-

-    image_endian_swap (src_img);

-    image_endian_swap (dst_img);

-

-    if (lcg_rand_n (4) > 0)

-    {

-	scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);

-	scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);

-	translate_x = lcg_rand_N (65536);

-	translate_y = lcg_rand_N (65536);

-	pixman_transform_init_scale (&transform, scale_x, scale_y);

-	pixman_transform_translate (&transform, NULL, translate_x, translate_y);

-	pixman_image_set_transform (src_img, &transform);

-    }

-

-    if (lcg_rand_n (2) > 0)

-    {

-	mask_scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);

-	mask_scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);

-	mask_translate_x = lcg_rand_N (65536);

-	mask_translate_y = lcg_rand_N (65536);

-	pixman_transform_init_scale (&transform, mask_scale_x, mask_scale_y);

-	pixman_transform_translate (&transform, NULL, mask_translate_x, mask_translate_y);

-	pixman_image_set_transform (mask_img, &transform);

-    }

-

-    switch (lcg_rand_n (4))

-    {

-    case 0:

-	mask_repeat = PIXMAN_REPEAT_NONE;

-	break;

-

-    case 1:

-	mask_repeat = PIXMAN_REPEAT_NORMAL;

-	break;

-

-    case 2:

-	mask_repeat = PIXMAN_REPEAT_PAD;

-	break;

-

-    case 3:

-	mask_repeat = PIXMAN_REPEAT_REFLECT;

-	break;

-

-    default:

-        break;

-    }

-    pixman_image_set_repeat (mask_img, mask_repeat);

-

-    switch (lcg_rand_n (4))

-    {

-    case 0:

-	repeat = PIXMAN_REPEAT_NONE;

-	break;

-

-    case 1:

-	repeat = PIXMAN_REPEAT_NORMAL;

-	break;

-

-    case 2:

-	repeat = PIXMAN_REPEAT_PAD;

-	break;

-

-    case 3:

-	repeat = PIXMAN_REPEAT_REFLECT;

-	break;

-

-    default:

-        break;

-    }

-    pixman_image_set_repeat (src_img, repeat);

-

-    if (lcg_rand_n (2))

-	pixman_image_set_filter (src_img, PIXMAN_FILTER_NEAREST, NULL, 0);

-    else

-	pixman_image_set_filter (src_img, PIXMAN_FILTER_BILINEAR, NULL, 0);

-

-    if (lcg_rand_n (2))

-	pixman_image_set_filter (mask_img, PIXMAN_FILTER_NEAREST, NULL, 0);

-    else

-	pixman_image_set_filter (mask_img, PIXMAN_FILTER_BILINEAR, NULL, 0);

-

-    if (verbose)

-    {

-	printf ("src_fmt=%08X, dst_fmt=%08X\n", src_fmt, dst_fmt);

-	printf ("op=%d, scale_x=%d, scale_y=%d, repeat=%d\n",

-	        op, scale_x, scale_y, repeat);

-	printf ("translate_x=%d, translate_y=%d\n",

-	        translate_x, translate_y);

-	printf ("src_width=%d, src_height=%d, dst_width=%d, dst_height=%d\n",

-	        src_width, src_height, dst_width, dst_height);

-	printf ("src_x=%d, src_y=%d, dst_x=%d, dst_y=%d\n",

-	        src_x, src_y, dst_x, dst_y);

-	printf ("w=%d, h=%d\n", w, h);

-    }

-

-    if (lcg_rand_n (8) == 0)

-    {

-	pixman_box16_t clip_boxes[2];

-	int            n = lcg_rand_n (2) + 1;

-

-	for (i = 0; i < n; i++)

-	{

-	    clip_boxes[i].x1 = lcg_rand_n (src_width);

-	    clip_boxes[i].y1 = lcg_rand_n (src_height);

-	    clip_boxes[i].x2 =

-		clip_boxes[i].x1 + lcg_rand_n (src_width - clip_boxes[i].x1);

-	    clip_boxes[i].y2 =

-		clip_boxes[i].y1 + lcg_rand_n (src_height - clip_boxes[i].y1);

-

-	    if (verbose)

-	    {

-		printf ("source clip box: [%d,%d-%d,%d]\n",

-		        clip_boxes[i].x1, clip_boxes[i].y1,

-		        clip_boxes[i].x2, clip_boxes[i].y2);

-	    }

-	}

-

-	pixman_region_init_rects (&clip, clip_boxes, n);

-	pixman_image_set_clip_region (src_img, &clip);

-	pixman_image_set_source_clipping (src_img, 1);

-	pixman_region_fini (&clip);

-    }

-

-    if (lcg_rand_n (8) == 0)

-    {

-	pixman_box16_t clip_boxes[2];

-	int            n = lcg_rand_n (2) + 1;

-

-	for (i = 0; i < n; i++)

-	{

-	    clip_boxes[i].x1 = lcg_rand_n (mask_width);

-	    clip_boxes[i].y1 = lcg_rand_n (mask_height);

-	    clip_boxes[i].x2 =

-		clip_boxes[i].x1 + lcg_rand_n (mask_width - clip_boxes[i].x1);

-	    clip_boxes[i].y2 =

-		clip_boxes[i].y1 + lcg_rand_n (mask_height - clip_boxes[i].y1);

-

-	    if (verbose)

-	    {

-		printf ("mask clip box: [%d,%d-%d,%d]\n",

-		        clip_boxes[i].x1, clip_boxes[i].y1,

-		        clip_boxes[i].x2, clip_boxes[i].y2);

-	    }

-	}

-

-	pixman_region_init_rects (&clip, clip_boxes, n);

-	pixman_image_set_clip_region (mask_img, &clip);

-	pixman_image_set_source_clipping (mask_img, 1);

-	pixman_region_fini (&clip);

-    }

-

-    if (lcg_rand_n (8) == 0)

-    {

-	pixman_box16_t clip_boxes[2];

-	int            n = lcg_rand_n (2) + 1;

-	for (i = 0; i < n; i++)

-	{

-	    clip_boxes[i].x1 = lcg_rand_n (dst_width);

-	    clip_boxes[i].y1 = lcg_rand_n (dst_height);

-	    clip_boxes[i].x2 =

-		clip_boxes[i].x1 + lcg_rand_n (dst_width - clip_boxes[i].x1);

-	    clip_boxes[i].y2 =

-		clip_boxes[i].y1 + lcg_rand_n (dst_height - clip_boxes[i].y1);

-

-	    if (verbose)

-	    {

-		printf ("destination clip box: [%d,%d-%d,%d]\n",

-		        clip_boxes[i].x1, clip_boxes[i].y1,

-		        clip_boxes[i].x2, clip_boxes[i].y2);

-	    }

-	}

-	pixman_region_init_rects (&clip, clip_boxes, n);

-	pixman_image_set_clip_region (dst_img, &clip);

-	pixman_region_fini (&clip);

-    }

-

-    if (lcg_rand_n (2) == 0)

-	pixman_image_composite (op, src_img, NULL, dst_img,

-                            src_x, src_y, 0, 0, dst_x, dst_y, w, h);

-    else

-	pixman_image_composite (op, src_img, mask_img, dst_img,

-                            src_x, src_y, mask_x, mask_y, dst_x, dst_y, w, h);

-

-    if (dst_fmt == PIXMAN_x8r8g8b8)

-    {

-	/* ignore unused part */

-	for (i = 0; i < dst_stride * dst_height / 4; i++)

-	    dstbuf[i] &= 0xFFFFFF;

-    }

-

-    image_endian_swap (dst_img);

-

-    if (verbose)

-    {

-	int j;

-	

-	for (i = 0; i < dst_height; i++)

-	{

-	    for (j = 0; j < dst_stride; j++)

-		printf ("%02X ", *((uint8_t *)dstbuf + i * dst_stride + j));

-

-	    printf ("\n");

-	}

-    }

-

-    pixman_image_unref (src_img);

-    pixman_image_unref (mask_img);

-    pixman_image_unref (dst_img);

-

-    crc32 = compute_crc32 (0, dstbuf, dst_stride * dst_height);

-    free (srcbuf);

-    free (maskbuf);

-    free (dstbuf);

-

-    FLOAT_REGS_CORRUPTION_DETECTOR_FINISH ();

-    return crc32;

-}

-

-int

-main (int argc, const char *argv[])

-{

-    pixman_disable_out_of_bounds_workaround ();

-

-    return fuzzer_test_main("scaling", 8000000, 0x80DF1CB2,

-			    test_composite, argc, argv);

-}

+/*
+ * Test program, which can detect some problems with nearest neighbour
+ * and bilinear scaling in pixman. Testing is done by running lots
+ * of random SRC and OVER compositing operations a8r8g8b8, x8a8r8g8b8
+ * and r5g6b5 color formats.
+ *
+ * Script 'fuzzer-find-diff.pl' can be used to narrow down the problem in
+ * the case of test failure.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include "utils.h"
+
+#define MAX_SRC_WIDTH  48
+#define MAX_SRC_HEIGHT 8
+#define MAX_DST_WIDTH  48
+#define MAX_DST_HEIGHT 8
+#define MAX_STRIDE     4
+
+/*
+ * Composite operation with pseudorandom images
+ */
+uint32_t
+test_composite (int      testnum,
+		int      verbose)
+{
+    int                i;
+    pixman_image_t *   src_img;
+    pixman_image_t *   mask_img;
+    pixman_image_t *   dst_img;
+    pixman_transform_t transform;
+    pixman_region16_t  clip;
+    int                src_width, src_height;
+    int                mask_width, mask_height;
+    int                dst_width, dst_height;
+    int                src_stride, mask_stride, dst_stride;
+    int                src_x, src_y;
+    int                mask_x, mask_y;
+    int                dst_x, dst_y;
+    int                src_bpp;
+    int                mask_bpp = 1;
+    int                dst_bpp;
+    int                w, h;
+    pixman_fixed_t     scale_x = 65536, scale_y = 65536;
+    pixman_fixed_t     translate_x = 0, translate_y = 0;
+    pixman_fixed_t     mask_scale_x = 65536, mask_scale_y = 65536;
+    pixman_fixed_t     mask_translate_x = 0, mask_translate_y = 0;
+    pixman_op_t        op;
+    pixman_repeat_t    repeat = PIXMAN_REPEAT_NONE;
+    pixman_repeat_t    mask_repeat = PIXMAN_REPEAT_NONE;
+    pixman_format_code_t src_fmt, dst_fmt;
+    uint32_t *         srcbuf;
+    uint32_t *         dstbuf;
+    uint32_t *         maskbuf;
+    uint32_t           crc32;
+    FLOAT_REGS_CORRUPTION_DETECTOR_START ();
+
+    lcg_srand (testnum);
+
+    src_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;
+    dst_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;
+    switch (lcg_rand_n (3))
+    {
+    case 0:
+	op = PIXMAN_OP_SRC;
+	break;
+    case 1:
+	op = PIXMAN_OP_OVER;
+	break;
+    default:
+	op = PIXMAN_OP_ADD;
+	break;
+    }
+
+    src_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;
+    src_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;
+
+    if (lcg_rand_n (2))
+    {
+	mask_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;
+	mask_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;
+    }
+    else
+    {
+	mask_width = mask_height = 1;
+    }
+
+    dst_width = lcg_rand_n (MAX_DST_WIDTH) + 1;
+    dst_height = lcg_rand_n (MAX_DST_HEIGHT) + 1;
+    src_stride = src_width * src_bpp + lcg_rand_n (MAX_STRIDE) * src_bpp;
+    mask_stride = mask_width * mask_bpp + lcg_rand_n (MAX_STRIDE) * mask_bpp;
+    dst_stride = dst_width * dst_bpp + lcg_rand_n (MAX_STRIDE) * dst_bpp;
+
+    if (src_stride & 3)
+	src_stride += 2;
+
+    if (mask_stride & 1)
+	mask_stride += 1;
+    if (mask_stride & 2)
+	mask_stride += 2;
+
+    if (dst_stride & 3)
+	dst_stride += 2;
+
+    src_x = -(src_width / 4) + lcg_rand_n (src_width * 3 / 2);
+    src_y = -(src_height / 4) + lcg_rand_n (src_height * 3 / 2);
+    mask_x = -(mask_width / 4) + lcg_rand_n (mask_width * 3 / 2);
+    mask_y = -(mask_height / 4) + lcg_rand_n (mask_height * 3 / 2);
+    dst_x = -(dst_width / 4) + lcg_rand_n (dst_width * 3 / 2);
+    dst_y = -(dst_height / 4) + lcg_rand_n (dst_height * 3 / 2);
+    w = lcg_rand_n (dst_width * 3 / 2 - dst_x);
+    h = lcg_rand_n (dst_height * 3 / 2 - dst_y);
+
+    srcbuf = (uint32_t *)malloc (src_stride * src_height);
+    maskbuf = (uint32_t *)malloc (mask_stride * mask_height);
+    dstbuf = (uint32_t *)malloc (dst_stride * dst_height);
+
+    for (i = 0; i < src_stride * src_height; i++)
+	*((uint8_t *)srcbuf + i) = lcg_rand_n (256);
+
+    for (i = 0; i < mask_stride * mask_height; i++)
+	*((uint8_t *)maskbuf + i) = lcg_rand_n (256);
+
+    for (i = 0; i < dst_stride * dst_height; i++)
+	*((uint8_t *)dstbuf + i) = lcg_rand_n (256);
+
+    src_fmt = src_bpp == 4 ? (lcg_rand_n (2) == 0 ?
+                              PIXMAN_a8r8g8b8 : PIXMAN_x8r8g8b8) : PIXMAN_r5g6b5;
+
+    dst_fmt = dst_bpp == 4 ? (lcg_rand_n (2) == 0 ?
+                              PIXMAN_a8r8g8b8 : PIXMAN_x8r8g8b8) : PIXMAN_r5g6b5;
+
+    src_img = pixman_image_create_bits (
+        src_fmt, src_width, src_height, srcbuf, src_stride);
+
+    mask_img = pixman_image_create_bits (
+        PIXMAN_a8, mask_width, mask_height, maskbuf, mask_stride);
+
+    dst_img = pixman_image_create_bits (
+        dst_fmt, dst_width, dst_height, dstbuf, dst_stride);
+
+    image_endian_swap (src_img);
+    image_endian_swap (dst_img);
+
+    if (lcg_rand_n (4) > 0)
+    {
+	scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);
+	scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);
+	translate_x = lcg_rand_N (65536);
+	translate_y = lcg_rand_N (65536);
+	pixman_transform_init_scale (&transform, scale_x, scale_y);
+	pixman_transform_translate (&transform, NULL, translate_x, translate_y);
+	pixman_image_set_transform (src_img, &transform);
+    }
+
+    if (lcg_rand_n (2) > 0)
+    {
+	mask_scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);
+	mask_scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);
+	mask_translate_x = lcg_rand_N (65536);
+	mask_translate_y = lcg_rand_N (65536);
+	pixman_transform_init_scale (&transform, mask_scale_x, mask_scale_y);
+	pixman_transform_translate (&transform, NULL, mask_translate_x, mask_translate_y);
+	pixman_image_set_transform (mask_img, &transform);
+    }
+
+    switch (lcg_rand_n (4))
+    {
+    case 0:
+	mask_repeat = PIXMAN_REPEAT_NONE;
+	break;
+
+    case 1:
+	mask_repeat = PIXMAN_REPEAT_NORMAL;
+	break;
+
+    case 2:
+	mask_repeat = PIXMAN_REPEAT_PAD;
+	break;
+
+    case 3:
+	mask_repeat = PIXMAN_REPEAT_REFLECT;
+	break;
+
+    default:
+        break;
+    }
+    pixman_image_set_repeat (mask_img, mask_repeat);
+
+    switch (lcg_rand_n (4))
+    {
+    case 0:
+	repeat = PIXMAN_REPEAT_NONE;
+	break;
+
+    case 1:
+	repeat = PIXMAN_REPEAT_NORMAL;
+	break;
+
+    case 2:
+	repeat = PIXMAN_REPEAT_PAD;
+	break;
+
+    case 3:
+	repeat = PIXMAN_REPEAT_REFLECT;
+	break;
+
+    default:
+        break;
+    }
+    pixman_image_set_repeat (src_img, repeat);
+
+    if (lcg_rand_n (2))
+	pixman_image_set_filter (src_img, PIXMAN_FILTER_NEAREST, NULL, 0);
+    else
+	pixman_image_set_filter (src_img, PIXMAN_FILTER_BILINEAR, NULL, 0);
+
+    if (lcg_rand_n (2))
+	pixman_image_set_filter (mask_img, PIXMAN_FILTER_NEAREST, NULL, 0);
+    else
+	pixman_image_set_filter (mask_img, PIXMAN_FILTER_BILINEAR, NULL, 0);
+
+    if (verbose)
+    {
+	printf ("src_fmt=%08X, dst_fmt=%08X\n", src_fmt, dst_fmt);
+	printf ("op=%d, scale_x=%d, scale_y=%d, repeat=%d\n",
+	        op, scale_x, scale_y, repeat);
+	printf ("translate_x=%d, translate_y=%d\n",
+	        translate_x, translate_y);
+	printf ("src_width=%d, src_height=%d, dst_width=%d, dst_height=%d\n",
+	        src_width, src_height, dst_width, dst_height);
+	printf ("src_x=%d, src_y=%d, dst_x=%d, dst_y=%d\n",
+	        src_x, src_y, dst_x, dst_y);
+	printf ("w=%d, h=%d\n", w, h);
+    }
+
+    if (lcg_rand_n (8) == 0)
+    {
+	pixman_box16_t clip_boxes[2];
+	int            n = lcg_rand_n (2) + 1;
+
+	for (i = 0; i < n; i++)
+	{
+	    clip_boxes[i].x1 = lcg_rand_n (src_width);
+	    clip_boxes[i].y1 = lcg_rand_n (src_height);
+	    clip_boxes[i].x2 =
+		clip_boxes[i].x1 + lcg_rand_n (src_width - clip_boxes[i].x1);
+	    clip_boxes[i].y2 =
+		clip_boxes[i].y1 + lcg_rand_n (src_height - clip_boxes[i].y1);
+
+	    if (verbose)
+	    {
+		printf ("source clip box: [%d,%d-%d,%d]\n",
+		        clip_boxes[i].x1, clip_boxes[i].y1,
+		        clip_boxes[i].x2, clip_boxes[i].y2);
+	    }
+	}
+
+	pixman_region_init_rects (&clip, clip_boxes, n);
+	pixman_image_set_clip_region (src_img, &clip);
+	pixman_image_set_source_clipping (src_img, 1);
+	pixman_region_fini (&clip);
+    }
+
+    if (lcg_rand_n (8) == 0)
+    {
+	pixman_box16_t clip_boxes[2];
+	int            n = lcg_rand_n (2) + 1;
+
+	for (i = 0; i < n; i++)
+	{
+	    clip_boxes[i].x1 = lcg_rand_n (mask_width);
+	    clip_boxes[i].y1 = lcg_rand_n (mask_height);
+	    clip_boxes[i].x2 =
+		clip_boxes[i].x1 + lcg_rand_n (mask_width - clip_boxes[i].x1);
+	    clip_boxes[i].y2 =
+		clip_boxes[i].y1 + lcg_rand_n (mask_height - clip_boxes[i].y1);
+
+	    if (verbose)
+	    {
+		printf ("mask clip box: [%d,%d-%d,%d]\n",
+		        clip_boxes[i].x1, clip_boxes[i].y1,
+		        clip_boxes[i].x2, clip_boxes[i].y2);
+	    }
+	}
+
+	pixman_region_init_rects (&clip, clip_boxes, n);
+	pixman_image_set_clip_region (mask_img, &clip);
+	pixman_image_set_source_clipping (mask_img, 1);
+	pixman_region_fini (&clip);
+    }
+
+    if (lcg_rand_n (8) == 0)
+    {
+	pixman_box16_t clip_boxes[2];
+	int            n = lcg_rand_n (2) + 1;
+	for (i = 0; i < n; i++)
+	{
+	    clip_boxes[i].x1 = lcg_rand_n (dst_width);
+	    clip_boxes[i].y1 = lcg_rand_n (dst_height);
+	    clip_boxes[i].x2 =
+		clip_boxes[i].x1 + lcg_rand_n (dst_width - clip_boxes[i].x1);
+	    clip_boxes[i].y2 =
+		clip_boxes[i].y1 + lcg_rand_n (dst_height - clip_boxes[i].y1);
+
+	    if (verbose)
+	    {
+		printf ("destination clip box: [%d,%d-%d,%d]\n",
+		        clip_boxes[i].x1, clip_boxes[i].y1,
+		        clip_boxes[i].x2, clip_boxes[i].y2);
+	    }
+	}
+	pixman_region_init_rects (&clip, clip_boxes, n);
+	pixman_image_set_clip_region (dst_img, &clip);
+	pixman_region_fini (&clip);
+    }
+
+    if (lcg_rand_n (2) == 0)
+	pixman_image_composite (op, src_img, NULL, dst_img,
+                            src_x, src_y, 0, 0, dst_x, dst_y, w, h);
+    else
+	pixman_image_composite (op, src_img, mask_img, dst_img,
+                            src_x, src_y, mask_x, mask_y, dst_x, dst_y, w, h);
+
+    if (dst_fmt == PIXMAN_x8r8g8b8)
+    {
+	/* ignore unused part */
+	for (i = 0; i < dst_stride * dst_height / 4; i++)
+	    dstbuf[i] &= 0xFFFFFF;
+    }
+
+    image_endian_swap (dst_img);
+
+    if (verbose)
+    {
+	int j;
+	
+	for (i = 0; i < dst_height; i++)
+	{
+	    for (j = 0; j < dst_stride; j++)
+		printf ("%02X ", *((uint8_t *)dstbuf + i * dst_stride + j));
+
+	    printf ("\n");
+	}
+    }
+
+    pixman_image_unref (src_img);
+    pixman_image_unref (mask_img);
+    pixman_image_unref (dst_img);
+
+    crc32 = compute_crc32 (0, dstbuf, dst_stride * dst_height);
+    free (srcbuf);
+    free (maskbuf);
+    free (dstbuf);
+
+    FLOAT_REGS_CORRUPTION_DETECTOR_FINISH ();
+    return crc32;
+}
+
+int
+main (int argc, const char *argv[])
+{
+    pixman_disable_out_of_bounds_workaround ();
+
+    return fuzzer_test_main("scaling", 8000000, 0x80DF1CB2,
+			    test_composite, argc, argv);
+}
diff --git a/pixman/test/stress-test.c b/pixman/test/stress-test.c
index 571420ab0..08bf1d4df 100644
--- a/pixman/test/stress-test.c
+++ b/pixman/test/stress-test.c
@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <stdlib.h>
 #include "utils.h"
 #include <sys/types.h>
 
diff --git a/pixman/test/trap-crasher.c b/pixman/test/trap-crasher.c
index 7485e62fd..4e4cac297 100644
--- a/pixman/test/trap-crasher.c
+++ b/pixman/test/trap-crasher.c
@@ -1,5 +1,5 @@
 #include <stdlib.h>
-#include <pixman.h>
+#include "utils.h"
 
 int
 main()
@@ -22,6 +22,6 @@ main()
 
     dst = pixman_image_create_bits (PIXMAN_a8, 1, 1, NULL, -1);
 
-    pixman_add_trapezoids (dst, 0, 0, sizeof (traps)/sizeof (traps[0]), traps);
+    pixman_add_trapezoids (dst, 0, 0, ARRAY_LENGTH (traps), traps);
     return (0);
 }
diff --git a/pixman/test/utils.c b/pixman/test/utils.c
index adabd75dd..204066f9b 100644
--- a/pixman/test/utils.c
+++ b/pixman/test/utils.c
@@ -2,6 +2,7 @@
 
 #include "utils.h"
 #include <signal.h>
+#include <stdlib.h>
 
 #ifdef HAVE_GETTIMEOFDAY
 #include <sys/time.h>
diff --git a/pixman/test/utils.h b/pixman/test/utils.h
index b23925c4a..3bff78e76 100644
--- a/pixman/test/utils.h
+++ b/pixman/test/utils.h
@@ -2,7 +2,6 @@
 #include <config.h>
 #endif
 
-#include <stdlib.h>
 #include <assert.h>
 #include "pixman-private.h" /* For 'inline' definition */