qemu/pixman/test/pixel-test.c

   1 /*
   2  * Copyright © 2013 Soeren Sandmann
   3  * Copyright © 2013 Red Hat, Inc.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24 #include <stdio.h>
  25 #include <stdlib.h> /* abort() */
  26 #include <math.h>
  27 #include <time.h>
  28 #include "utils.h"
  29
  30 typedef struct pixel_combination_t pixel_combination_t;
  31 struct pixel_combination_t
  32 {
  33     pixman_op_t                 op;
  34     pixman_format_code_t        src_format;
  35     uint32_t                    src_pixel;
  36     pixman_format_code_t        dest_format;
  37     uint32_t                    dest_pixel;
  38 };
  39
  40 static const pixel_combination_t regressions[] =
  41 {
  42     { PIXMAN_OP_OVER,
  43       PIXMAN_a8r8g8b8,  0x0f00c300,
  44       PIXMAN_x14r6g6b6, 0x003c0,
  45     },
  46     { PIXMAN_OP_DISJOINT_XOR,
  47       PIXMAN_a4r4g4b4,  0xd0c0,
  48       PIXMAN_a8r8g8b8,  0x5300ea00,
  49     },
  50     { PIXMAN_OP_OVER,
  51       PIXMAN_a8r8g8b8,  0x20c6bf00,
  52       PIXMAN_r5g6b5,    0xb9ff
  53     },
  54     { PIXMAN_OP_OVER,
  55       PIXMAN_a8r8g8b8,  0x204ac7ff,
  56       PIXMAN_r5g6b5,    0xc1ff
  57     },
  58     { PIXMAN_OP_OVER_REVERSE,
  59       PIXMAN_r5g6b5,    0xffc3,
  60       PIXMAN_a8r8g8b8,  0x102d00dd
  61     },
  62     { PIXMAN_OP_OVER_REVERSE,
  63       PIXMAN_r5g6b5,    0x1f00,
  64       PIXMAN_a8r8g8b8,  0x1bdf0c89
  65     },
  66     { PIXMAN_OP_OVER_REVERSE,
  67       PIXMAN_r5g6b5,    0xf9d2,
  68       PIXMAN_a8r8g8b8,  0x1076bcf7
  69     },
  70     { PIXMAN_OP_OVER_REVERSE,
  71       PIXMAN_r5g6b5,    0x00c3,
  72       PIXMAN_a8r8g8b8,  0x1bfe9ae5
  73     },
  74     { PIXMAN_OP_OVER_REVERSE,
  75       PIXMAN_r5g6b5,    0x09ff,
  76       PIXMAN_a8r8g8b8,  0x0b00c16c
  77     },
  78     { PIXMAN_OP_DISJOINT_ATOP,
  79       PIXMAN_a2r2g2b2,  0xbc,
  80       PIXMAN_a8r8g8b8,  0x9efff1ff
  81     },
  82     { PIXMAN_OP_DISJOINT_ATOP,
  83       PIXMAN_a4r4g4b4,  0xae5f,
  84       PIXMAN_a8r8g8b8,  0xf215b675
  85     },
  86     { PIXMAN_OP_DISJOINT_ATOP_REVERSE,
  87       PIXMAN_a8r8g8b8,  0xce007980,
  88       PIXMAN_a8r8g8b8,  0x80ffe4ad
  89     },
  90     { PIXMAN_OP_DISJOINT_XOR,
  91       PIXMAN_a8r8g8b8,  0xb8b07bea,
  92       PIXMAN_a4r4g4b4,  0x939c
  93     },
  94     { PIXMAN_OP_CONJOINT_ATOP_REVERSE,
  95       PIXMAN_r5g6b5,    0x0063,
  96       PIXMAN_a8r8g8b8,  0x10bb1ed7,
  97     },
  98 };
  99
 100 static void
 101 fill (pixman_image_t *image, uint32_t pixel)
 102 {
 103     uint8_t *data = (uint8_t *)pixman_image_get_data (image);
 104     int bytes_per_pixel = PIXMAN_FORMAT_BPP (pixman_image_get_format (image)) / 8;
 105     int n_bytes = pixman_image_get_stride (image) * pixman_image_get_height (image);
 106     int i;
 107
 108     switch (bytes_per_pixel)
 109     {
 110     case 4:
 111         for (i = 0; i < n_bytes / 4; ++i)
 112             ((uint32_t *)data)[i] = pixel;
 113         break;
 114
 115     case 2:
 116         pixel &= 0xffff;
 117         for (i = 0; i < n_bytes / 2; ++i)
 118             ((uint16_t *)data)[i] = pixel;
 119         break;
 120
 121     case 1:
 122         pixel &= 0xff;
 123         for (i = 0; i < n_bytes; ++i)
 124             ((uint8_t *)data)[i] = pixel;
 125         break;
 126
 127     default:
 128         assert (0);
 129         break;
 130     }
 131 }
 132
 133 static uint32_t
 134 access (pixman_image_t *image, int x, int y)
 135 {
 136     int bytes_per_pixel;
 137     int stride;
 138     uint32_t result;
 139     uint8_t *location;
 140
 141     if (x < 0 || x >= image->bits.width || y < 0 || y >= image->bits.height)
 142         return 0;
 143
 144     bytes_per_pixel = PIXMAN_FORMAT_BPP (image->bits.format) / 8;
 145     stride = image->bits.rowstride * 4;
 146
 147     location = (uint8_t *)image->bits.bits + y * stride + x * bytes_per_pixel;
 148
 149     if (bytes_per_pixel == 4)
 150         result = *(uint32_t *)location;
 151     else if (bytes_per_pixel == 2)
 152         result = *(uint16_t *)location;
 153     else if (bytes_per_pixel == 1)
 154         result = *(uint8_t *)location;
 155     else
 156         assert (0);
 157
 158     return result;
 159 }
 160
 161 static pixman_bool_t
 162 verify (int test_no, const pixel_combination_t *combination, int size)
 163 {
 164     pixman_image_t *src, *dest;
 165     pixel_checker_t src_checker, dest_checker;
 166     color_t source_color, dest_color, reference_color;
 167     pixman_bool_t result = TRUE;
 168     int i, j;
 169
 170     /* Compute reference color */
 171     pixel_checker_init (&src_checker, combination->src_format);
 172     pixel_checker_init (&dest_checker, combination->dest_format);
 173     pixel_checker_convert_pixel_to_color (
 174         &src_checker, combination->src_pixel, &source_color);
 175     pixel_checker_convert_pixel_to_color (
 176         &dest_checker, combination->dest_pixel, &dest_color);
 177     do_composite (combination->op,
 178                   &source_color, NULL, &dest_color,
 179                   &reference_color, FALSE);
 180
 181     src = pixman_image_create_bits (
 182         combination->src_format, size, size, NULL, -1);
 183     dest = pixman_image_create_bits (
 184         combination->dest_format, size, size, NULL, -1);
 185
 186     fill (src, combination->src_pixel);
 187     fill (dest, combination->dest_pixel);
 188
 189     pixman_image_composite32 (
 190         combination->op, src, NULL, dest, 0, 0, 0, 0, 0, 0, size, size);
 191
 192     for (j = 0; j < size; ++j)
 193     {
 194         for (i = 0; i < size; ++i)
 195         {
 196             uint32_t computed = access (dest, i, j);
 197             int32_t a, r, g, b;
 198
 199             if (!pixel_checker_check (&dest_checker, computed, &reference_color))
 200             {
 201                 printf ("----------- Test %d failed ----------\n", test_no);
 202
 203                 printf ("   operator:         %s\n", operator_name (combination->op));
 204                 printf ("   src format:       %s\n", format_name (combination->src_format));
 205                 printf ("   dest format:      %s\n", format_name (combination->dest_format));
 206                 printf (" - source ARGB:      %f  %f  %f  %f   (pixel: %8x)\n",
 207                         source_color.a, source_color.r, source_color.g, source_color.b,
 208                         combination->src_pixel);
 209                 pixel_checker_split_pixel (&src_checker, combination->src_pixel,
 210                                            &a, &r, &g, &b);
 211                 printf ("                     %8d  %8d  %8d  %8d\n", a, r, g, b);
 212
 213                 printf (" - dest ARGB:        %f  %f  %f  %f   (pixel: %8x)\n",
 214                         dest_color.a, dest_color.r, dest_color.g, dest_color.b,
 215                         combination->dest_pixel);
 216                 pixel_checker_split_pixel (&dest_checker, combination->dest_pixel,
 217                                            &a, &r, &g, &b);
 218                 printf ("                     %8d  %8d  %8d  %8d\n", a, r, g, b);
 219
 220                 pixel_checker_split_pixel (&dest_checker, computed, &a, &r, &g, &b);
 221                 printf (" - expected ARGB:    %f  %f  %f  %f\n",
 222                         reference_color.a, reference_color.r, reference_color.g, reference_color.b);
 223
 224                 pixel_checker_get_min (&dest_checker, &reference_color, &a, &r, &g, &b);
 225                 printf ("   min acceptable:   %8d  %8d  %8d  %8d\n", a, r, g, b);
 226
 227                 pixel_checker_split_pixel (&dest_checker, computed, &a, &r, &g, &b);
 228                 printf ("   got:              %8d  %8d  %8d  %8d   (pixel: %8x)\n", a, r, g, b, computed);
 229
 230                 pixel_checker_get_max (&dest_checker, &reference_color, &a, &r, &g, &b);
 231                 printf ("   max acceptable:   %8d  %8d  %8d  %8d\n", a, r, g, b);
 232
 233                 result = FALSE;
 234                 goto done;
 235             }
 236         }
 237     }
 238
 239 done:
 240     pixman_image_unref (src);
 241     pixman_image_unref (dest);
 242
 243     return result;
 244 }
 245
 246 int
 247 main (int argc, char **argv)
 248 {
 249     int result = 0;
 250     int i, j;
 251
 252     for (i = 0; i < ARRAY_LENGTH (regressions); ++i)
 253     {
 254         const pixel_combination_t *combination = &(regressions[i]);
 255
 256         for (j = 1; j < 34; ++j)
 257         {
 258             if (!verify (i, combination, j))
 259             {
 260                 result = 1;
 261                 break;
 262             }
 263         }
 264     }
 265
 266     return result;
 267 }