pixman git update 6/8/2010

1 files changed, 484 insertions, 497 deletions

diff --git a/pixman/test/blitters-test.c b/pixman/test/blitters-test.c
index 18f871eae..1340e081a 100644
--- a/pixman/test/blitters-test.c
+++ b/pixman/test/blitters-test.c
@@ -1,497 +1,484 @@
-/*
- * Test program, which stresses the use of different color formats and
- * compositing operations.
- *
- * Just run it without any command line arguments, and it will report either
- *   "blitters test passed" - everything is ok
- *   "blitters test failed!" - there is some problem
- *
- * In the case of failure, finding the problem involves the following steps:
- * 1. Get the reference 'blitters-test' binary. It makes sense to disable all
- *    the cpu specific optimizations in pixman and also configure it with
- *    '--disable-shared' option. Those who are paranoid can also tweak the
- *    sources to disable all fastpath functions. The resulting binary
- *    can be renamed to something like 'blitters-test.ref'.
- * 2. Compile the buggy binary (also with the '--disable-shared' option).
- * 3. Run 'ruby blitters-test-bisect.rb ./blitters-test.ref ./blitters-test'
- * 4. Look at the information about failed case (destination buffer content
- *    will be shown) and try to figure out what is wrong. Loading
- *    test program in gdb, specifying failed test number in the command
- *    line with '-' character prepended and setting breakpoint on
- *    'pixman_image_composite' function can provide detailed information
- *    about function arguments
- */
-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <config.h>
-#include "utils.h"
-
-static pixman_indexed_t palette;
-
-static void *
-aligned_malloc (size_t align, size_t size)
-{
-    void *result;
-
-#ifdef HAVE_POSIX_MEMALIGN
-    if (posix_memalign (&result, align, size) != 0)
-      result = NULL;
-#else
-    result = malloc (size);
-#endif
-
-    return result;
-}
-
-/* Create random image for testing purposes */
-static pixman_image_t *
-create_random_image (pixman_format_code_t *allowed_formats,
-		     int                   max_width,
-		     int                   max_height,
-		     int                   max_extra_stride,
-		     pixman_format_code_t *used_fmt)
-{
-    int n = 0, i, width, height, stride;
-    pixman_format_code_t fmt;
-    uint32_t *buf;
-    pixman_image_t *img;
-
-    while (allowed_formats[n] != -1)
-	n++;
-    fmt = allowed_formats[lcg_rand_n (n)];
-
-    width = lcg_rand_n (max_width) + 1;
-    height = lcg_rand_n (max_height) + 1;
-    stride = (width * PIXMAN_FORMAT_BPP (fmt) + 7) / 8 +
-	lcg_rand_n (max_extra_stride + 1);
-    stride = (stride + 3) & ~3;
-
-    /* do the allocation */
-    buf = aligned_malloc (64, stride * height);
-
-    /* initialize image with random data */
-    for (i = 0; i < stride * height; i++)
-    {
-	/* generation is biased to having more 0 or 255 bytes as
-	 * they are more likely to be special-cased in code
-	 */
-	*((uint8_t *)buf + i) = lcg_rand_n (4) ? lcg_rand_n (256) :
-	    (lcg_rand_n (2) ? 0 : 255);
-    }
-
-    img = pixman_image_create_bits (fmt, width, height, buf, stride);
-
-    if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_COLOR	||
-	PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_GRAY)
-    {
-	pixman_image_set_indexed (img, &palette);
-    }
-
-    image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));
-
-    if (used_fmt) *used_fmt = fmt;
-    return img;
-}
-
-/* Free random image, and optionally update crc32 based on its data */
-static uint32_t
-free_random_image (uint32_t initcrc,
-		   pixman_image_t *img,
-		   pixman_format_code_t fmt)
-{
-    uint32_t crc32 = 0;
-    int stride = pixman_image_get_stride (img);
-    uint32_t *data = pixman_image_get_data (img);
-    int height = pixman_image_get_height (img);
-
-    if (fmt != -1)
-    {
-	/* mask unused 'x' part */
-	if (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt) &&
-	    PIXMAN_FORMAT_DEPTH (fmt) != 0)
-	{
-	    int i;
-	    uint32_t *data = pixman_image_get_data (img);
-	    uint32_t mask = (1 << PIXMAN_FORMAT_DEPTH (fmt)) - 1;
-
-	    if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_BGRA)
-		mask <<= (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt));
-
-	    for (i = 0; i < 32; i++)
-		mask |= mask << (i * PIXMAN_FORMAT_BPP (fmt));
-
-	    for (i = 0; i < stride * height / 4; i++)
-		data[i] &= mask;
-	}
-
-	/* swap endiannes in order to provide identical results on both big
-	 * and litte endian systems
-	 */
-	image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));
-	crc32 = compute_crc32 (initcrc, data, stride * height);
-    }
-
-    pixman_image_unref (img);
-    free (data);
-
-    return crc32;
-}
-
-static pixman_op_t op_list[] = {
-    PIXMAN_OP_SRC,
-    PIXMAN_OP_OVER,
-    PIXMAN_OP_ADD,
-    PIXMAN_OP_CLEAR,
-    PIXMAN_OP_SRC,
-    PIXMAN_OP_DST,
-    PIXMAN_OP_OVER,
-    PIXMAN_OP_OVER_REVERSE,
-    PIXMAN_OP_IN,
-    PIXMAN_OP_IN_REVERSE,
-    PIXMAN_OP_OUT,
-    PIXMAN_OP_OUT_REVERSE,
-    PIXMAN_OP_ATOP,
-    PIXMAN_OP_ATOP_REVERSE,
-    PIXMAN_OP_XOR,
-    PIXMAN_OP_ADD,
-    PIXMAN_OP_SATURATE,
-    PIXMAN_OP_DISJOINT_CLEAR,
-    PIXMAN_OP_DISJOINT_SRC,
-    PIXMAN_OP_DISJOINT_DST,
-    PIXMAN_OP_DISJOINT_OVER,
-    PIXMAN_OP_DISJOINT_OVER_REVERSE,
-    PIXMAN_OP_DISJOINT_IN,
-    PIXMAN_OP_DISJOINT_IN_REVERSE,
-    PIXMAN_OP_DISJOINT_OUT,
-    PIXMAN_OP_DISJOINT_OUT_REVERSE,
-    PIXMAN_OP_DISJOINT_ATOP,
-    PIXMAN_OP_DISJOINT_ATOP_REVERSE,
-    PIXMAN_OP_DISJOINT_XOR,
-    PIXMAN_OP_CONJOINT_CLEAR,
-    PIXMAN_OP_CONJOINT_SRC,
-    PIXMAN_OP_CONJOINT_DST,
-    PIXMAN_OP_CONJOINT_OVER,
-    PIXMAN_OP_CONJOINT_OVER_REVERSE,
-    PIXMAN_OP_CONJOINT_IN,
-    PIXMAN_OP_CONJOINT_IN_REVERSE,
-    PIXMAN_OP_CONJOINT_OUT,
-    PIXMAN_OP_CONJOINT_OUT_REVERSE,
-    PIXMAN_OP_CONJOINT_ATOP,
-    PIXMAN_OP_CONJOINT_ATOP_REVERSE,
-    PIXMAN_OP_CONJOINT_XOR,
-    PIXMAN_OP_MULTIPLY,
-    PIXMAN_OP_SCREEN,
-    PIXMAN_OP_OVERLAY,
-    PIXMAN_OP_DARKEN,
-    PIXMAN_OP_LIGHTEN,
-    PIXMAN_OP_COLOR_DODGE,
-    PIXMAN_OP_COLOR_BURN,
-    PIXMAN_OP_HARD_LIGHT,
-    PIXMAN_OP_DIFFERENCE,
-    PIXMAN_OP_EXCLUSION,
-#if 0 /* these use floating point math and are not always bitexact on different platforms */
-    PIXMAN_OP_SOFT_LIGHT,
-    PIXMAN_OP_HSL_HUE,
-    PIXMAN_OP_HSL_SATURATION,
-    PIXMAN_OP_HSL_COLOR,
-    PIXMAN_OP_HSL_LUMINOSITY,
-#endif
-};
-
-static pixman_format_code_t img_fmt_list[] = {
-    PIXMAN_a8r8g8b8,
-    PIXMAN_x8r8g8b8,
-    PIXMAN_r5g6b5,
-    PIXMAN_r3g3b2,
-    PIXMAN_a8,
-    PIXMAN_a8b8g8r8,
-    PIXMAN_x8b8g8r8,
-    PIXMAN_b8g8r8a8,
-    PIXMAN_b8g8r8x8,
-    PIXMAN_r8g8b8,
-    PIXMAN_b8g8r8,
-    PIXMAN_r5g6b5,
-    PIXMAN_b5g6r5,
-    PIXMAN_x2r10g10b10,
-    PIXMAN_a2r10g10b10,
-    PIXMAN_x2b10g10r10,
-    PIXMAN_a2b10g10r10,
-    PIXMAN_a1r5g5b5,
-    PIXMAN_x1r5g5b5,
-    PIXMAN_a1b5g5r5,
-    PIXMAN_x1b5g5r5,
-    PIXMAN_a4r4g4b4,
-    PIXMAN_x4r4g4b4,
-    PIXMAN_a4b4g4r4,
-    PIXMAN_x4b4g4r4,
-    PIXMAN_a8,
-    PIXMAN_r3g3b2,
-    PIXMAN_b2g3r3,
-    PIXMAN_a2r2g2b2,
-    PIXMAN_a2b2g2r2,
-    PIXMAN_c8,
-    PIXMAN_g8,
-    PIXMAN_x4c4,
-    PIXMAN_x4g4,
-    PIXMAN_c4,
-    PIXMAN_g4,
-    PIXMAN_g1,
-    PIXMAN_x4a4,
-    PIXMAN_a4,
-    PIXMAN_r1g2b1,
-    PIXMAN_b1g2r1,
-    PIXMAN_a1r1g1b1,
-    PIXMAN_a1b1g1r1,
-    PIXMAN_a1,
-    -1
-};
-
-static pixman_format_code_t mask_fmt_list[] = {
-    PIXMAN_a8r8g8b8,
-    PIXMAN_a8,
-    PIXMAN_a4,
-    PIXMAN_a1,
-    -1
-};
-
-
-/*
- * Composite operation with pseudorandom images
- */
-uint32_t
-test_composite (uint32_t initcrc, int testnum, int verbose)
-{
-    int i;
-    pixman_image_t *src_img = NULL;
-    pixman_image_t *dst_img = NULL;
-    pixman_image_t *mask_img = NULL;
-    int src_width, src_height;
-    int dst_width, dst_height;
-    int src_stride, dst_stride;
-    int src_x, src_y;
-    int dst_x, dst_y;
-    int mask_x, mask_y;
-    int w, h;
-    int op;
-    pixman_format_code_t src_fmt, dst_fmt, mask_fmt;
-    uint32_t *dstbuf, *srcbuf, *maskbuf;
-    uint32_t crc32;
-    int max_width, max_height, max_extra_stride;
-
-    max_width = max_height = 24 + testnum / 10000;
-    max_extra_stride = 4 + testnum / 1000000;
-
-    if (max_width > 256)
-	max_width = 256;
-
-    if (max_height > 16)
-	max_height = 16;
-
-    if (max_extra_stride > 8)
-	max_extra_stride = 8;
-
-    lcg_srand (testnum);
-
-    op = op_list[lcg_rand_n (sizeof (op_list) / sizeof (op_list[0]))];
-
-    if (lcg_rand_n (8))
-    {
-	/* normal image */
-	src_img = create_random_image (img_fmt_list, max_width, max_height,
-				       max_extra_stride, &src_fmt);
-    }
-    else
-    {
-	/* solid case */
-	src_img = create_random_image (img_fmt_list, 1, 1,
-				       max_extra_stride, &src_fmt);
-
-	pixman_image_set_repeat (src_img, PIXMAN_REPEAT_NORMAL);
-    }
-
-    dst_img = create_random_image (img_fmt_list, max_width, max_height,
-				   max_extra_stride, &dst_fmt);
-
-    src_width = pixman_image_get_width (src_img);
-    src_height = pixman_image_get_height (src_img);
-    src_stride = pixman_image_get_stride (src_img);
-
-    dst_width = pixman_image_get_width (dst_img);
-    dst_height = pixman_image_get_height (dst_img);
-    dst_stride = pixman_image_get_stride (dst_img);
-
-    dstbuf = pixman_image_get_data (dst_img);
-    srcbuf = pixman_image_get_data (src_img);
-
-    src_x = lcg_rand_n (src_width);
-    src_y = lcg_rand_n (src_height);
-    dst_x = lcg_rand_n (dst_width);
-    dst_y = lcg_rand_n (dst_height);
-
-    mask_img = NULL;
-    mask_fmt = -1;
-    mask_x = 0;
-    mask_y = 0;
-    maskbuf = NULL;
-
-    if ((src_fmt == PIXMAN_x8r8g8b8 || src_fmt == PIXMAN_x8b8g8r8) &&
-	(lcg_rand_n (4) == 0))
-    {
-	/* PIXBUF */
-	mask_fmt = lcg_rand_n (2) ? PIXMAN_a8r8g8b8 : PIXMAN_a8b8g8r8;
-	mask_img = pixman_image_create_bits (mask_fmt,
-	                                     src_width,
-	                                     src_height,
-	                                     srcbuf,
-	                                     src_stride);
-	mask_x = src_x;
-	mask_y = src_y;
-	maskbuf = srcbuf;
-    }
-    else if (lcg_rand_n (2))
-    {
-	if (lcg_rand_n (2))
-	{
-	    mask_img = create_random_image (mask_fmt_list, max_width, max_height,
-					   max_extra_stride, &mask_fmt);
-	}
-	else
-	{
-	    /* solid case */
-	    mask_img = create_random_image (mask_fmt_list, 1, 1,
-					   max_extra_stride, &mask_fmt);
-	    pixman_image_set_repeat (mask_img, PIXMAN_REPEAT_NORMAL);
-	}
-
-	if (lcg_rand_n (2))
-	    pixman_image_set_component_alpha (mask_img, 1);
-
-	mask_x = lcg_rand_n (pixman_image_get_width (mask_img));
-	mask_y = lcg_rand_n (pixman_image_get_height (mask_img));
-    }
-
-
-    w = lcg_rand_n (dst_width - dst_x + 1);
-    h = lcg_rand_n (dst_height - dst_y + 1);
-
-    if (verbose)
-    {
-	printf ("op=%d, src_fmt=%08X, dst_fmt=%08X, mask_fmt=%08X\n",
-	    op, src_fmt, dst_fmt, mask_fmt);
-	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 ("src_stride=%d, dst_stride=%d\n",
-	    src_stride, dst_stride);
-	printf ("w=%d, h=%d\n", w, h);
-    }
-
-    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 (verbose)
-    {
-	int j;
-
-	printf ("---\n");
-	for (i = 0; i < dst_height; i++)
-	{
-	    for (j = 0; j < dst_stride; j++)
-	    {
-		if (j == (dst_width * PIXMAN_FORMAT_BPP (dst_fmt) + 7) / 8)
-		    printf ("| ");
-
-		printf ("%02X ", *((uint8_t *)dstbuf + i * dst_stride + j));
-	    }
-	    printf ("\n");
-	}
-	printf ("---\n");
-    }
-
-    free_random_image (initcrc, src_img, -1);
-    crc32 = free_random_image (initcrc, dst_img, dst_fmt);
-
-    if (mask_img)
-    {
-	if (srcbuf == maskbuf)
-	    pixman_image_unref(mask_img);
-	else
-	    free_random_image (initcrc, mask_img, -1);
-    }
-
-
-    return crc32;
-}
-
-static void
-initialize_palette (void)
-{
-    int i;
-
-    for (i = 0; i < PIXMAN_MAX_INDEXED; ++i)
-	palette.rgba[i] = lcg_rand ();
-
-    for (i = 0; i < 32768; ++i)
-	palette.ent[i] = lcg_rand() & 0xff;
-}
-
-int
-main (int argc, char *argv[])
-{
-    int i, n1 = 1, n2 = 0;
-    uint32_t crc = 0;
-    int verbose = getenv ("VERBOSE") != NULL;
-
-    initialize_palette();
-
-    if (argc >= 3)
-    {
-	n1 = atoi (argv[1]);
-	n2 = atoi (argv[2]);
-    }
-    else if (argc >= 2)
-    {
-	n2 = atoi (argv[1]);
-    }
-    else
-    {
-	n1 = 1;
-	n2 = 2000000;
-    }
-
-    if (n2 < 0)
-    {
-	crc = test_composite (0, abs (n2), 1);
-	printf ("crc32=%08X\n", crc);
-    }
-    else
-    {
-	for (i = n1; i <= n2; i++)
-	{
-	    crc = test_composite (crc, i, 0);
-
-	    if (verbose)
-		printf ("%d: %08X\n", i, crc);
-	}
-	printf ("crc32=%08X\n", crc);
-
-	if (n2 == 2000000)
-	{
-	    /* Predefined value for running with all the fastpath functions
-	       disabled. It needs to be updated every time when changes are
-	       introduced to this program or behavior of pixman changes! */
-	    if (crc == 0x8F9F7DC1)
-	    {
-		printf ("blitters test passed\n");
-	    }
-	    else
-	    {
-		printf ("blitters test failed!\n");
-		return 1;
-	    }
-	}
-    }
-    return 0;
-}
+/*

+ * Test program, which stresses the use of different color formats and

+ * compositing operations.

+ *

+ * 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 <config.h>

+#include "utils.h"

+

+static pixman_indexed_t rgb_palette[9];

+static pixman_indexed_t y_palette[9];

+

+static void *

+aligned_malloc (size_t align, size_t size)

+{

+    void *result;

+

+#ifdef HAVE_POSIX_MEMALIGN

+    if (posix_memalign (&result, align, size) != 0)

+      result = NULL;

+#else

+    result = malloc (size);

+#endif

+

+    return result;

+}

+

+/* Create random image for testing purposes */

