libXext libXdmcp pixman git update 29/12/2010

1 files changed, 855 insertions, 0 deletions

diff --git a/pixman/test/stress-test.c b/pixman/test/stress-test.c
new file mode 100644
index 000000000..0a89a52e9
--- /dev/null
+++ b/pixman/test/stress-test.c
@@ -0,0 +1,855 @@
+#include "utils.h"

+

+#if 0

+#define fence_malloc malloc

+#define fence_free free

+#define make_random_bytes malloc

+#endif

+

+static const pixman_format_code_t image_formats[] =

+{

+    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

+};

+

+static pixman_filter_t filters[] =

+{

+    PIXMAN_FILTER_NEAREST,

+    PIXMAN_FILTER_BILINEAR,

+    PIXMAN_FILTER_FAST,

+    PIXMAN_FILTER_GOOD,

+    PIXMAN_FILTER_BEST,

+    PIXMAN_FILTER_CONVOLUTION

+};

+

+static int

+get_size (void)

+{

+    switch (lcg_rand_n (28))

+    {

+    case 0:

+	return 1;

+

+    case 1:

+	return 2;

+

+    default:

+    case 2:

+	return lcg_rand_n (200);

+

+    case 4:

+	return lcg_rand_n (2000) + 1000;

+

+    case 5:

+	return 65535;

+

+    case 6:

+	return 65536;

+

+    case 7:

+	return lcg_rand_N (64000) + 63000;

+    }

+}

+

+static void

+destroy (pixman_image_t *image, void *data)

+{

+    if (image->type == BITS && image->bits.free_me != image->bits.bits)

+    {

+	uint32_t *bits;

+

+	if (image->bits.bits != (void *)0x01)

+	{

+	    bits = image->bits.bits;

+

+	    if (image->bits.rowstride < 0)

+		bits -= (- image->bits.rowstride * (image->bits.height - 1));

+

+	    fence_free (bits);

+	}

+    }

+

+    free (data);

+}

+

+static uint32_t

+real_reader (const void *src, int size)

+{

+    switch (size)

+    {

+    case 1:

+	return *(uint8_t *)src;

+    case 2:

+	return *(uint16_t *)src;

+    case 4:

+	return *(uint32_t *)src;

+    default:

+	assert (0);

+	break;

+    }

+}

+

+static void

+real_writer (void *src, uint32_t value, int size)

+{

+    switch (size)

+    {

+    case 1:

+	*(uint8_t *)src = value;

+	break;

+

+    case 2:

+	*(uint16_t *)src = value;

+	break;

+

+    case 4:

+	*(uint32_t *)src = value;

+	break;

+

+    default:

+	assert (0);

+	break;

+    }

+}

+

+static uint32_t

+fake_reader (const void *src, int size)

+{

+    uint32_t r = lcg_rand_u32 ();

+

+    assert (size == 1 || size == 2 || size == 4);

+    return r & ((1 << (size * 8)) - 1);

+}

+

+static void

+fake_writer (void *src, uint32_t value, int size)

+{

+    assert (size == 1 || size == 2 || size == 4);

+}

+

+static int32_t

+log_rand (void)

+{

+    uint32_t mask;

+

+    mask = (1 << lcg_rand_n (31)) - 1;

+

+    return (lcg_rand () & mask) - (mask >> 1);

+}

+

+static pixman_image_t *

+create_random_bits_image (void)

+{

+    pixman_format_code_t format;

+    pixman_indexed_t *indexed;

+    pixman_image_t *image;

+    int width, height, stride;

+    uint32_t *bits;

+    pixman_read_memory_func_t read_func = NULL;

+    pixman_write_memory_func_t write_func = NULL;

+    pixman_filter_t filter;

+    pixman_fixed_t *coefficients = NULL;

+    int n_coefficients = 0;

+

+    /* format */

+    format = image_formats[lcg_rand_n (ARRAY_LENGTH (image_formats))];

+

+    indexed = NULL;

+    if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_COLOR)

