2 * Test program, which stresses the use of different color formats and
3 * compositing operations.
5 * Script 'fuzzer-find-diff.pl' can be used to narrow down the problem in
6 * the case of test failure.
14 static pixman_indexed_t rgb_palette[9];
15 static pixman_indexed_t y_palette[9];
17 /* Create random image for testing purposes */
18 static pixman_image_t *
19 create_random_image (pixman_format_code_t *allowed_formats,
23 pixman_format_code_t *used_fmt)
25 int n = 0, i, width, height, stride;
26 pixman_format_code_t fmt;
30 while (allowed_formats[n] != -1)
32 fmt = allowed_formats[lcg_rand_n (n)];
34 width = lcg_rand_n (max_width) + 1;
35 height = lcg_rand_n (max_height) + 1;
36 stride = (width * PIXMAN_FORMAT_BPP (fmt) + 7) / 8 +
37 lcg_rand_n (max_extra_stride + 1);
38 stride = (stride + 3) & ~3;
40 /* do the allocation */
41 buf = aligned_malloc (64, stride * height);
43 /* initialize image with random data */
44 for (i = 0; i < stride * height; i++)
46 /* generation is biased to having more 0 or 255 bytes as
47 * they are more likely to be special-cased in code
49 *((uint8_t *)buf + i) = lcg_rand_n (4) ? lcg_rand_n (256) :
50 (lcg_rand_n (2) ? 0 : 255);
53 img = pixman_image_create_bits (fmt, width, height, buf, stride);
55 if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_COLOR)
57 pixman_image_set_indexed (img, &(rgb_palette[PIXMAN_FORMAT_BPP (fmt)]));
59 else if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_GRAY)
61 pixman_image_set_indexed (img, &(y_palette[PIXMAN_FORMAT_BPP (fmt)]));
64 image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));
66 if (used_fmt) *used_fmt = fmt;
70 /* Free random image, and optionally update crc32 based on its data */
72 free_random_image (uint32_t initcrc,
74 pixman_format_code_t fmt)
77 int stride = pixman_image_get_stride (img);
78 uint32_t *data = pixman_image_get_data (img);
79 int height = pixman_image_get_height (img);
83 /* mask unused 'x' part */
84 if (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt) &&
85 PIXMAN_FORMAT_DEPTH (fmt) != 0)
88 uint32_t *data = pixman_image_get_data (img);
89 uint32_t mask = (1 << PIXMAN_FORMAT_DEPTH (fmt)) - 1;
91 if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_BGRA)
92 mask <<= (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt));
94 for (i = 0; i < 32; i++)
95 mask |= mask << (i * PIXMAN_FORMAT_BPP (fmt));
97 for (i = 0; i < stride * height / 4; i++)
101 /* swap endiannes in order to provide identical results on both big
102 * and litte endian systems
104 image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));
105 crc32 = compute_crc32 (initcrc, data, stride * height);
108 pixman_image_unref (img);
114 static pixman_op_t op_list[] = {
122 PIXMAN_OP_OVER_REVERSE,
124 PIXMAN_OP_IN_REVERSE,
126 PIXMAN_OP_OUT_REVERSE,
128 PIXMAN_OP_ATOP_REVERSE,
132 PIXMAN_OP_DISJOINT_CLEAR,
133 PIXMAN_OP_DISJOINT_SRC,
134 PIXMAN_OP_DISJOINT_DST,
135 PIXMAN_OP_DISJOINT_OVER,
136 PIXMAN_OP_DISJOINT_OVER_REVERSE,
137 PIXMAN_OP_DISJOINT_IN,
138 PIXMAN_OP_DISJOINT_IN_REVERSE,
139 PIXMAN_OP_DISJOINT_OUT,
140 PIXMAN_OP_DISJOINT_OUT_REVERSE,
141 PIXMAN_OP_DISJOINT_ATOP,
142 PIXMAN_OP_DISJOINT_ATOP_REVERSE,
143 PIXMAN_OP_DISJOINT_XOR,
144 PIXMAN_OP_CONJOINT_CLEAR,
145 PIXMAN_OP_CONJOINT_SRC,
146 PIXMAN_OP_CONJOINT_DST,
147 PIXMAN_OP_CONJOINT_OVER,
148 PIXMAN_OP_CONJOINT_OVER_REVERSE,
149 PIXMAN_OP_CONJOINT_IN,
150 PIXMAN_OP_CONJOINT_IN_REVERSE,
151 PIXMAN_OP_CONJOINT_OUT,
152 PIXMAN_OP_CONJOINT_OUT_REVERSE,
153 PIXMAN_OP_CONJOINT_ATOP,
154 PIXMAN_OP_CONJOINT_ATOP_REVERSE,
155 PIXMAN_OP_CONJOINT_XOR,
161 PIXMAN_OP_COLOR_DODGE,
162 PIXMAN_OP_COLOR_BURN,
163 PIXMAN_OP_HARD_LIGHT,
164 PIXMAN_OP_DIFFERENCE,
166 #if 0 /* these use floating point math and are not always bitexact on different platforms */
167 PIXMAN_OP_SOFT_LIGHT,
169 PIXMAN_OP_HSL_SATURATION,
171 PIXMAN_OP_HSL_LUMINOSITY,
175 static pixman_format_code_t img_fmt_list[] = {
224 static pixman_format_code_t mask_fmt_list[] = {
234 * Composite operation with pseudorandom images
237 test_composite (int testnum, int verbose)
240 pixman_image_t *src_img = NULL;
241 pixman_image_t *dst_img = NULL;
242 pixman_image_t *mask_img = NULL;
243 int src_width, src_height;
244 int dst_width, dst_height;
245 int src_stride, dst_stride;
251 pixman_format_code_t src_fmt, dst_fmt, mask_fmt;
252 uint32_t *dstbuf, *srcbuf, *maskbuf;
254 int max_width, max_height, max_extra_stride;
255 FLOAT_REGS_CORRUPTION_DETECTOR_START ();
257 max_width = max_height = 24 + testnum / 10000;
258 max_extra_stride = 4 + testnum / 1000000;
266 if (max_extra_stride > 8)
267 max_extra_stride = 8;
271 op = op_list[lcg_rand_n (sizeof (op_list) / sizeof (op_list[0]))];
276 src_img = create_random_image (img_fmt_list, max_width, max_height,
277 max_extra_stride, &src_fmt);
282 src_img = create_random_image (img_fmt_list, 1, 1,
283 max_extra_stride, &src_fmt);
285 pixman_image_set_repeat (src_img, PIXMAN_REPEAT_NORMAL);
288 dst_img = create_random_image (img_fmt_list, max_width, max_height,
289 max_extra_stride, &dst_fmt);
291 src_width = pixman_image_get_width (src_img);
292 src_height = pixman_image_get_height (src_img);
293 src_stride = pixman_image_get_stride (src_img);
295 dst_width = pixman_image_get_width (dst_img);
296 dst_height = pixman_image_get_height (dst_img);
297 dst_stride = pixman_image_get_stride (dst_img);
299 dstbuf = pixman_image_get_data (dst_img);
300 srcbuf = pixman_image_get_data (src_img);
302 src_x = lcg_rand_n (src_width);
303 src_y = lcg_rand_n (src_height);
304 dst_x = lcg_rand_n (dst_width);
305 dst_y = lcg_rand_n (dst_height);
313 if ((src_fmt == PIXMAN_x8r8g8b8 || src_fmt == PIXMAN_x8b8g8r8) &&
314 (lcg_rand_n (4) == 0))
317 mask_fmt = lcg_rand_n (2) ? PIXMAN_a8r8g8b8 : PIXMAN_a8b8g8r8;
318 mask_img = pixman_image_create_bits (mask_fmt,
327 else if (lcg_rand_n (2))
331 mask_img = create_random_image (mask_fmt_list, max_width, max_height,
332 max_extra_stride, &mask_fmt);
337 mask_img = create_random_image (mask_fmt_list, 1, 1,
338 max_extra_stride, &mask_fmt);
339 pixman_image_set_repeat (mask_img, PIXMAN_REPEAT_NORMAL);
343 pixman_image_set_component_alpha (mask_img, 1);
345 mask_x = lcg_rand_n (pixman_image_get_width (mask_img));
346 mask_y = lcg_rand_n (pixman_image_get_height (mask_img));
350 w = lcg_rand_n (dst_width - dst_x + 1);
351 h = lcg_rand_n (dst_height - dst_y + 1);
355 printf ("op=%d, src_fmt=%08X, dst_fmt=%08X, mask_fmt=%08X\n",
356 op, src_fmt, dst_fmt, mask_fmt);
357 printf ("src_width=%d, src_height=%d, dst_width=%d, dst_height=%d\n",
358 src_width, src_height, dst_width, dst_height);
359 printf ("src_x=%d, src_y=%d, dst_x=%d, dst_y=%d\n",
360 src_x, src_y, dst_x, dst_y);
361 printf ("src_stride=%d, dst_stride=%d\n",
362 src_stride, dst_stride);
363 printf ("w=%d, h=%d\n", w, h);
366 pixman_image_composite (op, src_img, mask_img, dst_img,
367 src_x, src_y, mask_x, mask_y, dst_x, dst_y, w, h);
374 for (i = 0; i < dst_height; i++)
376 for (j = 0; j < dst_stride; j++)
378 if (j == (dst_width * PIXMAN_FORMAT_BPP (dst_fmt) + 7) / 8)
381 printf ("%02X ", *((uint8_t *)dstbuf + i * dst_stride + j));
388 free_random_image (0, src_img, -1);
389 crc32 = free_random_image (0, dst_img, dst_fmt);
393 if (srcbuf == maskbuf)
394 pixman_image_unref(mask_img);
396 free_random_image (0, mask_img, -1);
399 FLOAT_REGS_CORRUPTION_DETECTOR_FINISH ();
403 #define CONVERT_15(c, is_rgb) \
405 ((((c) >> 3) & 0x001f) | \
406 (((c) >> 6) & 0x03e0) | \
407 (((c) >> 9) & 0x7c00)) : \
408 (((((c) >> 16) & 0xff) * 153 + \
409 (((c) >> 8) & 0xff) * 301 + \
410 (((c) ) & 0xff) * 58) >> 2))
413 initialize_palette (pixman_indexed_t *palette, uint32_t mask, int is_rgb)
417 for (i = 0; i < 32768; ++i)
418 palette->ent[i] = lcg_rand() & mask;
420 for (i = 0; i < mask + 1; ++i)
426 /* We filled the rgb->index map with random numbers, but we
427 * do need the ability to round trip, that is if some indexed
428 * color expands to an argb24, then the 15 bit version of that
429 * color must map back to the index. Anything else, we don't
430 * care about too much.
437 i15 = CONVERT_15 (rgba24, is_rgb);
439 old_idx = palette->ent[i15];
440 if (CONVERT_15 (palette->rgba[old_idx], is_rgb) == i15)
446 palette->rgba[i] = rgba24;
447 palette->ent[i15] = i;
450 for (i = 0; i < mask + 1; ++i)
452 assert (palette->ent[CONVERT_15 (palette->rgba[i], is_rgb)] == i);
457 main (int argc, const char *argv[])
461 for (i = 1; i <= 8; i++)
463 initialize_palette (&(rgb_palette[i]), (1 << i) - 1, TRUE);
464 initialize_palette (&(y_palette[i]), (1 << i) - 1, FALSE);
467 return fuzzer_test_main("blitters", 2000000,
469 test_composite, argc, argv);