+static pixman_image_t *

+create_random_image (pixman_format_code_t *allowed_formats,

+		     int                   max_width,

+		     int                   max_height,

+		     int                   max_extra_stride,

+		     pixman_format_code_t *used_fmt)

+{

+    int n = 0, i, width, height, stride;

+    pixman_format_code_t fmt;

+    uint32_t *buf;

+    pixman_image_t *img;

+

+    while (allowed_formats[n] != -1)

+	n++;

+    fmt = allowed_formats[lcg_rand_n (n)];

+

+    width = lcg_rand_n (max_width) + 1;

+    height = lcg_rand_n (max_height) + 1;

+    stride = (width * PIXMAN_FORMAT_BPP (fmt) + 7) / 8 +

+	lcg_rand_n (max_extra_stride + 1);

+    stride = (stride + 3) & ~3;

+

+    /* do the allocation */

+    buf = aligned_malloc (64, stride * height);

+

+    /* initialize image with random data */

+    for (i = 0; i < stride * height; i++)

+    {

+	/* generation is biased to having more 0 or 255 bytes as

+	 * they are more likely to be special-cased in code

+	 */

+	*((uint8_t *)buf + i) = lcg_rand_n (4) ? lcg_rand_n (256) :

+	    (lcg_rand_n (2) ? 0 : 255);

+    }

+

+    img = pixman_image_create_bits (fmt, width, height, buf, stride);

+

+    if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_COLOR)