+    {

+	indexed = malloc (sizeof (pixman_indexed_t));

+

+	initialize_palette (indexed, PIXMAN_FORMAT_BPP (format), TRUE);

+    }

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

+    {

+	indexed = malloc (sizeof (pixman_indexed_t));

+

+	initialize_palette (indexed, PIXMAN_FORMAT_BPP (format), FALSE);

+    }

+    else

+    {

+	indexed = NULL;

+    }

+

+    /* size */

+    width = get_size ();

+    height = get_size ();

+

+    if ((uint64_t)width * height > 200000)

+    {

+	if (lcg_rand_n(2) == 0)

+	    height = 200000 / width;

+	else

+	    width = 200000 / height;

+    }

+

+    if (height == 0)

+	height = 1;

+    if (width == 0)

+	width = 1;

+

+    /* bits */

+    switch (lcg_rand_n (7))

+    {

+    default:

+    case 0:

+	stride = width * PIXMAN_FORMAT_BPP (format) + lcg_rand_n (17);

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

+	bits = (uint32_t *)make_random_bytes (height * stride);

+	break;

+

+    case 1:

+	stride = 0;

+	bits = NULL;

+	break;

+

+    case 2: /* Zero-filled */

+	stride = width * PIXMAN_FORMAT_BPP (format) + lcg_rand_n (17);

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

+	bits = fence_malloc (height * stride);

+	if (!bits)

+	    return NULL;

+	memset (bits, 0, height * stride);

+	break;

+

+    case 3: /* Filled with 0xFF */

+	stride = width * PIXMAN_FORMAT_BPP (format) + lcg_rand_n (17);

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

+	bits = fence_malloc (height * stride);

+	if (!bits)

+	    return NULL;

+	memset (bits, 0xff, height * stride);

+	break;

+

+    case 4: /* bits is a bad pointer, has read/write functions */

+	stride = 232;

+	bits = (void *)0x01;

+	read_func = fake_reader;

+	write_func = fake_writer;

+	break;

+

+    case 5: /* bits is a real pointer, has read/write functions */

+	stride = width * PIXMAN_FORMAT_BPP (format) + lcg_rand_n (17);

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

+	bits = fence_malloc (height * stride);

+	if (!bits)

+	    return NULL;

+	memset (bits, 0xff, height * stride);

+	read_func = real_reader;

+	write_func = real_writer;

+	break;

+

+    case 6: /* bits is a real pointer, stride is negative */

+	stride = (width * PIXMAN_FORMAT_BPP (format) + lcg_rand_n (17));

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

+	bits = (uint32_t *)make_random_bytes (height * stride);

+	if (!bits)

+	    return NULL;

+	bits += ((height - 1) * stride) / 4;

+	stride = - stride;

+	break;

+    }

+

+    /* Filter */

+    filter = filters[lcg_rand_n (ARRAY_LENGTH (filters))];

+    if (filter == PIXMAN_FILTER_CONVOLUTION)

+    {

+	int width = lcg_rand_n (17);

+	int height = lcg_rand_n (19);

+

+	n_coefficients = width * height + 2;

+	coefficients = malloc (n_coefficients * sizeof (pixman_fixed_t));

+

+	if (coefficients)

+	{

+	    int i;

+

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

+		coefficients[i + 2] = lcg_rand_u32();

+

+	    coefficients[0] = width << 16;

+	    coefficients[1] = height << 16;

+	}

+	else

+	{

+	    filter = PIXMAN_FILTER_BEST;

+	}

+    }

+

+    /* Finally create the image */

+    image = pixman_image_create_bits (format, width, height, bits, stride);

+    if (!image)

+	return NULL;

+

+    pixman_image_set_indexed (image, indexed);

+    pixman_image_set_destroy_function (image, destroy, indexed);

+    pixman_image_set_accessors (image, read_func, write_func);

+    pixman_image_set_filter (image, filter, coefficients, n_coefficients);

+

+    return image;

+}

+

+static pixman_repeat_t repeats[] =

