File: | test/tolerance-test.c |
Location: | line 215, column 18 |
Description: | Function call argument is an uninitialized value |
1 | #include <assert.h> | |||
2 | #include <stdlib.h> | |||
3 | #include <stdio.h> | |||
4 | #include <float.h> | |||
5 | #include <math.h> | |||
6 | #include "utils.h" | |||
7 | ||||
8 | #define MAX_WIDTH16 16 | |||
9 | #define MAX_HEIGHT16 16 | |||
10 | #define MAX_STRIDE4 4 | |||
11 | ||||
12 | static const pixman_format_code_t formats[] = | |||
13 | { | |||
14 | PIXMAN_a2r10g10b10, | |||
15 | PIXMAN_x2r10g10b10, | |||
16 | PIXMAN_a8r8g8b8, | |||
17 | PIXMAN_a4r4g4b4, | |||
18 | PIXMAN_a2r2g2b2, | |||
19 | PIXMAN_r5g6b5, | |||
20 | PIXMAN_r3g3b2, | |||
21 | }; | |||
22 | ||||
23 | static const pixman_op_t operators[] = | |||
24 | { | |||
25 | PIXMAN_OP_CLEAR, | |||
26 | PIXMAN_OP_SRC, | |||
27 | PIXMAN_OP_DST, | |||
28 | PIXMAN_OP_OVER, | |||
29 | PIXMAN_OP_OVER_REVERSE, | |||
30 | PIXMAN_OP_IN, | |||
31 | PIXMAN_OP_IN_REVERSE, | |||
32 | PIXMAN_OP_OUT, | |||
33 | PIXMAN_OP_OUT_REVERSE, | |||
34 | PIXMAN_OP_ATOP, | |||
35 | PIXMAN_OP_ATOP_REVERSE, | |||
36 | PIXMAN_OP_XOR, | |||
37 | PIXMAN_OP_ADD, | |||
38 | PIXMAN_OP_SATURATE, | |||
39 | ||||
40 | PIXMAN_OP_DISJOINT_CLEAR, | |||
41 | PIXMAN_OP_DISJOINT_SRC, | |||
42 | PIXMAN_OP_DISJOINT_DST, | |||
43 | PIXMAN_OP_DISJOINT_OVER, | |||
44 | PIXMAN_OP_DISJOINT_OVER_REVERSE, | |||
45 | PIXMAN_OP_DISJOINT_IN, | |||
46 | PIXMAN_OP_DISJOINT_IN_REVERSE, | |||
47 | PIXMAN_OP_DISJOINT_OUT, | |||
48 | PIXMAN_OP_DISJOINT_OUT_REVERSE, | |||
49 | PIXMAN_OP_DISJOINT_ATOP, | |||
50 | PIXMAN_OP_DISJOINT_ATOP_REVERSE, | |||
51 | PIXMAN_OP_DISJOINT_XOR, | |||
52 | ||||
53 | PIXMAN_OP_CONJOINT_CLEAR, | |||
54 | PIXMAN_OP_CONJOINT_SRC, | |||
55 | PIXMAN_OP_CONJOINT_DST, | |||
56 | PIXMAN_OP_CONJOINT_OVER, | |||
57 | PIXMAN_OP_CONJOINT_OVER_REVERSE, | |||
58 | PIXMAN_OP_CONJOINT_IN, | |||
59 | PIXMAN_OP_CONJOINT_IN_REVERSE, | |||
60 | PIXMAN_OP_CONJOINT_OUT, | |||
61 | PIXMAN_OP_CONJOINT_OUT_REVERSE, | |||
62 | PIXMAN_OP_CONJOINT_ATOP, | |||
63 | PIXMAN_OP_CONJOINT_ATOP_REVERSE, | |||
64 | PIXMAN_OP_CONJOINT_XOR, | |||
65 | ||||
66 | PIXMAN_OP_MULTIPLY, | |||
67 | PIXMAN_OP_SCREEN, | |||
68 | PIXMAN_OP_OVERLAY, | |||
69 | PIXMAN_OP_DARKEN, | |||
70 | PIXMAN_OP_LIGHTEN, | |||
71 | PIXMAN_OP_COLOR_DODGE, | |||
72 | PIXMAN_OP_COLOR_BURN, | |||
73 | PIXMAN_OP_HARD_LIGHT, | |||
74 | PIXMAN_OP_SOFT_LIGHT, | |||
75 | PIXMAN_OP_DIFFERENCE, | |||
76 | PIXMAN_OP_EXCLUSION, | |||
77 | }; | |||
78 | ||||
79 | #define RANDOM_ELT(array)(array[prng_rand_n (((int) (sizeof (array) / sizeof ((array) [ 0]))))]) \ | |||
80 | (array[prng_rand_n (ARRAY_LENGTH (array)((int) (sizeof (array) / sizeof ((array) [0]))))]) | |||
81 | ||||
82 | static void | |||
83 | free_bits (pixman_image_t *image, void *data) | |||
84 | { | |||
85 | free (image->bits.bits); | |||
86 | } | |||
87 | ||||
88 | static pixman_image_t * | |||
89 | create_image (pixman_image_t **clone) | |||
90 | { | |||
91 | pixman_format_code_t format = RANDOM_ELT (formats)(formats[prng_rand_n (((int) (sizeof (formats) / sizeof ((formats ) [0]))))]); | |||
92 | pixman_image_t *image; | |||
93 | int width = prng_rand_n (MAX_WIDTH16); | |||
94 | int height = prng_rand_n (MAX_HEIGHT16); | |||
95 | int stride = ((width * (PIXMAN_FORMAT_BPP (format)(((format) >> 24) ) / 8)) + 3) & ~3; | |||
96 | uint32_t *bytes = malloc (stride * height); | |||
97 | ||||
98 | prng_randmemset (bytes, stride * height, RANDMEMSET_MORE_00_AND_FF); | |||
99 | ||||
100 | image = pixman_image_create_bits ( | |||
101 | format, width, height, bytes, stride); | |||
102 | ||||
103 | pixman_image_set_destroy_function (image, free_bits, NULL((void*)0)); | |||
104 | ||||
105 | assert (image)(__builtin_expect(!(image), 0) ? __assert_rtn(__func__, "tolerance-test.c" , 105, "image") : (void)0); | |||
106 | ||||
107 | if (clone) | |||
108 | { | |||
109 | uint32_t *bytes_dup = malloc (stride * height); | |||
110 | ||||
111 | memcpy (bytes_dup, bytes, stride * height)__builtin___memcpy_chk (bytes_dup, bytes, stride * height, __builtin_object_size (bytes_dup, 0)); | |||
112 | ||||
113 | *clone = pixman_image_create_bits ( | |||
114 | format, width, height, bytes_dup, stride); | |||
115 | ||||
116 | pixman_image_set_destroy_function (*clone, free_bits, NULL((void*)0)); | |||
117 | } | |||
118 | ||||
119 | return image; | |||
120 | } | |||
121 | ||||
122 | static pixman_bool_t | |||
123 | access (pixman_image_t *image, int x, int y, uint32_t *pixel) | |||
124 | { | |||
125 | int bytes_per_pixel; | |||
126 | int stride; | |||
127 | uint8_t *location; | |||
128 | ||||
129 | if (x < 0 || x >= image->bits.width || y < 0 || y >= image->bits.height) | |||
130 | return FALSE0; | |||
131 | ||||
132 | bytes_per_pixel = PIXMAN_FORMAT_BPP (image->bits.format)(((image->bits.format) >> 24) ) / 8; | |||
133 | stride = image->bits.rowstride * 4; | |||
134 | ||||
135 | location = (uint8_t *)image->bits.bits + y * stride + x * bytes_per_pixel; | |||
136 | ||||
137 | if (bytes_per_pixel == 4) | |||
138 | *pixel = *(uint32_t *)location; | |||
139 | else if (bytes_per_pixel == 2) | |||
140 | *pixel = *(uint16_t *)location; | |||
141 | else if (bytes_per_pixel == 1) | |||
142 | *pixel = *(uint8_t *)location; | |||
143 | else | |||
144 | assert (0)(__builtin_expect(!(0), 0) ? __assert_rtn(__func__, "tolerance-test.c" , 144, "0") : (void)0); | |||
145 | ||||
146 | return TRUE1; | |||
147 | } | |||
148 | ||||
149 | static void | |||
150 | get_color (pixel_checker_t *checker, | |||
151 | pixman_image_t *image, | |||
152 | int x, int y, | |||
153 | color_t *color, | |||
154 | uint32_t *pixel) | |||
155 | { | |||
156 | if (!access (image, x, y, pixel)) | |||
157 | { | |||
158 | color->a = 0.0; | |||
159 | color->r = 0.0; | |||
160 | color->g = 0.0; | |||
161 | color->b = 0.0; | |||
162 | } | |||
163 | else | |||
164 | { | |||
165 | pixel_checker_convert_pixel_to_color ( | |||
166 | checker, *pixel, color); | |||
167 | } | |||
168 | } | |||
169 | ||||
170 | static pixman_bool_t | |||
171 | verify (int test_no, | |||
172 | pixman_op_t op, | |||
173 | pixman_image_t *source, | |||
174 | pixman_image_t *mask, | |||
175 | pixman_image_t *dest, | |||
176 | pixman_image_t *orig_dest, | |||
177 | int x, int y, | |||
178 | int width, int height, | |||
179 | pixman_bool_t component_alpha) | |||
180 | { | |||
181 | pixel_checker_t dest_checker, src_checker, mask_checker; | |||
182 | int i, j; | |||
183 | ||||
184 | pixel_checker_init (&src_checker, source->bits.format); | |||
185 | pixel_checker_init (&dest_checker, dest->bits.format); | |||
186 | pixel_checker_init (&mask_checker, mask->bits.format); | |||
187 | ||||
188 | assert (dest->bits.format == orig_dest->bits.format)(__builtin_expect(!(dest->bits.format == orig_dest->bits .format), 0) ? __assert_rtn(__func__, "tolerance-test.c", 188 , "dest->bits.format == orig_dest->bits.format") : (void )0); | |||
189 | ||||
190 | for (j = y; j < y + height; ++j) | |||
191 | { | |||
192 | for (i = x; i < x + width; ++i) | |||
193 | { | |||
194 | color_t src_color, mask_color, orig_dest_color, result; | |||
195 | uint32_t dest_pixel, orig_dest_pixel, src_pixel, mask_pixel; | |||
196 | ||||
197 | access (dest, i, j, &dest_pixel); | |||
198 | ||||
199 | get_color (&src_checker, | |||
200 | source, i - x, j - y, | |||
201 | &src_color, &src_pixel); | |||
202 | ||||
203 | get_color (&mask_checker, | |||
204 | mask, i - x, j - y, | |||
205 | &mask_color, &mask_pixel); | |||
206 | ||||
207 | get_color (&dest_checker, | |||
208 | orig_dest, i, j, | |||
209 | &orig_dest_color, &orig_dest_pixel); | |||
210 | ||||
211 | do_composite (op, | |||
212 | &src_color, &mask_color, &orig_dest_color, | |||
213 | &result, component_alpha); | |||
214 | ||||
215 | if (!pixel_checker_check (&dest_checker, dest_pixel, &result)) | |||
| ||||
216 | { | |||
217 | int a, r, g, b; | |||
218 | ||||
219 | printf ("--------- Test 0x%x failed ---------\n", test_no); | |||
220 | ||||
221 | printf (" operator: %s (%s alpha)\n", operator_name (op), | |||
222 | component_alpha? "component" : "unified"); | |||
223 | printf (" dest_x, dest_y: %d %d\n", x, y); | |||
224 | printf (" width, height: %d %d\n", width, height); | |||
225 | printf (" source: format: %-14s size: %2d x %2d\n", | |||
226 | format_name (source->bits.format), | |||
227 | source->bits.width, source->bits.height); | |||
228 | printf (" mask: format: %-14s size: %2d x %2d\n", | |||
229 | format_name (mask->bits.format), | |||
230 | mask->bits.width, mask->bits.height); | |||
231 | printf (" dest: format: %-14s size: %2d x %2d\n", | |||
232 | format_name (dest->bits.format), | |||
233 | dest->bits.width, dest->bits.height); | |||
234 | printf (" -- Failed pixel: (%d, %d) --\n", i, j); | |||
235 | printf (" source ARGB: %f %f %f %f (pixel: %x)\n", | |||
236 | src_color.a, src_color.r, src_color.g, src_color.b, | |||
237 | src_pixel); | |||
238 | printf (" mask ARGB: %f %f %f %f (pixel: %x)\n", | |||
239 | mask_color.a, mask_color.r, mask_color.g, mask_color.b, | |||
240 | mask_pixel); | |||
241 | printf (" dest ARGB: %f %f %f %f (pixel: %x)\n", | |||
242 | orig_dest_color.a, orig_dest_color.r, orig_dest_color.g, orig_dest_color.b, | |||
243 | orig_dest_pixel); | |||
244 | printf (" expected ARGB: %f %f %f %f\n", | |||
245 | result.a, result.r, result.g, result.b); | |||
246 | ||||
247 | pixel_checker_get_min (&dest_checker, &result, &a, &r, &g, &b); | |||
248 | printf (" min acceptable: %8d %8d %8d %8d\n", a, r, g, b); | |||
249 | ||||
250 | pixel_checker_split_pixel (&dest_checker, dest_pixel, &a, &r, &g, &b); | |||
251 | printf (" got: %8d %8d %8d %8d (pixel: %x)\n", a, r, g, b, dest_pixel); | |||
252 | ||||
253 | pixel_checker_get_max (&dest_checker, &result, &a, &r, &g, &b); | |||
254 | printf (" max acceptable: %8d %8d %8d %8d\n", a, r, g, b); | |||
255 | printf ("\n"); | |||
256 | printf (" { %s,\n", operator_name (op)); | |||
257 | printf (" PIXMAN_%s,\t0x%x,\n", format_name (source->bits.format), src_pixel); | |||
258 | printf (" PIXMAN_%s,\t0x%x,\n", format_name (mask->bits.format), mask_pixel); | |||
259 | printf (" PIXMAN_%s,\t0x%x\n", format_name (dest->bits.format), orig_dest_pixel); | |||
260 | printf (" },\n"); | |||
261 | return FALSE0; | |||
262 | } | |||
263 | } | |||
264 | } | |||
265 | ||||
266 | return TRUE1; | |||
267 | } | |||
268 | ||||
269 | static pixman_bool_t | |||
270 | do_check (int i) | |||
271 | { | |||
272 | pixman_image_t *source, *dest, *mask; | |||
273 | pixman_op_t op; | |||
274 | int x, y, width, height; | |||
275 | pixman_image_t *dest_copy; | |||
276 | pixman_bool_t result = TRUE1; | |||
277 | pixman_bool_t component_alpha; | |||
278 | ||||
279 | prng_srand (i); | |||
280 | op = RANDOM_ELT (operators)(operators[prng_rand_n (((int) (sizeof (operators) / sizeof ( (operators) [0]))))]); | |||
281 | x = prng_rand_n (MAX_WIDTH16); | |||
282 | y = prng_rand_n (MAX_HEIGHT16); | |||
283 | width = prng_rand_n (MAX_WIDTH16) + 4; | |||
284 | height = prng_rand_n (MAX_HEIGHT16) + 4; | |||
285 | ||||
286 | source = create_image (NULL((void*)0)); | |||
287 | mask = create_image (NULL((void*)0)); | |||
288 | dest = create_image (&dest_copy); | |||
289 | ||||
290 | if (x >= dest->bits.width) | |||
291 | x = dest->bits.width / 2; | |||
292 | if (y >= dest->bits.height) | |||
293 | y = dest->bits.height / 2; | |||
294 | if (x + width > dest->bits.width) | |||
295 | width = dest->bits.width - x; | |||
296 | if (y + height > dest->bits.height) | |||
297 | height = dest->bits.height - y; | |||
298 | ||||
299 | component_alpha = prng_rand_n (2); | |||
300 | ||||
301 | pixman_image_set_component_alpha (mask, component_alpha); | |||
302 | ||||
303 | pixman_image_composite32 (op, source, mask, dest, | |||
304 | 0, 0, 0, 0, | |||
305 | x, y, width, height); | |||
306 | ||||
307 | if (!verify (i, op, source, mask, dest, dest_copy, | |||
308 | x, y, width, height, component_alpha)) | |||
309 | { | |||
310 | result = FALSE0; | |||
311 | } | |||
312 | ||||
313 | pixman_image_unref (source); | |||
314 | pixman_image_unref (mask); | |||
315 | pixman_image_unref (dest); | |||
316 | pixman_image_unref (dest_copy); | |||
317 | ||||
318 | return result; | |||
319 | } | |||
320 | ||||
321 | #define N_TESTS10000000 10000000 | |||
322 | ||||
323 | int | |||
324 | main (int argc, const char *argv[]) | |||
325 | { | |||
326 | int i; | |||
327 | int result = 0; | |||
328 | ||||
329 | if (argc == 2) | |||
| ||||
330 | { | |||
331 | if (strcmp (argv[1], "--forever") == 0) | |||
332 | { | |||
333 | uint32_t n; | |||
334 | ||||
335 | prng_srand (time (0)); | |||
336 | ||||
337 | n = prng_rand(); | |||
338 | ||||
339 | for (;;) | |||
340 | do_check (n++); | |||
341 | } | |||
342 | else | |||
343 | { | |||
344 | do_check (strtol (argv[1], NULL((void*)0), 0)); | |||
345 | } | |||
346 | } | |||
347 | else | |||
348 | { | |||
349 | #ifdef USE_OPENMP | |||
350 | # pragma omp parallel for default(none) reduction(|:result) | |||
351 | #endif | |||
352 | for (i = 0; i < N_TESTS10000000; ++i) | |||
353 | { | |||
354 | if (!do_check (i)) | |||
355 | result |= 1; | |||
356 | } | |||
357 | } | |||
358 | ||||
359 | return result; | |||
360 | } |