+    {

+	pixman_image_set_indexed (img, &(rgb_palette[PIXMAN_FORMAT_BPP (fmt)]));

+    }

+    else if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_GRAY)

+    {

+	pixman_image_set_indexed (img, &(y_palette[PIXMAN_FORMAT_BPP (fmt)]));

+    }

+

+    image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));

+

+    if (used_fmt) *used_fmt = fmt;

+    return img;

+}

+

+/* Free random image, and optionally update crc32 based on its data */

+static uint32_t

+free_random_image (uint32_t initcrc,

+		   pixman_image_t *img,

+		   pixman_format_code_t fmt)

+{

+    uint32_t crc32 = 0;

+    int stride = pixman_image_get_stride (img);

+    uint32_t *data = pixman_image_get_data (img);

+    int height = pixman_image_get_height (img);

+

+    if (fmt != -1)

+    {

+	/* mask unused 'x' part */

+	if (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt) &&

+	    PIXMAN_FORMAT_DEPTH (fmt) != 0)

+	{

+	    int i;

+	    uint32_t *data = pixman_image_get_data (img);

+	    uint32_t mask = (1 << PIXMAN_FORMAT_DEPTH (fmt)) - 1;

+

+	    if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_BGRA)

+		mask <<= (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt));

+

+	    for (i = 0; i < 32; i++)