+{

+    PIXMAN_REPEAT_NONE,

+    PIXMAN_REPEAT_NORMAL,

+    PIXMAN_REPEAT_REFLECT,

+    PIXMAN_REPEAT_PAD

+};

+

+static uint32_t

+absolute (int32_t i)

+{

+    return i < 0? -i : i;

+}

+

+static void

+set_general_properties (pixman_image_t *image, pixman_bool_t allow_alpha_map)

+{

+    pixman_repeat_t repeat;

+

+    /* Set properties that are generic to all images */

+

+    /* Repeat */

+    repeat = repeats[lcg_rand_n (ARRAY_LENGTH (repeats))];

+    pixman_image_set_repeat (image, repeat);

+

+    /* Alpha map */

+    if (allow_alpha_map && lcg_rand_n (3) == 0)

+    {

+	pixman_image_t *alpha_map;

+	int16_t x, y;

+

+	alpha_map = create_random_bits_image ();

+

+	if (alpha_map)

+	{

+	    set_general_properties (alpha_map, FALSE);

+

+	    x = lcg_rand_N (100000) - 65536;

+	    y = lcg_rand_N (100000) - 65536;

+

+	    pixman_image_set_alpha_map (image, alpha_map, x, y);

+

+	    pixman_image_unref (alpha_map);

+	}

+    }

+

+    /* Component alpha */

+    pixman_image_set_component_alpha (image, lcg_rand_n (3) == 0);

+

+    /* Clip region */

+    if (lcg_rand_n (8) != 0)

+    {

+	pixman_region32_t region;

+	int i, n_rects;

+

+	pixman_region32_init (&region);

+

+	switch (lcg_rand_n (10))

+	{

+	case 0:

+	    n_rects = 0;

+	    break;

+

+	case 1: case 2: case 3:

+	    n_rects = 1;

+	    break;

+

+	case 4: case 5:

+	    n_rects = 2;

+	    break;

+

+	case 6: case 7:

+	    n_rects = 3;

+

+	default:

+	    n_rects = lcg_rand_n (100);

+	    break;

+	}

+

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

+	{

+	    uint32_t width, height;

+	    int x, y;

+

+	    x = log_rand();

+	    y = log_rand();

+	    width = absolute (log_rand ()) + 1;

+	    height = absolute (log_rand ()) + 1;

+

+	    pixman_region32_union_rect (

+		&region, &region, x, y, width, height);

+	}

+

+	pixman_image_set_clip_region32 (image, &region);

+

+	pixman_region32_fini (&region);

+    }

+

+    /* Whether source clipping is enabled */

+    pixman_image_set_source_clipping (image, !!lcg_rand_n (2));

+

+    /* Client clip */

+    pixman_image_set_has_client_clip (image, !!lcg_rand_n (2));

+

+    /* Transform */

+    if (lcg_rand_n (5) < 2)

+    {

+	pixman_transform_t xform;

+	int i, j, k;

+	uint32_t tx, ty, sx, sy;

+	uint32_t c, s;

+

+	memset (&xform, 0, sizeof xform);

+	xform.matrix[0][0] = pixman_fixed_1;

+	xform.matrix[1][1] = pixman_fixed_1;

+	xform.matrix[2][2] = pixman_fixed_1;

+

+	for (k = 0; k < 3; ++k)

+	{

+	    switch (lcg_rand_n (4))

+	    {

+	    case 0:

+		/* rotation */

+		c = lcg_rand_N (2 * 65536) - 65536;

+		s = lcg_rand_N (2 * 65536) - 65536;

+		pixman_transform_rotate (&xform, NULL, c, s);

+		break;

+

+	    case 1:

+		/* translation */

+		tx = lcg_rand_u32();

+		ty = lcg_rand_u32();

+		pixman_transform_translate (&xform, NULL, tx, ty);

+		break;

+

+	    case 2:

+		/* scale */

+		sx = lcg_rand_u32();

+		sy = lcg_rand_u32();

+		pixman_transform_scale (&xform, NULL, sx, sy);

+		break;

+

+	    case 3:

+		if (lcg_rand_n (16) == 0)

+		{

+		    /* random */

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

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

+			    xform.matrix[i][j] = lcg_rand_u32();

+		    break;

+		}

+		else if (lcg_rand_n (16) == 0)

+		{

+		    /* zero */

+		    memset (&xform, 0, sizeof xform);

+		}

+		break;

+	    }

+	}

+

+	pixman_image_set_transform (image, &xform);

+    }

+}

