test/glyph-test.c - third_party/pixman - Git at Google

 #include <stdlib.h>
 #include "utils.h"

 static const pixman_format_code_t glyph_formats[] =
 {
     PIXMAN_a8r8g8b8,
     PIXMAN_a8,
     PIXMAN_a4,
     PIXMAN_a1,
     PIXMAN_x8r8g8b8,
     PIXMAN_r3g3b2,
     PIXMAN_null,
 };

 static const pixman_format_code_t formats[] =
 {
     PIXMAN_a8r8g8b8,
     PIXMAN_a8b8g8r8,
     PIXMAN_x8r8g8b8,
     PIXMAN_x8b8g8r8,
     PIXMAN_r5g6b5,
     PIXMAN_b5g6r5,
     PIXMAN_a8,
     PIXMAN_a1,
     PIXMAN_r3g3b2,
     PIXMAN_b8g8r8a8,
     PIXMAN_b8g8r8x8,
     PIXMAN_r8g8b8a8,
     PIXMAN_r8g8b8x8,
     PIXMAN_x14r6g6b6,
     PIXMAN_r8g8b8,
     PIXMAN_b8g8r8,
 #if 0
     /* These use floating point */
     PIXMAN_x2r10g10b10,
     PIXMAN_a2r10g10b10,
     PIXMAN_x2b10g10r10,
     PIXMAN_a2b10g10r10,
 #endif
     PIXMAN_a1r5g5b5,
     PIXMAN_x1r5g5b5,
     PIXMAN_a1b5g5r5,
     PIXMAN_x1b5g5r5,
     PIXMAN_a4r4g4b4,
     PIXMAN_x4r4g4b4,
     PIXMAN_a4b4g4r4,
     PIXMAN_x4b4g4r4,
     PIXMAN_r3g3b2,
     PIXMAN_b2g3r3,
     PIXMAN_a2r2g2b2,
     PIXMAN_a2b2g2r2,
     PIXMAN_x4a4,
     PIXMAN_a4,
     PIXMAN_r1g2b1,
     PIXMAN_b1g2r1,
     PIXMAN_a1r1g1b1,
     PIXMAN_a1b1g1r1,
     PIXMAN_null,
 };

 static const pixman_op_t operators[] =
 {
     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
 };

 enum
 {
     ALLOW_CLIPPED		= (1 << 0),
     ALLOW_ALPHA_MAP		= (1 << 1),
     ALLOW_SOURCE_CLIPPING	= (1 << 2),
     ALLOW_REPEAT		= (1 << 3),
     ALLOW_SOLID			= (1 << 4),
     ALLOW_FENCED_MEMORY		= (1 << 5),
 };

 static void
 destroy_fenced (pixman_image_t *image, void *data)
 {
     fence_free (data);
 }

 static void
 destroy_malloced (pixman_image_t *image, void *data)
 {
     free (data);
 }

 static pixman_format_code_t
 random_format (const pixman_format_code_t *formats)
 {
     int i;
     i = 0;
     while (formats[i] != PIXMAN_null)
 	++i;
     return formats[prng_rand_n (i)];
 }

 static pixman_image_t *
 create_image (int max_size, const pixman_format_code_t *formats, uint32_t flags)
 {
     int width, height;
     pixman_image_t *image;
     pixman_format_code_t format;
     uint32_t *data;
     int bpp;
     int stride;
     int i;
     pixman_image_destroy_func_t destroy;

     if ((flags & ALLOW_SOLID) && prng_rand_n (4) == 0)
     {
 	pixman_color_t color;

 	color.alpha = prng_rand();
 	color.red = prng_rand();
 	color.green = prng_rand();
 	color.blue = prng_rand();

 	return pixman_image_create_solid_fill (&color);
     }

     width = prng_rand_n (max_size) + 1;
     height = prng_rand_n (max_size) + 1;
     format = random_format (formats);

     bpp = PIXMAN_FORMAT_BPP (format);
     stride = (width * bpp + 7) / 8 + prng_rand_n (17);
     stride = (stride + 3) & ~3;

     if (prng_rand_n (64) == 0)
     {
 	if (!(data = (uint32_t *)make_random_bytes (stride * height)))
 	{
 	    fprintf (stderr, "Out of memory\n");
 	    abort ();
 	}
 	destroy = destroy_fenced;
     }
     else
     {
 	data = malloc (stride * height);
 	prng_randmemset (data, height * stride, 0);
 	destroy = destroy_malloced;
     }

     image = pixman_image_create_bits (format, width, height, data, stride);
     pixman_image_set_destroy_function (image, destroy, data);

     if ((flags & ALLOW_CLIPPED) && prng_rand_n (8) == 0)
     {
 	pixman_box16_t clip_boxes[8];
 	pixman_region16_t clip;
 	int n = prng_rand_n (8) + 1;

 	for (i = 0; i < n; i++)
 	{
 	    clip_boxes[i].x1 = prng_rand_n (width);
 	    clip_boxes[i].y1 = prng_rand_n (height);
 	    clip_boxes[i].x2 =
 		clip_boxes[i].x1 + prng_rand_n (width - clip_boxes[i].x1);
 	    clip_boxes[i].y2 =
 		clip_boxes[i].y1 + prng_rand_n (height - clip_boxes[i].y1);
 	}

 	pixman_region_init_rects (&clip, clip_boxes, n);
 	pixman_image_set_clip_region (image, &clip);
 	pixman_region_fini (&clip);
     }

     if ((flags & ALLOW_SOURCE_CLIPPING) && prng_rand_n (4) == 0)
     {
 	pixman_image_set_source_clipping (image, TRUE);
 	pixman_image_set_has_client_clip (image, TRUE);
     }

     if ((flags & ALLOW_ALPHA_MAP) && prng_rand_n (16) == 0)
     {
 	pixman_image_t *alpha_map;
 	int alpha_x, alpha_y;

 	alpha_x = prng_rand_n (width);
 	alpha_y = prng_rand_n (height);
 	alpha_map =
 	    create_image (max_size, formats, (flags & ~(ALLOW_ALPHA_MAP | ALLOW_SOLID)));
 	pixman_image_set_alpha_map (image, alpha_map, alpha_x, alpha_y);
 	pixman_image_unref (alpha_map);
     }

     if ((flags & ALLOW_REPEAT) && prng_rand_n (2) == 0)
 	pixman_image_set_repeat (image, prng_rand_n (4));

     image_endian_swap (image);

     return image;
 }

 #define KEY1(p) ((void *)(((uintptr_t)p) ^ (0xa7e23dfaUL)))
 #define KEY2(p) ((void *)(((uintptr_t)p) ^ (0xabcd9876UL)))

 #define MAX_GLYPHS 32

 uint32_t
 test_glyphs (int testnum, int verbose)
 {
     pixman_image_t *glyph_images[MAX_GLYPHS];
     pixman_glyph_t glyphs[4 * MAX_GLYPHS];
     uint32_t crc32 = 0;
     pixman_image_t *source, *dest;
     int n_glyphs, i;
     pixman_glyph_cache_t *cache;

     prng_srand (testnum);

     cache = pixman_glyph_cache_create ();

     source = create_image (300, formats,
 			   ALLOW_CLIPPED | ALLOW_ALPHA_MAP |
 			   ALLOW_SOURCE_CLIPPING |
 			   ALLOW_REPEAT | ALLOW_SOLID);

     dest = create_image (128, formats,
 			 ALLOW_CLIPPED | ALLOW_ALPHA_MAP |
 			 ALLOW_SOURCE_CLIPPING);

     pixman_glyph_cache_freeze (cache);

     n_glyphs = prng_rand_n (MAX_GLYPHS);
     for (i = 0; i < n_glyphs; ++i)
 	glyph_images[i] = create_image (32, glyph_formats, 0);

     for (i = 0; i < 4 * n_glyphs; ++i)
     {
 	int g = prng_rand_n (n_glyphs);
 	pixman_image_t *glyph_img = glyph_images[g];
 	void *key1 = KEY1 (glyph_img);
 	void *key2 = KEY2 (glyph_img);
 	const void *glyph;

 	if (!(glyph = pixman_glyph_cache_lookup (cache, key1, key2)))
 	{
 	    glyph =
 		pixman_glyph_cache_insert (cache, key1, key2, 5, 8, glyph_img);
 	}

 	glyphs[i].glyph = glyph;
 	glyphs[i].x = prng_rand_n (128);
 	glyphs[i].y = prng_rand_n (128);
     }

     if (prng_rand_n (2) == 0)
     {
 	int src_x = prng_rand_n (300) - 150;
 	int src_y = prng_rand_n (300) - 150;
 	int mask_x = prng_rand_n (64) - 32;
 	int mask_y = prng_rand_n (64) - 32;
 	int dest_x = prng_rand_n (64) - 32;
 	int dest_y = prng_rand_n (64) - 32;
 	int width = prng_rand_n (64);
 	int height = prng_rand_n (64);
 	pixman_op_t op = operators[prng_rand_n (ARRAY_LENGTH (operators))];
 	pixman_format_code_t format = random_format (glyph_formats);

 	pixman_composite_glyphs (
 	    op,
 	    source, dest, format,
 	    src_x, src_y,
 	    mask_x, mask_y,
 	    dest_x, dest_y,
 	    width, height,
 	    cache, 4 * n_glyphs, glyphs);
     }
     else
     {
 	pixman_op_t op = operators[prng_rand_n (ARRAY_LENGTH (operators))];
 	int src_x = prng_rand_n (300) - 150;
 	int src_y = prng_rand_n (300) - 150;
 	int dest_x = prng_rand_n (64) - 32;
 	int dest_y = prng_rand_n (64) - 32;

 	pixman_composite_glyphs_no_mask (
 	    op, source, dest,
 	    src_x, src_y,
 	    dest_x, dest_y,
 	    cache, 4 * n_glyphs, glyphs);
     }

     pixman_glyph_cache_thaw (cache);

     for (i = 0; i < n_glyphs; ++i)
     {
 	pixman_image_t *img = glyph_images[i];
 	void *key1, *key2;

 	key1 = KEY1 (img);
 	key2 = KEY2 (img);

 	pixman_glyph_cache_remove (cache, key1, key2);
 	pixman_image_unref (glyph_images[i]);
     }

     crc32 = compute_crc32_for_image (0, dest);

     pixman_image_unref (source);
     pixman_image_unref (dest);

     pixman_glyph_cache_destroy (cache);

     return crc32;
 }

 int
 main (int argc, const char *argv[])
 {
     return fuzzer_test_main ("glyph", 30000,
 			     0xFA478A79,
 			     test_glyphs, argc, argv);
 }
	#include <stdlib.h>
	#include "utils.h"

	static const pixman_format_code_t glyph_formats[] =
	{
	PIXMAN_a8r8g8b8,
	PIXMAN_a8,
	PIXMAN_a4,
	PIXMAN_a1,
	PIXMAN_x8r8g8b8,
	PIXMAN_r3g3b2,
	PIXMAN_null,
	};

	static const pixman_format_code_t formats[] =
	{
	PIXMAN_a8r8g8b8,
	PIXMAN_a8b8g8r8,
	PIXMAN_x8r8g8b8,
	PIXMAN_x8b8g8r8,
	PIXMAN_r5g6b5,
	PIXMAN_b5g6r5,
	PIXMAN_a8,
	PIXMAN_a1,
	PIXMAN_r3g3b2,
	PIXMAN_b8g8r8a8,
	PIXMAN_b8g8r8x8,
	PIXMAN_r8g8b8a8,
	PIXMAN_r8g8b8x8,
	PIXMAN_x14r6g6b6,
	PIXMAN_r8g8b8,
	PIXMAN_b8g8r8,
	#if 0
	/* These use floating point */
	PIXMAN_x2r10g10b10,
	PIXMAN_a2r10g10b10,
	PIXMAN_x2b10g10r10,
	PIXMAN_a2b10g10r10,
	#endif
	PIXMAN_a1r5g5b5,
	PIXMAN_x1r5g5b5,
	PIXMAN_a1b5g5r5,
	PIXMAN_x1b5g5r5,
	PIXMAN_a4r4g4b4,
	PIXMAN_x4r4g4b4,
	PIXMAN_a4b4g4r4,
	PIXMAN_x4b4g4r4,
	PIXMAN_r3g3b2,
	PIXMAN_b2g3r3,
	PIXMAN_a2r2g2b2,
	PIXMAN_a2b2g2r2,
	PIXMAN_x4a4,
	PIXMAN_a4,
	PIXMAN_r1g2b1,
	PIXMAN_b1g2r1,
	PIXMAN_a1r1g1b1,
	PIXMAN_a1b1g1r1,
	PIXMAN_null,
	};

	static const pixman_op_t operators[] =
	{
	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
	};

	enum
	{
	ALLOW_CLIPPED = (1 << 0),
	ALLOW_ALPHA_MAP = (1 << 1),
	ALLOW_SOURCE_CLIPPING = (1 << 2),
	ALLOW_REPEAT = (1 << 3),
	ALLOW_SOLID = (1 << 4),
	ALLOW_FENCED_MEMORY = (1 << 5),
	};

	static void
	destroy_fenced (pixman_image_t image, void data)
	{
	fence_free (data);
	}

	static void
	destroy_malloced (pixman_image_t image, void data)
	{
	free (data);
	}

	static pixman_format_code_t
	random_format (const pixman_format_code_t *formats)
	{
	int i;
	i = 0;
	while (formats[i] != PIXMAN_null)
	++i;
	return formats[prng_rand_n (i)];
	}

	static pixman_image_t *
	create_image (int max_size, const pixman_format_code_t *formats, uint32_t flags)
	{
	int width, height;
	pixman_image_t *image;
	pixman_format_code_t format;
	uint32_t *data;
	int bpp;
	int stride;
	int i;
	pixman_image_destroy_func_t destroy;

	if ((flags & ALLOW_SOLID) && prng_rand_n (4) == 0)
	{
	pixman_color_t color;

	color.alpha = prng_rand();
	color.red = prng_rand();
	color.green = prng_rand();
	color.blue = prng_rand();

	return pixman_image_create_solid_fill (&color);
	}

	width = prng_rand_n (max_size) + 1;
	height = prng_rand_n (max_size) + 1;
	format = random_format (formats);

	bpp = PIXMAN_FORMAT_BPP (format);
	stride = (width * bpp + 7) / 8 + prng_rand_n (17);
	stride = (stride + 3) & ~3;

	if (prng_rand_n (64) == 0)
	{
	if (!(data = (uint32_t )make_random_bytes (stride height)))
	{
	fprintf (stderr, "Out of memory\n");
	abort ();
	}
	destroy = destroy_fenced;
	}
	else
	{
	data = malloc (stride * height);
	prng_randmemset (data, height * stride, 0);
	destroy = destroy_malloced;
	}

	image = pixman_image_create_bits (format, width, height, data, stride);
	pixman_image_set_destroy_function (image, destroy, data);

	if ((flags & ALLOW_CLIPPED) && prng_rand_n (8) == 0)
	{
	pixman_box16_t clip_boxes[8];
	pixman_region16_t clip;
	int n = prng_rand_n (8) + 1;

	for (i = 0; i < n; i++)
	{
	clip_boxes[i].x1 = prng_rand_n (width);
	clip_boxes[i].y1 = prng_rand_n (height);
	clip_boxes[i].x2 =
	clip_boxes[i].x1 + prng_rand_n (width - clip_boxes[i].x1);
	clip_boxes[i].y2 =
	clip_boxes[i].y1 + prng_rand_n (height - clip_boxes[i].y1);
	}

	pixman_region_init_rects (&clip, clip_boxes, n);
	pixman_image_set_clip_region (image, &clip);
	pixman_region_fini (&clip);
	}

	if ((flags & ALLOW_SOURCE_CLIPPING) && prng_rand_n (4) == 0)
	{
	pixman_image_set_source_clipping (image, TRUE);
	pixman_image_set_has_client_clip (image, TRUE);
	}

	if ((flags & ALLOW_ALPHA_MAP) && prng_rand_n (16) == 0)
	{
	pixman_image_t *alpha_map;
	int alpha_x, alpha_y;

	alpha_x = prng_rand_n (width);
	alpha_y = prng_rand_n (height);
	alpha_map =
	create_image (max_size, formats, (flags & ~(ALLOW_ALPHA_MAP \| ALLOW_SOLID)));
	pixman_image_set_alpha_map (image, alpha_map, alpha_x, alpha_y);
	pixman_image_unref (alpha_map);
	}

	if ((flags & ALLOW_REPEAT) && prng_rand_n (2) == 0)
	pixman_image_set_repeat (image, prng_rand_n (4));

	image_endian_swap (image);

	return image;
	}

	#define KEY1(p) ((void *)(((uintptr_t)p) ^ (0xa7e23dfaUL)))
	#define KEY2(p) ((void *)(((uintptr_t)p) ^ (0xabcd9876UL)))

	#define MAX_GLYPHS 32

	uint32_t
	test_glyphs (int testnum, int verbose)
	{
	pixman_image_t *glyph_images[MAX_GLYPHS];
	pixman_glyph_t glyphs[4 * MAX_GLYPHS];
	uint32_t crc32 = 0;
	pixman_image_t source, dest;
	int n_glyphs, i;
	pixman_glyph_cache_t *cache;

	prng_srand (testnum);

	cache = pixman_glyph_cache_create ();

	source = create_image (300, formats,
	ALLOW_CLIPPED \| ALLOW_ALPHA_MAP \|
	ALLOW_SOURCE_CLIPPING \|
	ALLOW_REPEAT \| ALLOW_SOLID);

	dest = create_image (128, formats,
	ALLOW_CLIPPED \| ALLOW_ALPHA_MAP \|
	ALLOW_SOURCE_CLIPPING);

	pixman_glyph_cache_freeze (cache);

	n_glyphs = prng_rand_n (MAX_GLYPHS);
	for (i = 0; i < n_glyphs; ++i)
	glyph_images[i] = create_image (32, glyph_formats, 0);

	for (i = 0; i < 4 * n_glyphs; ++i)
	{
	int g = prng_rand_n (n_glyphs);
	pixman_image_t *glyph_img = glyph_images[g];
	void *key1 = KEY1 (glyph_img);
	void *key2 = KEY2 (glyph_img);
	const void *glyph;

	if (!(glyph = pixman_glyph_cache_lookup (cache, key1, key2)))
	{
	glyph =
	pixman_glyph_cache_insert (cache, key1, key2, 5, 8, glyph_img);
	}

	glyphs[i].glyph = glyph;
	glyphs[i].x = prng_rand_n (128);
	glyphs[i].y = prng_rand_n (128);
	}

	if (prng_rand_n (2) == 0)
	{
	int src_x = prng_rand_n (300) - 150;
	int src_y = prng_rand_n (300) - 150;
	int mask_x = prng_rand_n (64) - 32;
	int mask_y = prng_rand_n (64) - 32;
	int dest_x = prng_rand_n (64) - 32;
	int dest_y = prng_rand_n (64) - 32;
	int width = prng_rand_n (64);
	int height = prng_rand_n (64);
	pixman_op_t op = operators[prng_rand_n (ARRAY_LENGTH (operators))];
	pixman_format_code_t format = random_format (glyph_formats);

	pixman_composite_glyphs (
	op,
	source, dest, format,
	src_x, src_y,
	mask_x, mask_y,
	dest_x, dest_y,
	width, height,
	cache, 4 * n_glyphs, glyphs);
	}
	else
	{
	pixman_op_t op = operators[prng_rand_n (ARRAY_LENGTH (operators))];
	int src_x = prng_rand_n (300) - 150;
	int src_y = prng_rand_n (300) - 150;
	int dest_x = prng_rand_n (64) - 32;
	int dest_y = prng_rand_n (64) - 32;

	pixman_composite_glyphs_no_mask (
	op, source, dest,
	src_x, src_y,
	dest_x, dest_y,
	cache, 4 * n_glyphs, glyphs);
	}

	pixman_glyph_cache_thaw (cache);

	for (i = 0; i < n_glyphs; ++i)
	{
	pixman_image_t *img = glyph_images[i];
	void key1, key2;

	key1 = KEY1 (img);
	key2 = KEY2 (img);

	pixman_glyph_cache_remove (cache, key1, key2);
	pixman_image_unref (glyph_images[i]);
	}

	crc32 = compute_crc32_for_image (0, dest);

	pixman_image_unref (source);
	pixman_image_unref (dest);

	pixman_glyph_cache_destroy (cache);

	return crc32;
	}

	int
	main (int argc, const char *argv[])
	{
	return fuzzer_test_main ("glyph", 30000,
	0xFA478A79,
	test_glyphs, argc, argv);
	}