+		mask |= mask << (i * PIXMAN_FORMAT_BPP (fmt));

+

+	    for (i = 0; i < stride * height / 4; i++)

+		data[i] &= mask;

+	}

+

+	/* swap endiannes in order to provide identical results on both big

+	 * and litte endian systems

+	 */

+	image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));

+	crc32 = compute_crc32 (initcrc, data, stride * height);

+    }

+

+    pixman_image_unref (img);

+    free (data);

+

+    return crc32;

+}

+

+static pixman_op_t op_list[] = {

+    PIXMAN_OP_SRC,

+    PIXMAN_OP_OVER,

+    PIXMAN_OP_ADD,

+    PIXMAN_OP_CLEAR,

+    PIXMAN_OP_SRC,

+    PIXMAN_OP_DST,

+    PIXMAN_OP_OVER,

+    PIXMAN_OP_OVER_REVERSE,

+    PIXMAN_OP_IN,

+    PIXMAN_OP_IN_REVERSE,

+    PIXMAN_OP_OUT,

+    PIXMAN_OP_OUT_REVERSE,

+    PIXMAN_OP_ATOP,

+    PIXMAN_OP_ATOP_REVERSE,

+    PIXMAN_OP_XOR,

+    PIXMAN_OP_ADD,

+    PIXMAN_OP_SATURATE,

+    PIXMAN_OP_DISJOINT_CLEAR,

+    PIXMAN_OP_DISJOINT_SRC,

+    PIXMAN_OP_DISJOINT_DST,

+    PIXMAN_OP_DISJOINT_OVER,

+    PIXMAN_OP_DISJOINT_OVER_REVERSE,

+    PIXMAN_OP_DISJOINT_IN,

+    PIXMAN_OP_DISJOINT_IN_REVERSE,

+    PIXMAN_OP_DISJOINT_OUT,

+    PIXMAN_OP_DISJOINT_OUT_REVERSE,

+    PIXMAN_OP_DISJOINT_ATOP,

+    PIXMAN_OP_DISJOINT_ATOP_REVERSE,

+    PIXMAN_OP_DISJOINT_XOR,

+    PIXMAN_OP_CONJOINT_CLEAR,

+    PIXMAN_OP_CONJOINT_SRC,

+    PIXMAN_OP_CONJOINT_DST,

+    PIXMAN_OP_CONJOINT_OVER,

+    PIXMAN_OP_CONJOINT_OVER_REVERSE,

+    PIXMAN_OP_CONJOINT_IN,

+    PIXMAN_OP_CONJOINT_IN_REVERSE,

+    PIXMAN_OP_CONJOINT_OUT,

+    PIXMAN_OP_CONJOINT_OUT_REVERSE,

+    PIXMAN_OP_CONJOINT_ATOP,

+    PIXMAN_OP_CONJOINT_ATOP_REVERSE,

+    PIXMAN_OP_CONJOINT_XOR,

+    PIXMAN_OP_MULTIPLY,

+    PIXMAN_OP_SCREEN,

+    PIXMAN_OP_OVERLAY,

+    PIXMAN_OP_DARKEN,

+    PIXMAN_OP_LIGHTEN,

+    PIXMAN_OP_COLOR_DODGE,

+    PIXMAN_OP_COLOR_BURN,

+    PIXMAN_OP_HARD_LIGHT,

+    PIXMAN_OP_DIFFERENCE,

+    PIXMAN_OP_EXCLUSION,

+#if 0 /* these use floating point math and are not always bitexact on different platforms */

+    PIXMAN_OP_SOFT_LIGHT,

+    PIXMAN_OP_HSL_HUE,

+    PIXMAN_OP_HSL_SATURATION,

+    PIXMAN_OP_HSL_COLOR,

+    PIXMAN_OP_HSL_LUMINOSITY,

+#endif

+};