+

+static pixman_color_t

+random_color (void)

+{

+    pixman_color_t color =

+    {

+	lcg_rand() & 0xffff,

+	lcg_rand() & 0xffff,

+	lcg_rand() & 0xffff,

+	lcg_rand() & 0xffff,

+    };

+

+    return color;

+}

+

+

+static pixman_image_t *

+create_random_solid_image (void)

+{

+    pixman_color_t color = random_color();

+    pixman_image_t *image = pixman_image_create_solid_fill (&color);

+

+    return image;

+}

+

+static pixman_gradient_stop_t *

+create_random_stops (int *n_stops)

+{

+    pixman_fixed_t step;

+    pixman_fixed_t s;

+    int i;

+    pixman_gradient_stop_t *stops;

+

+    *n_stops = lcg_rand_n (50) + 1;

+

+    step = pixman_fixed_1 / *n_stops;

+

+    stops = malloc (*n_stops * sizeof (pixman_gradient_stop_t));

+

+    s = 0;

+    for (i = 0; i < (*n_stops) - 1; ++i)

+    {

+	stops[i].x = s;

+	stops[i].color = random_color();

+

+	s += step;

+    }

+

+    stops[*n_stops - 1].x = pixman_fixed_1;

+    stops[*n_stops - 1].color = random_color();

+

+    return stops;

+}

+

+static pixman_point_fixed_t

+create_random_point (void)

+{

+    pixman_point_fixed_t p;

+

+    p.x = log_rand ();

+    p.y = log_rand ();

+

+    return p;

+}

+

+static pixman_image_t *

+create_random_linear_image (void)

+{

+    int n_stops;

+    pixman_gradient_stop_t *stops;

+    pixman_point_fixed_t p1, p2;

+    pixman_image_t *result;

+

+    stops = create_random_stops (&n_stops);

+    if (!stops)

+	return NULL;

+

+    p1 = create_random_point ();

+    p2 = create_random_point ();

+

+    result = pixman_image_create_linear_gradient (&p1, &p2, stops, n_stops);

+

+    free (stops);

+

+    return result;

+}

+

+static pixman_image_t *

+create_random_radial_image (void)

+{

+    int n_stops;

+    pixman_gradient_stop_t *stops;

+    pixman_point_fixed_t inner_c, outer_c;

+    pixman_fixed_t inner_r, outer_r;

+    pixman_image_t *result;

+

+    inner_c = create_random_point();

+    outer_c = create_random_point();

+    inner_r = lcg_rand();

+    outer_r = lcg_rand();

+

+    stops = create_random_stops (&n_stops);

+

+    if (!stops)

+	return NULL;

+

+    result = pixman_image_create_radial_gradient (

+	&inner_c, &outer_c, inner_r, outer_r, stops, n_stops);

+

+    free (stops);

+

+    return result;

+}

+

+static pixman_image_t *

+create_random_conical_image (void)

+{

+    pixman_gradient_stop_t *stops;

+    int n_stops;

+    pixman_point_fixed_t c;

+    pixman_fixed_t angle;

+    pixman_image_t *result;

+

+    c = create_random_point();

+    angle = lcg_rand();

+

+    stops = create_random_stops (&n_stops);

+

+    if (!stops)

+	return NULL;

+

+    result = pixman_image_create_conical_gradient (&c, angle, stops, n_stops);

+

+    free (stops);

+

+    return result;

+}

+

+static pixman_image_t *

+create_random_image (void)

