IABSD.fr/xenocara/lib/pixman/test/rotate-test.c

Branch : - branch - master - tag -

• Show log

  Commit

• Author : matthieu
  Date : 2013-12-01 20:34:20
  Hash : 4db6d49d
  Message : Update to pixman 0.32.4. Tested by naddy@ and ajacoutot@

• lib/pixman/test/rotate-test.c

• #include <stdlib.h>
  #include "utils.h"
  
  #define WIDTH	32
  #define HEIGHT	32
  
  static const pixman_format_code_t formats[] =
  {
      PIXMAN_a8r8g8b8,
      PIXMAN_a8b8g8r8,
      PIXMAN_x8r8g8b8,
      PIXMAN_x8b8g8r8,
      PIXMAN_r5g6b5,
      PIXMAN_b5g6r5,
      PIXMAN_a8,
      PIXMAN_a1,
  };
  
  static const pixman_op_t ops[] =
  {
      PIXMAN_OP_OVER,
      PIXMAN_OP_SRC,
      PIXMAN_OP_ADD,
  };
  
  #define TRANSFORM(v00, v01, v10, v11)					\
      { { { v00, v01, WIDTH * pixman_fixed_1 / 2 },			\
          { v10, v11, HEIGHT * pixman_fixed_1 / 2 },			\
  	{ 0, 0, pixman_fixed_1 } } }
  
  #define F1 pixman_fixed_1
  
  static const pixman_transform_t transforms[] =
  {
      TRANSFORM (0, -1, 1, 0),		/* wrong 90 degree rotation */
      TRANSFORM (0, 1, -1, 0),		/* wrong 270 degree rotation */
      TRANSFORM (1, 0, 0, 1),		/* wrong identity */
      TRANSFORM (-1, 0, 0, -1),		/* wrong 180 degree rotation */
      TRANSFORM (0, -F1, F1, 0),		/* correct 90 degree rotation */
      TRANSFORM (0, F1, -F1, 0),		/* correct 270 degree rotation */
      TRANSFORM (F1, 0, 0, F1),		/* correct identity */
      TRANSFORM (-F1, 0, 0, -F1),		/* correct 180 degree rotation */
  };
  
  #define RANDOM_FORMAT()							\
      (formats[prng_rand_n (ARRAY_LENGTH (formats))])
  
  #define RANDOM_OP()							\
      (ops[prng_rand_n (ARRAY_LENGTH (ops))])
  
  #define RANDOM_TRANSFORM()						\
      (&(transforms[prng_rand_n (ARRAY_LENGTH (transforms))]))
  
  static void
  on_destroy (pixman_image_t *image, void *data)
  {
      free (data);
  }
  
  static pixman_image_t *
  make_image (void)
  {
      pixman_format_code_t format = RANDOM_FORMAT();
      uint32_t *bytes, *orig;
      pixman_image_t *image;
      int stride;
  
      orig = bytes = malloc (WIDTH * HEIGHT * 4);
      prng_randmemset (bytes, WIDTH * HEIGHT * 4, 0);
  
      stride = WIDTH * 4;
      if (prng_rand_n (2) == 0)
      {
  	bytes += (stride / 4) * (HEIGHT - 1);
  	stride = - stride;
      }
  
      image = pixman_image_create_bits (
  	format, WIDTH, HEIGHT, bytes, stride);
  
      pixman_image_set_transform (image, RANDOM_TRANSFORM());
      pixman_image_set_destroy_function (image, on_destroy, orig);
      pixman_image_set_repeat (image, PIXMAN_REPEAT_NORMAL);
  
      image_endian_swap (image);
  
      return image;
  }
  
  static uint32_t
  test_transform (int testnum, int verbose)
  {
      pixman_image_t *src, *dest;
      uint32_t crc;
  
      prng_srand (testnum);
      
      src = make_image ();
      dest = make_image ();
  
      pixman_image_composite (RANDOM_OP(),
  			    src, NULL, dest,
  			    0, 0, 0, 0, WIDTH / 2, HEIGHT / 2,
  			    WIDTH, HEIGHT);
  
      crc = compute_crc32_for_image (0, dest);
  
      pixman_image_unref (src);
      pixman_image_unref (dest);
  
      return crc;
  }
  
  int
  main (int argc, const char *argv[])
  {
      return fuzzer_test_main ("rotate", 15000,
  			     0x81E9EC2F,
  			     test_transform, argc, argv);
  }