+

+static pixman_format_code_t img_fmt_list[] = {

+    PIXMAN_a8r8g8b8,

+    PIXMAN_x8r8g8b8,

+    PIXMAN_r5g6b5,

+    PIXMAN_r3g3b2,

+    PIXMAN_a8,

+    PIXMAN_a8b8g8r8,

+    PIXMAN_x8b8g8r8,

+    PIXMAN_b8g8r8a8,

+    PIXMAN_b8g8r8x8,

+    PIXMAN_x14r6g6b6,

+    PIXMAN_r8g8b8,

+    PIXMAN_b8g8r8,

+    PIXMAN_r5g6b5,

+    PIXMAN_b5g6r5,

+    PIXMAN_x2r10g10b10,

+    PIXMAN_a2r10g10b10,

+    PIXMAN_x2b10g10r10,

+    PIXMAN_a2b10g10r10,

+    PIXMAN_a1r5g5b5,

+    PIXMAN_x1r5g5b5,

+    PIXMAN_a1b5g5r5,

+    PIXMAN_x1b5g5r5,

+    PIXMAN_a4r4g4b4,

+    PIXMAN_x4r4g4b4,

+    PIXMAN_a4b4g4r4,

+    PIXMAN_x4b4g4r4,

+    PIXMAN_a8,

+    PIXMAN_r3g3b2,

+    PIXMAN_b2g3r3,

+    PIXMAN_a2r2g2b2,

+    PIXMAN_a2b2g2r2,

+    PIXMAN_c8,

+    PIXMAN_g8,

+    PIXMAN_x4c4,

+    PIXMAN_x4g4,

+    PIXMAN_c4,

+    PIXMAN_g4,

+    PIXMAN_g1,

+    PIXMAN_x4a4,

+    PIXMAN_a4,

+    PIXMAN_r1g2b1,

+    PIXMAN_b1g2r1,

+    PIXMAN_a1r1g1b1,

+    PIXMAN_a1b1g1r1,

+    PIXMAN_a1,

+    -1

+};

