test: Make sure the palettes for indexed format roundtrip properly
[profile/ivi/pixman.git] / test / blitters-test.c
1 /*
2  * Test program, which stresses the use of different color formats and
3  * compositing operations.
4  *
5  * Script 'fuzzer-find-diff.pl' can be used to narrow down the problem in
6  * the case of test failure.
7  */
8 #include <assert.h>
9 #include <stdlib.h>
10 #include <stdio.h>
11 #include <config.h>
12 #include "utils.h"
13
14 static pixman_indexed_t rgb_palette[9];
15 static pixman_indexed_t y_palette[9];
16
17 static void *
18 aligned_malloc (size_t align, size_t size)
19 {
20     void *result;
21
22 #ifdef HAVE_POSIX_MEMALIGN
23     if (posix_memalign (&result, align, size) != 0)
24       result = NULL;
25 #else
26     result = malloc (size);
27 #endif
28
29     return result;
30 }
31
32 /* Create random image for testing purposes */
33 static pixman_image_t *
34 create_random_image (pixman_format_code_t *allowed_formats,
35                      int                   max_width,
36                      int                   max_height,
37                      int                   max_extra_stride,
38                      pixman_format_code_t *used_fmt)
39 {
40     int n = 0, i, width, height, stride;
41     pixman_format_code_t fmt;
42     uint32_t *buf;
43     pixman_image_t *img;
44
45     while (allowed_formats[n] != -1)
46         n++;
47     fmt = allowed_formats[lcg_rand_n (n)];
48
49     width = lcg_rand_n (max_width) + 1;
50     height = lcg_rand_n (max_height) + 1;
51     stride = (width * PIXMAN_FORMAT_BPP (fmt) + 7) / 8 +
52         lcg_rand_n (max_extra_stride + 1);
53     stride = (stride + 3) & ~3;
54
55     /* do the allocation */
56     buf = aligned_malloc (64, stride * height);
57
58     /* initialize image with random data */
59     for (i = 0; i < stride * height; i++)
60     {
61         /* generation is biased to having more 0 or 255 bytes as
62          * they are more likely to be special-cased in code
63          */
64         *((uint8_t *)buf + i) = lcg_rand_n (4) ? lcg_rand_n (256) :
65             (lcg_rand_n (2) ? 0 : 255);
66     }
67
68     img = pixman_image_create_bits (fmt, width, height, buf, stride);
69
70     if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_COLOR)
71     {
72         pixman_image_set_indexed (img, &(rgb_palette[PIXMAN_FORMAT_BPP (fmt)]));
73     }
74     else if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_GRAY)
75     {
76         pixman_image_set_indexed (img, &(y_palette[PIXMAN_FORMAT_BPP (fmt)]));
77     }
78
79     image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));
80
81     if (used_fmt) *used_fmt = fmt;
82     return img;
83 }
84
85 /* Free random image, and optionally update crc32 based on its data */
86 static uint32_t
87 free_random_image (uint32_t initcrc,
88                    pixman_image_t *img,
89                    pixman_format_code_t fmt)
90 {
91     uint32_t crc32 = 0;
92     int stride = pixman_image_get_stride (img);
93     uint32_t *data = pixman_image_get_data (img);
94     int height = pixman_image_get_height (img);
95
96     if (fmt != -1)
97     {
98         /* mask unused 'x' part */
99         if (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt) &&
100             PIXMAN_FORMAT_DEPTH (fmt) != 0)
101         {
102             int i;
103             uint32_t *data = pixman_image_get_data (img);
104             uint32_t mask = (1 << PIXMAN_FORMAT_DEPTH (fmt)) - 1;
105
106             if (PIXMAN_FORMAT_TYPE (fmt) == PIXMAN_TYPE_BGRA)
107                 mask <<= (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt));
108
109             for (i = 0; i < 32; i++)
110                 mask |= mask << (i * PIXMAN_FORMAT_BPP (fmt));
111
112             for (i = 0; i < stride * height / 4; i++)
113                 data[i] &= mask;
114         }
115
116         /* swap endiannes in order to provide identical results on both big
117          * and litte endian systems
118          */
119         image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));
120         crc32 = compute_crc32 (initcrc, data, stride * height);
121     }
122
123     pixman_image_unref (img);
124     free (data);
125
126     return crc32;
127 }
128
129 static pixman_op_t op_list[] = {
130     PIXMAN_OP_SRC,
131     PIXMAN_OP_OVER,
132     PIXMAN_OP_ADD,
133     PIXMAN_OP_CLEAR,
134     PIXMAN_OP_SRC,
135     PIXMAN_OP_DST,
136     PIXMAN_OP_OVER,
137     PIXMAN_OP_OVER_REVERSE,
138     PIXMAN_OP_IN,
139     PIXMAN_OP_IN_REVERSE,
140     PIXMAN_OP_OUT,
141     PIXMAN_OP_OUT_REVERSE,
142     PIXMAN_OP_ATOP,
143     PIXMAN_OP_ATOP_REVERSE,
144     PIXMAN_OP_XOR,
145     PIXMAN_OP_ADD,
146     PIXMAN_OP_SATURATE,
147     PIXMAN_OP_DISJOINT_CLEAR,
148     PIXMAN_OP_DISJOINT_SRC,
149     PIXMAN_OP_DISJOINT_DST,
150     PIXMAN_OP_DISJOINT_OVER,
151     PIXMAN_OP_DISJOINT_OVER_REVERSE,
152     PIXMAN_OP_DISJOINT_IN,
153     PIXMAN_OP_DISJOINT_IN_REVERSE,
154     PIXMAN_OP_DISJOINT_OUT,
155     PIXMAN_OP_DISJOINT_OUT_REVERSE,
156     PIXMAN_OP_DISJOINT_ATOP,
157     PIXMAN_OP_DISJOINT_ATOP_REVERSE,
158     PIXMAN_OP_DISJOINT_XOR,
159     PIXMAN_OP_CONJOINT_CLEAR,
160     PIXMAN_OP_CONJOINT_SRC,
161     PIXMAN_OP_CONJOINT_DST,
162     PIXMAN_OP_CONJOINT_OVER,
163     PIXMAN_OP_CONJOINT_OVER_REVERSE,
164     PIXMAN_OP_CONJOINT_IN,
165     PIXMAN_OP_CONJOINT_IN_REVERSE,
166     PIXMAN_OP_CONJOINT_OUT,
167     PIXMAN_OP_CONJOINT_OUT_REVERSE,
168     PIXMAN_OP_CONJOINT_ATOP,
169     PIXMAN_OP_CONJOINT_ATOP_REVERSE,
170     PIXMAN_OP_CONJOINT_XOR,
171     PIXMAN_OP_MULTIPLY,
172     PIXMAN_OP_SCREEN,
173     PIXMAN_OP_OVERLAY,
174     PIXMAN_OP_DARKEN,
175     PIXMAN_OP_LIGHTEN,
176     PIXMAN_OP_COLOR_DODGE,
177     PIXMAN_OP_COLOR_BURN,
178     PIXMAN_OP_HARD_LIGHT,
179     PIXMAN_OP_DIFFERENCE,
180     PIXMAN_OP_EXCLUSION,
181 #if 0 /* these use floating point math and are not always bitexact on different platforms */
182     PIXMAN_OP_SOFT_LIGHT,
183     PIXMAN_OP_HSL_HUE,
184     PIXMAN_OP_HSL_SATURATION,
185     PIXMAN_OP_HSL_COLOR,
186     PIXMAN_OP_HSL_LUMINOSITY,
187 #endif
188 };
189
190 static pixman_format_code_t img_fmt_list[] = {
191     PIXMAN_a8r8g8b8,
192     PIXMAN_x8r8g8b8,
193     PIXMAN_r5g6b5,
194     PIXMAN_r3g3b2,
195     PIXMAN_a8,
196     PIXMAN_a8b8g8r8,
197     PIXMAN_x8b8g8r8,
198     PIXMAN_b8g8r8a8,
199     PIXMAN_b8g8r8x8,
200     PIXMAN_r8g8b8,
201     PIXMAN_b8g8r8,
202     PIXMAN_r5g6b5,
203     PIXMAN_b5g6r5,
204     PIXMAN_x2r10g10b10,
205     PIXMAN_a2r10g10b10,
206     PIXMAN_x2b10g10r10,
207     PIXMAN_a2b10g10r10,
208     PIXMAN_a1r5g5b5,
209     PIXMAN_x1r5g5b5,
210     PIXMAN_a1b5g5r5,
211     PIXMAN_x1b5g5r5,
212     PIXMAN_a4r4g4b4,
213     PIXMAN_x4r4g4b4,
214     PIXMAN_a4b4g4r4,
215     PIXMAN_x4b4g4r4,
216     PIXMAN_a8,
217     PIXMAN_r3g3b2,
218     PIXMAN_b2g3r3,
219     PIXMAN_a2r2g2b2,
220     PIXMAN_a2b2g2r2,
221     PIXMAN_c8,
222     PIXMAN_g8,
223     PIXMAN_x4c4,
224     PIXMAN_x4g4,
225     PIXMAN_c4,
226     PIXMAN_g4,
227     PIXMAN_g1,
228     PIXMAN_x4a4,
229     PIXMAN_a4,
230     PIXMAN_r1g2b1,
231     PIXMAN_b1g2r1,
232     PIXMAN_a1r1g1b1,
233     PIXMAN_a1b1g1r1,
234     PIXMAN_a1,
235     -1
236 };
237
238 static pixman_format_code_t mask_fmt_list[] = {
239     PIXMAN_a8r8g8b8,
240     PIXMAN_a8,
241     PIXMAN_a4,
242     PIXMAN_a1,
243     -1
244 };
245
246
247 /*
248  * Composite operation with pseudorandom images
249  */
250 uint32_t
251 test_composite (int testnum, int verbose)
252 {
253     int i;
254     pixman_image_t *src_img = NULL;
255     pixman_image_t *dst_img = NULL;
256     pixman_image_t *mask_img = NULL;
257     int src_width, src_height;
258     int dst_width, dst_height;
259     int src_stride, dst_stride;
260     int src_x, src_y;
261     int dst_x, dst_y;
262     int mask_x, mask_y;
263     int w, h;
264     int op;
265     pixman_format_code_t src_fmt, dst_fmt, mask_fmt;
266     uint32_t *dstbuf, *srcbuf, *maskbuf;
267     uint32_t crc32;
268     int max_width, max_height, max_extra_stride;
269
270     max_width = max_height = 24 + testnum / 10000;
271     max_extra_stride = 4 + testnum / 1000000;
272
273     if (max_width > 256)
274         max_width = 256;
275
276     if (max_height > 16)
277         max_height = 16;
278
279     if (max_extra_stride > 8)
280         max_extra_stride = 8;
281
282     lcg_srand (testnum);
283
284     op = op_list[lcg_rand_n (sizeof (op_list) / sizeof (op_list[0]))];
285
286     if (lcg_rand_n (8))
287     {
288         /* normal image */
289         src_img = create_random_image (img_fmt_list, max_width, max_height,
290                                        max_extra_stride, &src_fmt);
291     }
292     else
293     {
294         /* solid case */
295         src_img = create_random_image (img_fmt_list, 1, 1,
296                                        max_extra_stride, &src_fmt);
297
298         pixman_image_set_repeat (src_img, PIXMAN_REPEAT_NORMAL);
299     }
300
301     dst_img = create_random_image (img_fmt_list, max_width, max_height,
302                                    max_extra_stride, &dst_fmt);
303
304     src_width = pixman_image_get_width (src_img);
305     src_height = pixman_image_get_height (src_img);
306     src_stride = pixman_image_get_stride (src_img);
307
308     dst_width = pixman_image_get_width (dst_img);
309     dst_height = pixman_image_get_height (dst_img);
310     dst_stride = pixman_image_get_stride (dst_img);
311
312     dstbuf = pixman_image_get_data (dst_img);
313     srcbuf = pixman_image_get_data (src_img);
314
315     src_x = lcg_rand_n (src_width);
316     src_y = lcg_rand_n (src_height);
317     dst_x = lcg_rand_n (dst_width);
318     dst_y = lcg_rand_n (dst_height);
319
320     mask_img = NULL;
321     mask_fmt = -1;
322     mask_x = 0;
323     mask_y = 0;
324     maskbuf = NULL;
325
326     if ((src_fmt == PIXMAN_x8r8g8b8 || src_fmt == PIXMAN_x8b8g8r8) &&
327         (lcg_rand_n (4) == 0))
328     {
329         /* PIXBUF */
330         mask_fmt = lcg_rand_n (2) ? PIXMAN_a8r8g8b8 : PIXMAN_a8b8g8r8;
331         mask_img = pixman_image_create_bits (mask_fmt,
332                                              src_width,
333                                              src_height,
334                                              srcbuf,
335                                              src_stride);
336         mask_x = src_x;
337         mask_y = src_y;
338         maskbuf = srcbuf;
339     }
340     else if (lcg_rand_n (2))
341     {
342         if (lcg_rand_n (2))
343         {
344             mask_img = create_random_image (mask_fmt_list, max_width, max_height,
345                                            max_extra_stride, &mask_fmt);
346         }
347         else
348         {
349             /* solid case */
350             mask_img = create_random_image (mask_fmt_list, 1, 1,
351                                            max_extra_stride, &mask_fmt);
352             pixman_image_set_repeat (mask_img, PIXMAN_REPEAT_NORMAL);
353         }
354
355         if (lcg_rand_n (2))
356             pixman_image_set_component_alpha (mask_img, 1);
357
358         mask_x = lcg_rand_n (pixman_image_get_width (mask_img));
359         mask_y = lcg_rand_n (pixman_image_get_height (mask_img));
360     }
361
362
363     w = lcg_rand_n (dst_width - dst_x + 1);
364     h = lcg_rand_n (dst_height - dst_y + 1);
365
366     if (verbose)
367     {
368         printf ("op=%d, src_fmt=%08X, dst_fmt=%08X, mask_fmt=%08X\n",
369             op, src_fmt, dst_fmt, mask_fmt);
370         printf ("src_width=%d, src_height=%d, dst_width=%d, dst_height=%d\n",
371             src_width, src_height, dst_width, dst_height);
372         printf ("src_x=%d, src_y=%d, dst_x=%d, dst_y=%d\n",
373             src_x, src_y, dst_x, dst_y);
374         printf ("src_stride=%d, dst_stride=%d\n",
375             src_stride, dst_stride);
376         printf ("w=%d, h=%d\n", w, h);
377     }
378
379     pixman_image_composite (op, src_img, mask_img, dst_img,
380                             src_x, src_y, mask_x, mask_y, dst_x, dst_y, w, h);
381
382     if (verbose)
383     {
384         int j;
385
386         printf ("---\n");
387         for (i = 0; i < dst_height; i++)
388         {
389             for (j = 0; j < dst_stride; j++)
390             {
391                 if (j == (dst_width * PIXMAN_FORMAT_BPP (dst_fmt) + 7) / 8)
392                     printf ("| ");
393
394                 printf ("%02X ", *((uint8_t *)dstbuf + i * dst_stride + j));
395             }
396             printf ("\n");
397         }
398         printf ("---\n");
399     }
400
401     free_random_image (0, src_img, -1);
402     crc32 = free_random_image (0, dst_img, dst_fmt);
403
404     if (mask_img)
405     {
406         if (srcbuf == maskbuf)
407             pixman_image_unref(mask_img);
408         else
409             free_random_image (0, mask_img, -1);
410     }
411
412
413     return crc32;
414 }
415
416 #define CONVERT_15(c, is_rgb)                                           \
417     (is_rgb?                                                            \
418      ((((c) >> 3) & 0x001f) |                                           \
419       (((c) >> 6) & 0x03e0) |                                           \
420       (((c) >> 9) & 0x7c00)) :                                          \
421      (((((c) >> 16) & 0xff) * 153 +                                     \
422        (((c) >>  8) & 0xff) * 301 +                                     \
423        (((c)      ) & 0xff) * 58) >> 2))
424
425 static void
426 initialize_palette (pixman_indexed_t *palette, uint32_t mask, int is_rgb)
427 {
428     int i;
429
430     for (i = 0; i < 32768; ++i)
431         palette->ent[i] = lcg_rand() & mask;
432
433     for (i = 0; i < mask + 1; ++i)
434     {
435         uint32_t rgba24;
436         pixman_bool_t retry;
437         uint32_t i15;
438
439         /* We filled the rgb->index map with random numbers, but we
440          * do need the ability to round trip, that is if some indexed
441          * color expands to an argb24, then the 15 bit version of that
442          * color must map back to the index. Anything else, we don't
443          * care about too much.
444          */
445         do
446         {
447             uint32_t old_idx;
448             
449             rgba24 = lcg_rand();
450             i15 = CONVERT_15 (rgba24, is_rgb);
451
452             old_idx = palette->ent[i15];
453             if (CONVERT_15 (palette->rgba[old_idx], is_rgb) == i15)
454                 retry = 1;
455             else
456                 retry = 0;
457         } while (retry);
458         
459         palette->rgba[i] = rgba24;
460         palette->ent[i15] = i;
461     }
462
463     for (i = 0; i < mask + 1; ++i)
464     {
465         assert (palette->ent[CONVERT_15 (palette->rgba[i], is_rgb)] == i);
466     }
467 }
468
469 int
470 main (int argc, const char *argv[])
471 {
472     int i;
473
474     for (i = 1; i <= 8; i++)
475     {
476         initialize_palette (&(rgb_palette[i]), (1 << i) - 1, TRUE);
477         initialize_palette (&(y_palette[i]), (1 << i) - 1, FALSE);
478     }
479
480     return fuzzer_test_main("blitters", 2000000,
481                             0xD0B050B1,
482                             test_composite, argc, argv);
483 }