| #include <stdio.h> |
| #include <stdlib.h> |
| #include "utils.h" |
| |
| #define WIDTH 48 |
| #define HEIGHT 48 |
| |
| static const pixman_format_code_t formats[] = |
| { |
| PIXMAN_a8r8g8b8, |
| PIXMAN_a2r10g10b10, |
| PIXMAN_a4r4g4b4, |
| PIXMAN_a8 |
| }; |
| |
| static const pixman_format_code_t alpha_formats[] = |
| { |
| PIXMAN_null, |
| PIXMAN_a8, |
| PIXMAN_a2r10g10b10, |
| PIXMAN_a4r4g4b4 |
| }; |
| |
| static const int origins[] = |
| { |
| 0, 10, -100 |
| }; |
| |
| static void |
| on_destroy (pixman_image_t *image, void *data) |
| { |
| uint32_t *bits = pixman_image_get_data (image); |
| |
| fence_free (bits); |
| } |
| |
| static pixman_image_t * |
| make_image (pixman_format_code_t format) |
| { |
| uint32_t *bits; |
| uint8_t bpp = PIXMAN_FORMAT_BPP (format) / 8; |
| pixman_image_t *image; |
| |
| bits = (uint32_t *)make_random_bytes (WIDTH * HEIGHT * bpp); |
| |
| image = pixman_image_create_bits (format, WIDTH, HEIGHT, bits, WIDTH * bpp); |
| |
| if (image && bits) |
| pixman_image_set_destroy_function (image, on_destroy, NULL); |
| |
| return image; |
| } |
| |
| static uint8_t |
| get_alpha (pixman_image_t *image, int x, int y, int orig_x, int orig_y) |
| { |
| uint8_t *bits; |
| uint8_t r; |
| |
| if (image->common.alpha_map) |
| { |
| if (x - orig_x >= 0 && x - orig_x < WIDTH && |
| y - orig_y >= 0 && y - orig_y < HEIGHT) |
| { |
| image = (pixman_image_t *)image->common.alpha_map; |
| |
| x -= orig_x; |
| y -= orig_y; |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| bits = (uint8_t *)image->bits.bits; |
| |
| if (image->bits.format == PIXMAN_a8) |
| { |
| r = bits[y * WIDTH + x]; |
| } |
| else if (image->bits.format == PIXMAN_a2r10g10b10) |
| { |
| r = ((uint32_t *)bits)[y * WIDTH + x] >> 30; |
| r |= r << 2; |
| r |= r << 4; |
| } |
| else if (image->bits.format == PIXMAN_a8r8g8b8) |
| { |
| r = ((uint32_t *)bits)[y * WIDTH + x] >> 24; |
| } |
| else if (image->bits.format == PIXMAN_a4r4g4b4) |
| { |
| r = ((uint16_t *)bits)[y * WIDTH + x] >> 12; |
| r |= r << 4; |
| } |
| else |
| { |
| assert (0); |
| } |
| |
| return r; |
| } |
| |
| static uint16_t |
| get_red (pixman_image_t *image, int x, int y, int orig_x, int orig_y) |
| { |
| uint8_t *bits; |
| uint16_t r; |
| |
| bits = (uint8_t *)image->bits.bits; |
| |
| if (image->bits.format == PIXMAN_a8) |
| { |
| r = 0x00; |
| } |
| else if (image->bits.format == PIXMAN_a2r10g10b10) |
| { |
| r = ((uint32_t *)bits)[y * WIDTH + x] >> 14; |
| r &= 0xffc0; |
| r |= (r >> 10); |
| } |
| else if (image->bits.format == PIXMAN_a8r8g8b8) |
| { |
| r = ((uint32_t *)bits)[y * WIDTH + x] >> 16; |
| r &= 0xff; |
| r |= r << 8; |
| } |
| else if (image->bits.format == PIXMAN_a4r4g4b4) |
| { |
| r = ((uint16_t *)bits)[y * WIDTH + x] >> 8; |
| r &= 0xf; |
| r |= r << 4; |
| r |= r << 8; |
| } |
| else |
| { |
| assert (0); |
| } |
| |
| return r; |
| } |
| |
| static int |
| run_test (int s, int d, int sa, int da, int soff, int doff) |
| { |
| pixman_format_code_t sf = formats[s]; |
| pixman_format_code_t df = formats[d]; |
| pixman_format_code_t saf = alpha_formats[sa]; |
| pixman_format_code_t daf = alpha_formats[da]; |
| pixman_image_t *src, *dst, *orig_dst, *alpha, *orig_alpha; |
| pixman_transform_t t1; |
| int j, k; |
| int n_alpha_bits, n_red_bits; |
| |
| soff = origins[soff]; |
| doff = origins[doff]; |
| |
| n_alpha_bits = PIXMAN_FORMAT_A (df); |
| if (daf != PIXMAN_null) |
| n_alpha_bits = PIXMAN_FORMAT_A (daf); |
| |
| n_red_bits = PIXMAN_FORMAT_R (df); |
| |
| /* Source */ |
| src = make_image (sf); |
| if (saf != PIXMAN_null) |
| { |
| alpha = make_image (saf); |
| pixman_image_set_alpha_map (src, alpha, soff, soff); |
| pixman_image_unref (alpha); |
| } |
| |
| /* Destination */ |
| orig_dst = make_image (df); |
| dst = make_image (df); |
| pixman_image_composite (PIXMAN_OP_SRC, orig_dst, NULL, dst, |
| 0, 0, 0, 0, 0, 0, WIDTH, HEIGHT); |
| |
| if (daf != PIXMAN_null) |
| { |
| orig_alpha = make_image (daf); |
| alpha = make_image (daf); |
| |
| pixman_image_composite (PIXMAN_OP_SRC, orig_alpha, NULL, alpha, |
| 0, 0, 0, 0, 0, 0, WIDTH, HEIGHT); |
| |
| pixman_image_set_alpha_map (orig_dst, orig_alpha, doff, doff); |
| pixman_image_set_alpha_map (dst, alpha, doff, doff); |
| |
| pixman_image_unref (orig_alpha); |
| pixman_image_unref (alpha); |
| } |
| |
| /* Transformations, repeats and filters on destinations should be ignored, |
| * so just set some random ones. |
| */ |
| pixman_transform_init_identity (&t1); |
| pixman_transform_scale (&t1, NULL, pixman_int_to_fixed (100), pixman_int_to_fixed (11)); |
| pixman_transform_rotate (&t1, NULL, pixman_double_to_fixed (0.5), pixman_double_to_fixed (0.11)); |
| pixman_transform_translate (&t1, NULL, pixman_int_to_fixed (11), pixman_int_to_fixed (17)); |
| |
| pixman_image_set_transform (dst, &t1); |
| pixman_image_set_filter (dst, PIXMAN_FILTER_BILINEAR, NULL, 0); |
| pixman_image_set_repeat (dst, PIXMAN_REPEAT_REFLECT); |
| |
| pixman_image_composite (PIXMAN_OP_ADD, src, NULL, dst, |
| 0, 0, 0, 0, 0, 0, WIDTH, HEIGHT); |
| |
| for (j = MAX (doff, 0); j < MIN (HEIGHT, HEIGHT + doff); ++j) |
| { |
| for (k = MAX (doff, 0); k < MIN (WIDTH, WIDTH + doff); ++k) |
| { |
| uint8_t sa, da, oda, refa; |
| uint16_t sr, dr, odr, refr; |
| |
| sa = get_alpha (src, k, j, soff, soff); |
| da = get_alpha (dst, k, j, doff, doff); |
| oda = get_alpha (orig_dst, k, j, doff, doff); |
| |
| if (sa + oda > 255) |
| refa = 255; |
| else |
| refa = sa + oda; |
| |
| if (da >> (8 - n_alpha_bits) != refa >> (8 - n_alpha_bits)) |
| { |
| printf ("\nWrong alpha value at (%d, %d). Should be 0x%x; got 0x%x. Source was 0x%x, original dest was 0x%x\n", |
| k, j, refa, da, sa, oda); |
| |
| printf ("src: %s, alpha: %s, origin %d %d\ndst: %s, alpha: %s, origin: %d %d\n\n", |
| format_name (sf), |
| format_name (saf), |
| soff, soff, |
| format_name (df), |
| format_name (daf), |
| doff, doff); |
| return 1; |
| } |
| |
| /* There are cases where we go through the 8 bit compositing |
| * path even with 10bpc formats. This results in incorrect |
| * results here, so only do the red check for narrow formats |
| */ |
| if (n_red_bits <= 8) |
| { |
| sr = get_red (src, k, j, soff, soff); |
| dr = get_red (dst, k, j, doff, doff); |
| odr = get_red (orig_dst, k, j, doff, doff); |
| |
| if (sr + odr > 0xffff) |
| refr = 0xffff; |
| else |
| refr = sr + odr; |
| |
| if (abs ((dr >> (16 - n_red_bits)) - (refr >> (16 - n_red_bits))) > 1) |
| { |
| printf ("%d red bits\n", n_red_bits); |
| printf ("\nWrong red value at (%d, %d). Should be 0x%x; got 0x%x. Source was 0x%x, original dest was 0x%x\n", |
| k, j, refr, dr, sr, odr); |
| |
| printf ("src: %s, alpha: %s, origin %d %d\ndst: %s, alpha: %s, origin: %d %d\n\n", |
| format_name (sf), |
| format_name (saf), |
| soff, soff, |
| format_name (df), |
| format_name (daf), |
| doff, doff); |
| return 1; |
| } |
| } |
| } |
| } |
| |
| pixman_image_set_alpha_map (src, NULL, 0, 0); |
| pixman_image_set_alpha_map (dst, NULL, 0, 0); |
| pixman_image_set_alpha_map (orig_dst, NULL, 0, 0); |
| |
| pixman_image_unref (src); |
| pixman_image_unref (dst); |
| pixman_image_unref (orig_dst); |
| |
| return 0; |
| } |
| |
| int |
| main (int argc, char **argv) |
| { |
| int i, j, a, b, x, y; |
| |
| prng_srand (0); |
| |
| for (i = 0; i < ARRAY_LENGTH (formats); ++i) |
| { |
| for (j = 0; j < ARRAY_LENGTH (formats); ++j) |
| { |
| for (a = 0; a < ARRAY_LENGTH (alpha_formats); ++a) |
| { |
| for (b = 0; b < ARRAY_LENGTH (alpha_formats); ++b) |
| { |
| for (x = 0; x < ARRAY_LENGTH (origins); ++x) |
| { |
| for (y = 0; y < ARRAY_LENGTH (origins); ++y) |
| { |
| if (run_test (i, j, a, b, x, y) != 0) |
| return 1; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return 0; |
| } |