+

+static pixman_format_code_t mask_fmt_list[] = {

+    PIXMAN_a8r8g8b8,

+    PIXMAN_a8,

+    PIXMAN_a4,

+    PIXMAN_a1,

+    -1

+};

+

+

+/*

+ * Composite operation with pseudorandom images

+ */

+uint32_t

+test_composite (int testnum, int verbose)

+{

+    int i;

+    pixman_image_t *src_img = NULL;

+    pixman_image_t *dst_img = NULL;

+    pixman_image_t *mask_img = NULL;

+    int src_width, src_height;

+    int dst_width, dst_height;

+    int src_stride, dst_stride;

+    int src_x, src_y;

+    int dst_x, dst_y;

+    int mask_x, mask_y;

+    int w, h;

+    int op;

+    pixman_format_code_t src_fmt, dst_fmt, mask_fmt;

+    uint32_t *dstbuf, *srcbuf, *maskbuf;

+    uint32_t crc32;

+    int max_width, max_height, max_extra_stride;

+

+    max_width = max_height = 24 + testnum / 10000;

+    max_extra_stride = 4 + testnum / 1000000;

+

+    if (max_width > 256)

+	max_width = 256;

+

+    if (max_height > 16)

+	max_height = 16;

+

+    if (max_extra_stride > 8)

+	max_extra_stride = 8;

+

+    lcg_srand (testnum);

+

+    op = op_list[lcg_rand_n (sizeof (op_list) / sizeof (op_list[0]))];

+

+    if (lcg_rand_n (8))

+    {

+	/* normal image */

+	src_img = create_random_image (img_fmt_list, max_width, max_height,

+				       max_extra_stride, &src_fmt);

+    }

+    else

+    {

+	/* solid case */

+	src_img = create_random_image (img_fmt_list, 1, 1,

+				       max_extra_stride, &src_fmt);

+

+	pixman_image_set_repeat (src_img, PIXMAN_REPEAT_NORMAL);

+    }

+

+    dst_img = create_random_image (img_fmt_list, max_width, max_height,

+				   max_extra_stride, &dst_fmt);

+

+    src_width = pixman_image_get_width (src_img);

+    src_height = pixman_image_get_height (src_img);

+    src_stride = pixman_image_get_stride (src_img);

+

+    dst_width = pixman_image_get_width (dst_img);

+    dst_height = pixman_image_get_height (dst_img);

+    dst_stride = pixman_image_get_stride (dst_img);

+

+    dstbuf = pixman_image_get_data (dst_img);

+    srcbuf = pixman_image_get_data (src_img);

+

+    src_x = lcg_rand_n (src_width);

+    src_y = lcg_rand_n (src_height);

+    dst_x = lcg_rand_n (dst_width);

+    dst_y = lcg_rand_n (dst_height);

+

+    mask_img = NULL;

+    mask_fmt = -1;

+    mask_x = 0;

+    mask_y = 0;

+    maskbuf = NULL;

+

+    if ((src_fmt == PIXMAN_x8r8g8b8 || src_fmt == PIXMAN_x8b8g8r8) &&

+	(lcg_rand_n (4) == 0))

+    {

+	/* PIXBUF */

+	mask_fmt = lcg_rand_n (2) ? PIXMAN_a8r8g8b8 : PIXMAN_a8b8g8r8;

+	mask_img = pixman_image_create_bits (mask_fmt,

+	                                     src_width,

+	                                     src_height,

+	                                     srcbuf,

+	                                     src_stride);

+	mask_x = src_x;

+	mask_y = src_y;

+	maskbuf = srcbuf;

+    }

+    else if (lcg_rand_n (2))

+    {

+	if (lcg_rand_n (2))

+	{

+	    mask_img = create_random_image (mask_fmt_list, max_width, max_height,

+					   max_extra_stride, &mask_fmt);

+	}

+	else

+	{

+	    /* solid case */

+	    mask_img = create_random_image (mask_fmt_list, 1, 1,

+					   max_extra_stride, &mask_fmt);

+	    pixman_image_set_repeat (mask_img, PIXMAN_REPEAT_NORMAL);

+	}

+

+	if (lcg_rand_n (2))

+	    pixman_image_set_component_alpha (mask_img, 1);

+

+	mask_x = lcg_rand_n (pixman_image_get_width (mask_img));

+	mask_y = lcg_rand_n (pixman_image_get_height (mask_img));

+    }

+

+

+    w = lcg_rand_n (dst_width - dst_x + 1);

+    h = lcg_rand_n (dst_height - dst_y + 1);

+

+    if (verbose)

+    {

+	printf ("op=%d, src_fmt=%08X, dst_fmt=%08X, mask_fmt=%08X\n",

+	    op, src_fmt, dst_fmt, mask_fmt);

+	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 ("src_stride=%d, dst_stride=%d\n",

+	    src_stride, dst_stride);

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

+    }

+

+    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 (verbose)

+    {

+	int j;

+

+	printf ("---\n");

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

+	{

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

+	    {

+		if (j == (dst_width * PIXMAN_FORMAT_BPP (dst_fmt) + 7) / 8)

+		    printf ("| ");

+

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

+	    }

+	    printf ("\n");

+	}

+	printf ("---\n");

+    }

+

+    free_random_image (0, src_img, -1);

+    crc32 = free_random_image (0, dst_img, dst_fmt);

+

+    if (mask_img)

+    {

+	if (srcbuf == maskbuf)

+	    pixman_image_unref(mask_img);

+	else

+	    free_random_image (0, mask_img, -1);

+    }

+

+

+    return crc32;

+}

