471 lines
12 KiB
C
471 lines
12 KiB
C
/*
|
|
* 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];
|
|
|
|
/* 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;
|
|
FLOAT_REGS_CORRUPTION_DETECTOR_START ();
|
|
|
|
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);
|
|
}
|
|
|
|
FLOAT_REGS_CORRUPTION_DETECTOR_FINISH ();
|
|
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,
|
|
0x1DB8BDF8,
|
|
test_composite, argc, argv);
|
|
}
|