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

 /*
  * Copyright © 2015 RISC OS Open Ltd
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
  * documentation, and that the name of the copyright holders not be used in
  * advertising or publicity pertaining to distribution of the software without
  * specific, written prior permission.  The copyright holders make no
  * representations about the suitability of this software for any purpose.  It
  * is provided "as is" without express or implied warranty.
  *
  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  * SOFTWARE.
  *
  * Author:  Ben Avison (bavison@riscosopen.org)
  *
  */

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

 #define WIDTH 32
 #define HEIGHT 32

 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_MULTIPLY,
     PIXMAN_OP_SCREEN,
     PIXMAN_OP_OVERLAY,
     PIXMAN_OP_DARKEN,
     PIXMAN_OP_LIGHTEN,
     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_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_COLOR_DODGE,
     PIXMAN_OP_COLOR_BURN,
     PIXMAN_OP_SOFT_LIGHT,
     PIXMAN_OP_HSL_HUE,
     PIXMAN_OP_HSL_SATURATION,
     PIXMAN_OP_HSL_COLOR,
     PIXMAN_OP_HSL_LUMINOSITY,
 #endif
 };

 /* The first eight format in the list are by far the most widely
  * used formats, so we test those more than the others
  */
 #define N_MOST_LIKELY_FORMATS 8

 static const pixman_format_code_t img_fmt_list[] = {
     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 are going to use floating point in the near future */
     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_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_null
 };

 static const pixman_format_code_t mask_fmt_list[] = {
     PIXMAN_a8r8g8b8,
     PIXMAN_a8,
     PIXMAN_a4,
     PIXMAN_a1,
     PIXMAN_null
 };

 static pixman_indexed_t rgb_palette[9];
 static pixman_indexed_t y_palette[9];

 static pixman_format_code_t
 random_format (const pixman_format_code_t *allowed_formats)
 {
     int n = 0;

     while (allowed_formats[n] != PIXMAN_null)
         n++;

     if (n > N_MOST_LIKELY_FORMATS && prng_rand_n (4) != 0)
         n = N_MOST_LIKELY_FORMATS;

     return allowed_formats[prng_rand_n (n)];
 }

 static pixman_image_t *
 create_multi_pixel_image (const pixman_format_code_t *allowed_formats,
                           uint32_t                   *buffer,
                           pixman_format_code_t       *used_fmt)
 {
     pixman_format_code_t fmt;
     pixman_image_t *img;
     int stride;

     fmt = random_format (allowed_formats);
     stride = (WIDTH * PIXMAN_FORMAT_BPP (fmt) + 31) / 32 * 4;
     img = pixman_image_create_bits (fmt, WIDTH, HEIGHT, buffer, 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)]));

     prng_randmemset (buffer, WIDTH * HEIGHT * 4, 0);
     image_endian_swap (img);

     if (used_fmt)
         *used_fmt = fmt;

     return img;
 }

 static pixman_image_t *
 create_solid_image (const pixman_format_code_t *allowed_formats,
                     uint32_t                   *buffer,
                     pixman_format_code_t       *used_fmt)
 {
     if (prng_rand_n (2))
     {
         /* Use a repeating 1x1 bitmap image for solid */
         pixman_format_code_t fmt;
         pixman_image_t      *img, *dummy_img;
         uint32_t             bpp, dummy_buf;

         fmt = random_format (allowed_formats);
         bpp = PIXMAN_FORMAT_BPP (fmt);
         img = pixman_image_create_bits (fmt, 1, 1, buffer, 4);
         pixman_image_set_repeat (img, PIXMAN_REPEAT_NORMAL);

         if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_COLOR)
             pixman_image_set_indexed (img, &(rgb_palette[bpp]));
         else if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_GRAY)
             pixman_image_set_indexed (img, &(y_palette[bpp]));

         /* Force the flags to be calculated for image with initial
          * bitmap contents of 0 or 2^bpp-1 by plotting from it into a
          * separate throwaway image. It is simplest to write all 0s
          * or all 1s to the first word irrespective of the colour
          * depth even though we actually only care about the first
          * pixel since the stride has to be a whole number of words.
          */
         *buffer = prng_rand_n (2) ? 0xFFFFFFFFu : 0;
         dummy_img = pixman_image_create_bits (PIXMAN_a8r8g8b8, 1, 1,
                                               &dummy_buf, 4);
         pixman_image_composite (PIXMAN_OP_SRC, img, NULL, dummy_img,
                                 0, 0, 0, 0, 0, 0, 1, 1);
         pixman_image_unref (dummy_img);

         /* Now set the bitmap contents to a random value */
         prng_randmemset (buffer, 4, 0);
         image_endian_swap (img);

         if (used_fmt)
             *used_fmt = fmt;

         return img;
     }
     else
     {
         /* Use a native solid image */
         pixman_color_t color;
         pixman_image_t *img;

         color.alpha = prng_rand_n (UINT16_MAX + 1);
         color.red   = prng_rand_n (UINT16_MAX + 1);
         color.green = prng_rand_n (UINT16_MAX + 1);
         color.blue  = prng_rand_n (UINT16_MAX + 1);
         img = pixman_image_create_solid_fill (&color);

         if (used_fmt)
             *used_fmt = PIXMAN_solid;

         return img;
     }
 }

 static uint32_t
 test_solid (int testnum, int verbose)
 {
     pixman_op_t          op;
     uint32_t             src_buf[WIDTH * HEIGHT];
     uint32_t             dst_buf[WIDTH * HEIGHT];
     uint32_t             mask_buf[WIDTH * HEIGHT];
     pixman_image_t      *src_img;
     pixman_image_t      *dst_img;
     pixman_image_t      *mask_img = NULL;
     pixman_format_code_t src_fmt, dst_fmt, mask_fmt = PIXMAN_null;
     pixman_bool_t        ca = 0;
     uint32_t             crc32;

     prng_srand (testnum);

     op = op_list[prng_rand_n (ARRAY_LENGTH (op_list))];

     dst_img = create_multi_pixel_image (img_fmt_list, dst_buf, &dst_fmt);
     switch (prng_rand_n (3))
     {
     case 0: /* Solid source, no mask */
         src_img = create_solid_image (img_fmt_list, src_buf, &src_fmt);
         break;
     case 1: /* Solid source, bitmap mask */
         src_img = create_solid_image (img_fmt_list, src_buf, &src_fmt);
         mask_img = create_multi_pixel_image (mask_fmt_list, mask_buf, &mask_fmt);
         break;
     case 2: /* Bitmap image, solid mask */
         src_img = create_multi_pixel_image (img_fmt_list, src_buf, &src_fmt);
         mask_img = create_solid_image (mask_fmt_list, mask_buf, &mask_fmt);
         break;
     default:
         abort ();
     }

     if (mask_img)
     {
         ca = prng_rand_n (2);
         pixman_image_set_component_alpha (mask_img, ca);
     }

     if (verbose)
     {
         printf ("op=%s\n", operator_name (op));
         printf ("src_fmt=%s, dst_fmt=%s, mask_fmt=%s\n",
                 format_name (src_fmt), format_name (dst_fmt),
                 format_name (mask_fmt));
         printf ("src_size=%u, mask_size=%u, component_alpha=%u\n",
                 src_fmt == PIXMAN_solid ? 1 : src_img->bits.width,
                 !mask_img || mask_fmt == PIXMAN_solid ? 1 : mask_img->bits.width,
                 ca);
     }

     pixman_image_composite (op, src_img, mask_img, dst_img,
                             0, 0, 0, 0, 0, 0, WIDTH, HEIGHT);

     if (verbose)
         print_image (dst_img);

     crc32 = compute_crc32_for_image (0, dst_img);

     pixman_image_unref (src_img);
     pixman_image_unref (dst_img);
     if (mask_img)
         pixman_image_unref (mask_img);

     return crc32;
 }

 int
 main (int argc, const char *argv[])
 {
     int i;

     prng_srand (0);

     for (i = 1; i <= 8; i++)
     {
         initialize_palette (&(rgb_palette[i]), i, TRUE);
         initialize_palette (&(y_palette[i]), i, FALSE);
     }

     return fuzzer_test_main ("solid", 500000,
                              0xC30FD380,
 			     test_solid, argc, argv);
 }
	/*
	* Copyright © 2015 RISC OS Open Ltd
	*
	* Permission to use, copy, modify, distribute, and sell this software and its
	* documentation for any purpose is hereby granted without fee, provided that
	* the above copyright notice appear in all copies and that both that
	* copyright notice and this permission notice appear in supporting
	* documentation, and that the name of the copyright holders not be used in
	* advertising or publicity pertaining to distribution of the software without
	* specific, written prior permission. The copyright holders make no
	* representations about the suitability of this software for any purpose. It
	* is provided "as is" without express or implied warranty.
	*
	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
	* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
	* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
	* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
	* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
	* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
	* SOFTWARE.
	*
	* Author: Ben Avison (bavison@riscosopen.org)
	*
	*/

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

	#define WIDTH 32
	#define HEIGHT 32

	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_MULTIPLY,
	PIXMAN_OP_SCREEN,
	PIXMAN_OP_OVERLAY,
	PIXMAN_OP_DARKEN,
	PIXMAN_OP_LIGHTEN,
	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_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_COLOR_DODGE,
	PIXMAN_OP_COLOR_BURN,
	PIXMAN_OP_SOFT_LIGHT,
	PIXMAN_OP_HSL_HUE,
	PIXMAN_OP_HSL_SATURATION,
	PIXMAN_OP_HSL_COLOR,
	PIXMAN_OP_HSL_LUMINOSITY,
	#endif
	};

	/* The first eight format in the list are by far the most widely
	* used formats, so we test those more than the others
	*/
	#define N_MOST_LIKELY_FORMATS 8

	static const pixman_format_code_t img_fmt_list[] = {
	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 are going to use floating point in the near future */
	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_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_null
	};

	static const pixman_format_code_t mask_fmt_list[] = {
	PIXMAN_a8r8g8b8,
	PIXMAN_a8,
	PIXMAN_a4,
	PIXMAN_a1,
	PIXMAN_null
	};

	static pixman_indexed_t rgb_palette[9];
	static pixman_indexed_t y_palette[9];

	static pixman_format_code_t
	random_format (const pixman_format_code_t *allowed_formats)
	{
	int n = 0;

	while (allowed_formats[n] != PIXMAN_null)
	n++;

	if (n > N_MOST_LIKELY_FORMATS && prng_rand_n (4) != 0)
	n = N_MOST_LIKELY_FORMATS;

	return allowed_formats[prng_rand_n (n)];
	}

	static pixman_image_t *
	create_multi_pixel_image (const pixman_format_code_t *allowed_formats,
	uint32_t *buffer,
	pixman_format_code_t *used_fmt)
	{
	pixman_format_code_t fmt;
	pixman_image_t *img;
	int stride;

	fmt = random_format (allowed_formats);
	stride = (WIDTH * PIXMAN_FORMAT_BPP (fmt) + 31) / 32 * 4;
	img = pixman_image_create_bits (fmt, WIDTH, HEIGHT, buffer, 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)]));

	prng_randmemset (buffer, WIDTH * HEIGHT * 4, 0);
	image_endian_swap (img);

	if (used_fmt)
	*used_fmt = fmt;

	return img;
	}

	static pixman_image_t *
	create_solid_image (const pixman_format_code_t *allowed_formats,
	uint32_t *buffer,
	pixman_format_code_t *used_fmt)
	{
	if (prng_rand_n (2))
	{
	/* Use a repeating 1x1 bitmap image for solid */
	pixman_format_code_t fmt;
	pixman_image_t img, dummy_img;
	uint32_t bpp, dummy_buf;

	fmt = random_format (allowed_formats);
	bpp = PIXMAN_FORMAT_BPP (fmt);
	img = pixman_image_create_bits (fmt, 1, 1, buffer, 4);
	pixman_image_set_repeat (img, PIXMAN_REPEAT_NORMAL);

	if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_COLOR)
	pixman_image_set_indexed (img, &(rgb_palette[bpp]));
	else if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_GRAY)
	pixman_image_set_indexed (img, &(y_palette[bpp]));

	/* Force the flags to be calculated for image with initial
	* bitmap contents of 0 or 2^bpp-1 by plotting from it into a
	* separate throwaway image. It is simplest to write all 0s
	* or all 1s to the first word irrespective of the colour
	* depth even though we actually only care about the first
	* pixel since the stride has to be a whole number of words.
	*/
	*buffer = prng_rand_n (2) ? 0xFFFFFFFFu : 0;
	dummy_img = pixman_image_create_bits (PIXMAN_a8r8g8b8, 1, 1,
	&dummy_buf, 4);
	pixman_image_composite (PIXMAN_OP_SRC, img, NULL, dummy_img,
	0, 0, 0, 0, 0, 0, 1, 1);
	pixman_image_unref (dummy_img);

	/* Now set the bitmap contents to a random value */
	prng_randmemset (buffer, 4, 0);
	image_endian_swap (img);

	if (used_fmt)
	*used_fmt = fmt;

	return img;
	}
	else
	{
	/* Use a native solid image */
	pixman_color_t color;
	pixman_image_t *img;

	color.alpha = prng_rand_n (UINT16_MAX + 1);
	color.red = prng_rand_n (UINT16_MAX + 1);
	color.green = prng_rand_n (UINT16_MAX + 1);
	color.blue = prng_rand_n (UINT16_MAX + 1);
	img = pixman_image_create_solid_fill (&color);

	if (used_fmt)
	*used_fmt = PIXMAN_solid;

	return img;
	}
	}

	static uint32_t
	test_solid (int testnum, int verbose)
	{
	pixman_op_t op;
	uint32_t src_buf[WIDTH * HEIGHT];
	uint32_t dst_buf[WIDTH * HEIGHT];
	uint32_t mask_buf[WIDTH * HEIGHT];
	pixman_image_t *src_img;
	pixman_image_t *dst_img;
	pixman_image_t *mask_img = NULL;
	pixman_format_code_t src_fmt, dst_fmt, mask_fmt = PIXMAN_null;
	pixman_bool_t ca = 0;
	uint32_t crc32;

	prng_srand (testnum);

	op = op_list[prng_rand_n (ARRAY_LENGTH (op_list))];

	dst_img = create_multi_pixel_image (img_fmt_list, dst_buf, &dst_fmt);
	switch (prng_rand_n (3))
	{
	case 0: /* Solid source, no mask */
	src_img = create_solid_image (img_fmt_list, src_buf, &src_fmt);
	break;
	case 1: /* Solid source, bitmap mask */
	src_img = create_solid_image (img_fmt_list, src_buf, &src_fmt);
	mask_img = create_multi_pixel_image (mask_fmt_list, mask_buf, &mask_fmt);
	break;
	case 2: /* Bitmap image, solid mask */
	src_img = create_multi_pixel_image (img_fmt_list, src_buf, &src_fmt);
	mask_img = create_solid_image (mask_fmt_list, mask_buf, &mask_fmt);
	break;
	default:
	abort ();
	}

	if (mask_img)
	{
	ca = prng_rand_n (2);
	pixman_image_set_component_alpha (mask_img, ca);
	}

	if (verbose)
	{
	printf ("op=%s\n", operator_name (op));
	printf ("src_fmt=%s, dst_fmt=%s, mask_fmt=%s\n",
	format_name (src_fmt), format_name (dst_fmt),
	format_name (mask_fmt));
	printf ("src_size=%u, mask_size=%u, component_alpha=%u\n",
	src_fmt == PIXMAN_solid ? 1 : src_img->bits.width,
	!mask_img \|\| mask_fmt == PIXMAN_solid ? 1 : mask_img->bits.width,
	ca);
	}

	pixman_image_composite (op, src_img, mask_img, dst_img,
	0, 0, 0, 0, 0, 0, WIDTH, HEIGHT);

	if (verbose)
	print_image (dst_img);

	crc32 = compute_crc32_for_image (0, dst_img);

	pixman_image_unref (src_img);
	pixman_image_unref (dst_img);
	if (mask_img)
	pixman_image_unref (mask_img);

	return crc32;
	}

	int
	main (int argc, const char *argv[])
	{
	int i;

	prng_srand (0);

	for (i = 1; i <= 8; i++)
	{
	initialize_palette (&(rgb_palette[i]), i, TRUE);
	initialize_palette (&(y_palette[i]), i, FALSE);
	}

	return fuzzer_test_main ("solid", 500000,
	0xC30FD380,
	test_solid, argc, argv);
	}