Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <config.h>
  4. #include "pixman-private.h"
  5. #include "pixman.h"
  6.  
  7. #define FALSE 0
  8. #define TRUE 1
  9.  
  10. /* Randomly decide between 32 and 16 bit
  11.  *
  12.  * Allocate bits with random width, stride and height
  13.  *
  14.  * Then make up some random offset (dx, dy)
  15.  *
  16.  * Then make an image with those values.
  17.  *
  18.  * Do this for both source and destination
  19.  *
  20.  * Composite them together using OVER.
  21.  *
  22.  * The bits in the source and the destination should have
  23.  * recognizable colors so that the result can be verified.
  24.  *
  25.  * Ie., walk the bits and verify that they have been composited.
  26.  */
  27.  
  28. static int
  29. get_rand (int bound)
  30. {
  31.     return rand () % bound;
  32. }
  33.  
  34. static pixman_image_t *
  35. make_image (int width, int height, pixman_bool_t src, int *rx, int *ry)
  36. {
  37.     pixman_format_code_t format;
  38.     pixman_image_t *image;
  39.     pixman_region32_t region;
  40.     uint8_t *bits;
  41.     int stride;
  42.     int bpp;
  43.     int dx, dy;
  44.     int i, j;
  45.  
  46.     if (src)
  47.         format = PIXMAN_a8r8g8b8;
  48.     else
  49.         format = PIXMAN_r5g6b5;
  50.  
  51.     bpp = PIXMAN_FORMAT_BPP (format) / 8;
  52.  
  53.     stride = width + get_rand (width);
  54.     stride += (stride & 1);             /* Make it an even number */
  55.  
  56.     bits = malloc (height * stride * bpp);
  57.  
  58.     for (j = 0; j < height; ++j)
  59.     {
  60.         for (i = 0; i < width; ++i)
  61.         {
  62.             uint8_t *pixel = bits + (stride * j + i) * bpp;
  63.  
  64.             if (src)
  65.                 *(uint32_t *)pixel = 0x7f00007f;
  66.             else
  67.                 *(uint16_t *)pixel = 0xf100;
  68.         }
  69.     }
  70.  
  71.     dx = dy = 0;
  72.  
  73.     dx = get_rand (500);
  74.     dy = get_rand (500);
  75.  
  76.     if (!src)
  77.     {
  78.         /* Now simulate the bogus X server translations */
  79.         bits -= (dy * stride + dx) * bpp;
  80.     }
  81.  
  82.     image = pixman_image_create_bits (
  83.         format, width, height, (uint32_t *)bits, stride * bpp);
  84.  
  85.     if (!src)
  86.     {
  87.         /* And add the bogus clip region */
  88.         pixman_region32_init_rect (&region, dx, dy, dx + width, dy + height);
  89.  
  90.         pixman_image_set_clip_region32 (image, &region);
  91.     }
  92.  
  93.     pixman_image_set_source_clipping (image, TRUE);
  94.  
  95.     if (src)
  96.     {
  97.         pixman_transform_t trans;
  98.  
  99.         pixman_transform_init_identity (&trans);
  100.  
  101.         pixman_transform_translate (&trans,
  102.                                     NULL,
  103.                                     - pixman_int_to_fixed (width / 2),
  104.                                     - pixman_int_to_fixed (height / 2));
  105.  
  106.         pixman_transform_scale (&trans,
  107.                                 NULL,
  108.                                 pixman_double_to_fixed (0.5),
  109.                                 pixman_double_to_fixed (0.5));
  110.  
  111.         pixman_transform_translate (&trans,
  112.                                     NULL,
  113.                                     pixman_int_to_fixed (width / 2),
  114.                                     pixman_int_to_fixed (height / 2));
  115.  
  116.         pixman_image_set_transform (image, &trans);
  117.         pixman_image_set_filter (image, PIXMAN_FILTER_BILINEAR, NULL, 0);
  118.         pixman_image_set_repeat (image, PIXMAN_REPEAT_PAD);
  119.     }
  120.  
  121.     if (!src)
  122.     {
  123.         *rx = dx;
  124.         *ry = dy;
  125.     }
  126.     else
  127.     {
  128.         *rx = *ry = 0;
  129.     }
  130.  
  131.     return image;
  132. }
  133.  
  134. int
  135. main ()
  136. {
  137.     pixman_image_t *src, *dest;
  138.     int src_x, src_y, dest_x, dest_y;
  139.     int i, j;
  140.     int width = get_rand (499) + 1;
  141.     int height = get_rand (499) + 1;
  142.  
  143.     src = make_image (width, height, TRUE, &src_x, &src_y);
  144.     dest = make_image (width, height, FALSE, &dest_x, &dest_y);
  145.  
  146.     pixman_image_composite (
  147.         PIXMAN_OP_OVER, src, NULL, dest,
  148.         src_x, src_y,
  149.         -1, -1,
  150.         dest_x, dest_y,
  151.         width, height);
  152.  
  153.     for (i = 0; i < height; ++i)
  154.     {
  155.         for (j = 0; j < width; ++j)
  156.         {
  157.             uint8_t *bits = (uint8_t *)dest->bits.bits;
  158.             int bpp = PIXMAN_FORMAT_BPP (dest->bits.format) / 8;
  159.             int stride = dest->bits.rowstride * 4;
  160.  
  161.             uint8_t *pixel =
  162.                 bits + (i + dest_y) * stride + (j + dest_x) * bpp;
  163.  
  164.             if (*(uint16_t *)pixel != 0x788f)
  165.             {
  166.                 printf ("bad pixel %x\n", *(uint16_t *)pixel);
  167.                 assert (*(uint16_t *)pixel == 0x788f);
  168.             }
  169.         }
  170.     }
  171.  
  172.     return 0;
  173. }
  174.