+{

+    pixman_image_t *result;

+

+    switch (lcg_rand_n (5))

+    {

+    default:

+    case 0:

+	result = create_random_bits_image ();

+	break;

+

+    case 1:

+	result = create_random_solid_image ();

+	break;

+

+    case 2:

+	result = create_random_linear_image ();

+	break;

+

+    case 3:

+	result = create_random_radial_image ();

+	break;

+

+    case 4:

+	result = create_random_conical_image ();

+	break;

+    }

+

+    if (result)

+	set_general_properties (result, TRUE);

+

+    return result;

+}

+

+static const 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,

+    PIXMAN_OP_SOFT_LIGHT,

+    PIXMAN_OP_HSL_HUE,

+    PIXMAN_OP_HSL_SATURATION,

+    PIXMAN_OP_HSL_COLOR,

+    PIXMAN_OP_HSL_LUMINOSITY,

+};

+

+static void

+run_test (uint32_t seed)

+{

+    pixman_image_t *source, *mask, *dest;

+    pixman_op_t op;

+

+    lcg_srand (seed);

+

+    source = create_random_image ();

+    mask   = create_random_image ();

+    dest   = create_random_bits_image ();

+

+    if (source && mask && dest)

+    {

+	set_general_properties (dest, TRUE);

+

+	op = op_list [lcg_rand_n (ARRAY_LENGTH (op_list))];

+

+	pixman_image_composite32 (op,

+				  source, mask, dest,

+				  log_rand(), log_rand(),

+				  log_rand(), log_rand(),

+				  log_rand(), log_rand(),

+				  absolute (log_rand()),

+				  absolute (log_rand()));

+    }

+    if (source)

+	pixman_image_unref (source);

+    if (mask)

+	pixman_image_unref (mask);

+    if (dest)

+	pixman_image_unref (dest);

+}

+

+static pixman_bool_t

+get_int (char *s, uint32_t *i)

+{

+    char *end;

+    int p;

+

+    p = strtol (s, &end, 0);

+

+    if (end != s && *end == 0)

+    {

+	*i = p;

+	return TRUE;

+    }

+

+    return FALSE;

+}

+

+int

+main (int argc, char **argv)

+{

+    int verbose = FALSE;

+    uint32_t seed = 1;

+    uint32_t n_tests = 0xffffffff;

+    uint32_t mod = 0;

+    uint32_t i;

+

+    pixman_disable_out_of_bounds_workaround ();

+

+    enable_fp_exceptions();

+

+    if (getenv ("VERBOSE") != NULL)

+	verbose = TRUE;

+

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

+    {

+	if (strcmp (argv[i], "-v") == 0)

+	{

+	    verbose = TRUE;

+

+	    if (i + 1 < argc)

+	    {

+		get_int (argv[i + 1], &mod);

+		i++;

+	    }

+	}

+	else if (strcmp (argv[i], "-s") == 0 && i + 1 < argc)

+	{

+	    get_int (argv[i + 1], &seed);

+	    i++;

+	}

+	else if (strcmp (argv[i], "-n") == 0 && i + 1 < argc)

+	{

+	    get_int (argv[i + 1], &n_tests);

+	    i++;

+	}

+	else

+	{

+	    if (strcmp (argv[i], "-h") != 0)

+		printf ("Unknown option '%s'\n\n", argv[i]);

+

+	    printf ("Options:\n\n"

+		    "-n <number>        Number of tests to run\n"

+		    "-s <seed> 	        Seed of first test\n"

+		    "-v                 Print out seeds\n"

+		    "-v <n>             Print out every n'th seed\n\n");

+

+	    exit (-1);

+	}

+    }

+

+    if (n_tests == 0xffffffff)

+	n_tests = 8000;

+

+    /* FIXME: seed 2005763 fails in set_lum() with divide by zero */

+#ifdef USE_OPENMP

+#   pragma omp parallel for default(none) shared(verbose, n_tests, mod, seed)

+#endif

+    for (i = seed; i < seed + n_tests; ++i)

+    {

+	if (verbose)

+	{

+	    if (mod == 0 || (i % mod) == 0)

+		printf ("Seed %d\n", i);

+	}

+

+	run_test (i);

+    }

+

+    return 0;

+}