+

+#define CONVERT_15(c, is_rgb)						\

+    (is_rgb?								\

+     ((((c) >> 3) & 0x001f) |						\

+      (((c) >> 6) & 0x03e0) |						\

+      (((c) >> 9) & 0x7c00)) :						\

+     (((((c) >> 16) & 0xff) * 153 +					\

+       (((c) >>  8) & 0xff) * 301 +					\

+       (((c)      ) & 0xff) * 58) >> 2))

+

+static void

+initialize_palette (pixman_indexed_t *palette, uint32_t mask, int is_rgb)

+{

+    int i;

+

+    for (i = 0; i < 32768; ++i)

+	palette->ent[i] = lcg_rand() & mask;

+

+    for (i = 0; i < mask + 1; ++i)

+    {

+	uint32_t rgba24;

+ 	pixman_bool_t retry;

+	uint32_t i15;

+

+	/* We filled the rgb->index map with random numbers, but we

+	 * do need the ability to round trip, that is if some indexed

+	 * color expands to an argb24, then the 15 bit version of that

+	 * color must map back to the index. Anything else, we don't

+	 * care about too much.

+	 */

+	do

+	{

+	    uint32_t old_idx;

+	    

+	    rgba24 = lcg_rand();

+	    i15 = CONVERT_15 (rgba24, is_rgb);

+

+	    old_idx = palette->ent[i15];

+	    if (CONVERT_15 (palette->rgba[old_idx], is_rgb) == i15)

+		retry = 1;

+	    else

+		retry = 0;

+	} while (retry);

+	

+	palette->rgba[i] = rgba24;

+	palette->ent[i15] = i;

+    }

+

+    for (i = 0; i < mask + 1; ++i)

+    {

+	assert (palette->ent[CONVERT_15 (palette->rgba[i], is_rgb)] == i);

+    }

+}

+

+int

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

+{

+    int i;

+

+    for (i = 1; i <= 8; i++)

+    {

+	initialize_palette (&(rgb_palette[i]), (1 << i) - 1, TRUE);

+	initialize_palette (&(y_palette[i]), (1 << i) - 1, FALSE);

+    }

+

+    return fuzzer_test_main("blitters", 2000000,

+			    0x217CF14A,

+			    test_composite, argc, argv);

+}