nitlanguage / nit.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
nitrpg: fix PlayerXCommits achievement trigger
[nit.git] / share / png / contrib / libtests / pngstest.c
1 /*-
2 * pngstest.c
3 *
4 * Copyright (c) 2013 John Cunningham Bowler
5 *
6 * Last changed in libpng 1.6.8 [December 19, 2013]
7 *
8 * This code is released under the libpng license.
9 * For conditions of distribution and use, see the disclaimer
10 * and license in png.h
11 *
12 * Test for the PNG 'simplified' APIs.
13 */
14 #define _ISOC90_SOURCE 1
15 #define MALLOC_CHECK_ 2/*glibc facility: turn on debugging*/
16
17 #include <stddef.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <stdio.h>
21 #include <errno.h>
22 #include <ctype.h>
23 #include <math.h>
24
25 #if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
26 # include <config.h>
27 #endif
28
29 /* Define the following to use this test against your installed libpng, rather
30 * than the one being built here:
31 */
32 #ifdef PNG_FREESTANDING_TESTS
33 # include <png.h>
34 #else
35 # include "../../png.h"
36 #endif
37
38 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED /* Else nothing can be done */
39 #include "../tools/sRGB.h"
40
41 /* KNOWN ISSUES
42 *
43 * These defines switch on alternate algorithms for format conversions to match
44 * the current libpng implementation; they are set to allow pngstest to pass
45 * even though libpng is producing answers that are not as correct as they
46 * should be.
47 */
48 #define ALLOW_UNUSED_GPC 0
49 /* If true include unused static GPC functions and declare an external array
50 * of them to hide the fact that they are unused. This is for development
51 * use while testing the correct function to use to take into account libpng
52 * misbehavior, such as using a simple power law to correct sRGB to linear.
53 */
54
55 /* The following is to support direct compilation of this file as C++ */
56 #ifdef __cplusplus
57 # define voidcast(type, value) static_cast<type>(value)
58 # define aligncastconst(type, value) \
59 static_cast<type>(static_cast<const void*>(value))
60 #else
61 # define voidcast(type, value) (value)
62 # define aligncastconst(type, value) ((const void*)(value))
63 #endif /* __cplusplus */
64
65 /* During parallel runs of pngstest each temporary file needs a unique name,
66 * this is used to permit uniqueness using a command line argument which can be
67 * up to 22 characters long.
68 */
69 static char tmpf[23] = "TMP";
70
71 /* Generate random bytes. This uses a boring repeatable algorithm and it
72 * is implemented here so that it gives the same set of numbers on every
73 * architecture. It's a linear congruential generator (Knuth or Sedgewick
74 * "Algorithms") but it comes from the 'feedback taps' table in Horowitz and
75 * Hill, "The Art of Electronics".
76 */
77 static void
78 make_random_bytes(png_uint_32* seed, void* pv, size_t size)
79 {
80 png_uint_32 u0 = seed[0], u1 = seed[1];
81 png_bytep bytes = voidcast(png_bytep, pv);
82
83 /* There are thirty three bits, the next bit in the sequence is bit-33 XOR
84 * bit-20. The top 1 bit is in u1, the bottom 32 are in u0.
85 */
86 size_t i;
87 for (i=0; i<size; ++i)
88 {
89 /* First generate 8 new bits then shift them in at the end. */
90 png_uint_32 u = ((u0 >> (20-8)) ^ ((u1 << 7) | (u0 >> (32-7)))) & 0xff;
91 u1 <<= 8;
92 u1 |= u0 >> 24;
93 u0 <<= 8;
94 u0 |= u;
95 *bytes++ = (png_byte)u;
96 }
97
98 seed[0] = u0;
99 seed[1] = u1;
100 }
101
102 static void
103 random_color(png_colorp color)
104 {
105 static png_uint_32 color_seed[2] = { 0x12345678, 0x9abcdef };
106 make_random_bytes(color_seed, color, sizeof *color);
107 }
108
109 /* Math support - neither Cygwin nor Visual Studio have C99 support and we need
110 * a predictable rounding function, so make one here:
111 */
112 static double
113 closestinteger(double x)
114 {
115 return floor(x + .5);
116 }
117
118 /* Cast support: remove GCC whines. */
119 static png_byte
120 u8d(double d)
121 {
122 d = closestinteger(d);
123 return (png_byte)d;
124 }
125
126 static png_uint_16
127 u16d(double d)
128 {
129 d = closestinteger(d);
130 return (png_uint_16)d;
131 }
132
133 /* sRGB support: use exact calculations rounded to the nearest int, see the
134 * fesetround() call in main(). sRGB_to_d optimizes the 8 to 16-bit conversion.
135 */
136 static double sRGB_to_d[256];
137 static double g22_to_d[256];
138
139 static void
140 init_sRGB_to_d(void)
141 {
142 int i;
143
144 sRGB_to_d[0] = 0;
145 for (i=1; i<255; ++i)
146 sRGB_to_d[i] = linear_from_sRGB(i/255.);
147 sRGB_to_d[255] = 1;
148
149 g22_to_d[0] = 0;
150 for (i=1; i<255; ++i)
151 g22_to_d[i] = pow(i/255., 1/.45455);
152 g22_to_d[255] = 1;
153 }
154
155 static png_byte
156 sRGB(double linear /*range 0.0 .. 1.0*/)
157 {
158 return u8d(255 * sRGB_from_linear(linear));
159 }
160
161 static png_byte
162 isRGB(int fixed_linear)
163 {
164 return sRGB(fixed_linear / 65535.);
165 }
166
167 #if 0 /* not used */
168 static png_byte
169 unpremultiply(int component, int alpha)
170 {
171 if (alpha <= component)
172 return 255; /* Arbitrary, but consistent with the libpng code */
173
174 else if (alpha >= 65535)
175 return isRGB(component);
176
177 else
178 return sRGB((double)component / alpha);
179 }
180 #endif
181
182 static png_uint_16
183 ilinear(int fixed_srgb)
184 {
185 return u16d(65535 * sRGB_to_d[fixed_srgb]);
186 }
187
188 static png_uint_16
189 ilineara(int fixed_srgb, int alpha)
190 {
191 return u16d((257 * alpha) * sRGB_to_d[fixed_srgb]);
192 }
193
194 static png_uint_16
195 ilinear_g22(int fixed_srgb)
196 {
197 return u16d(65535 * g22_to_d[fixed_srgb]);
198 }
199
200 #if ALLOW_UNUSED_GPC
201 static png_uint_16
202 ilineara_g22(int fixed_srgb, int alpha)
203 {
204 return u16d((257 * alpha) * g22_to_d[fixed_srgb]);
205 }
206 #endif
207
208 static double
209 YfromRGBint(int ir, int ig, int ib)
210 {
211 double r = ir;
212 double g = ig;
213 double b = ib;
214 return YfromRGB(r, g, b);
215 }
216
217 #if 0 /* unused */
218 /* The error that results from using a 2.2 power law in place of the correct
219 * sRGB transform, given an 8-bit value which might be either sRGB or power-law.
220 */
221 static int
222 power_law_error8(int value)
223 {
224 if (value > 0 && value < 255)
225 {
226 double vd = value / 255.;
227 double e = fabs(
228 pow(sRGB_to_d[value], 1/2.2) - sRGB_from_linear(pow(vd, 2.2)));
229
230 /* Always allow an extra 1 here for rounding errors */
231 e = 1+floor(255 * e);
232 return (int)e;
233 }
234
235 return 0;
236 }
237
238 static int error_in_sRGB_roundtrip = 56; /* by experiment */
239 static int
240 power_law_error16(int value)
241 {
242 if (value > 0 && value < 65535)
243 {
244 /* Round trip the value through an 8-bit representation but using
245 * non-matching to/from conversions.
246 */
247 double vd = value / 65535.;
248 double e = fabs(
249 pow(sRGB_from_linear(vd), 2.2) - linear_from_sRGB(pow(vd, 1/2.2)));
250
251 /* Always allow an extra 1 here for rounding errors */
252 e = error_in_sRGB_roundtrip+floor(65535 * e);
253 return (int)e;
254 }
255
256 return 0;
257 }
258
259 static int
260 compare_8bit(int v1, int v2, int error_limit, int multiple_algorithms)
261 {
262 int e = abs(v1-v2);
263 int ev1, ev2;
264
265 if (e <= error_limit)
266 return 1;
267
268 if (!multiple_algorithms)
269 return 0;
270
271 ev1 = power_law_error8(v1);
272 if (e <= ev1)
273 return 1;
274
275 ev2 = power_law_error8(v2);
276 if (e <= ev2)
277 return 1;
278
279 return 0;
280 }
281
282 static int
283 compare_16bit(int v1, int v2, int error_limit, int multiple_algorithms)
284 {
285 int e = abs(v1-v2);
286 int ev1, ev2;
287
288 if (e <= error_limit)
289 return 1;
290
291 /* "multiple_algorithms" in this case means that a color-map has been
292 * involved somewhere, so we can deduce that the values were forced to 8-bit
293 * (like the via_linear case for 8-bit.)
294 */
295 if (!multiple_algorithms)
296 return 0;
297
298 ev1 = power_law_error16(v1);
299 if (e <= ev1)
300 return 1;
301
302 ev2 = power_law_error16(v2);
303 if (e <= ev2)
304 return 1;
305
306 return 0;
307 }
308 #endif /* unused */
309
310 #define READ_FILE 1 /* else memory */
311 #define USE_STDIO 2 /* else use file name */
312 #define STRICT 4 /* fail on warnings too */
313 #define VERBOSE 8
314 #define KEEP_TMPFILES 16 /* else delete temporary files */
315 #define KEEP_GOING 32
316 #define ACCUMULATE 64
317 #define FAST_WRITE 128
318 #define sRGB_16BIT 256
319
320 static void
321 print_opts(png_uint_32 opts)
322 {
323 if (opts & READ_FILE)
324 printf(" --file");
325 if (opts & USE_STDIO)
326 printf(" --stdio");
327 if (opts & STRICT)
328 printf(" --strict");
329 if (opts & VERBOSE)
330 printf(" --verbose");
331 if (opts & KEEP_TMPFILES)
332 printf(" --preserve");
333 if (opts & KEEP_GOING)
334 printf(" --keep-going");
335 if (opts & ACCUMULATE)
336 printf(" --accumulate");
337 if (!(opts & FAST_WRITE)) /* --fast is currently the default */
338 printf(" --slow");
339 if (opts & sRGB_16BIT)
340 printf(" --sRGB-16bit");
341 }
342
343 #define FORMAT_NO_CHANGE 0x80000000 /* additional flag */
344
345 /* A name table for all the formats - defines the format of the '+' arguments to
346 * pngstest.
347 */
348 #define FORMAT_COUNT 64
349 #define FORMAT_MASK 0x3f
350 static PNG_CONST char * PNG_CONST format_names[FORMAT_COUNT] =
351 {
352 "sRGB-gray",
353 "sRGB-gray+alpha",
354 "sRGB-rgb",
355 "sRGB-rgb+alpha",
356 "linear-gray",
357 "linear-gray+alpha",
358 "linear-rgb",
359 "linear-rgb+alpha",
360
361 "color-mapped-sRGB-gray",
362 "color-mapped-sRGB-gray+alpha",
363 "color-mapped-sRGB-rgb",
364 "color-mapped-sRGB-rgb+alpha",
365 "color-mapped-linear-gray",
366 "color-mapped-linear-gray+alpha",
367 "color-mapped-linear-rgb",
368 "color-mapped-linear-rgb+alpha",
369
370 "sRGB-gray",
371 "sRGB-gray+alpha",
372 "sRGB-bgr",
373 "sRGB-bgr+alpha",
374 "linear-gray",
375 "linear-gray+alpha",
376 "linear-bgr",
377 "linear-bgr+alpha",
378
379 "color-mapped-sRGB-gray",
380 "color-mapped-sRGB-gray+alpha",
381 "color-mapped-sRGB-bgr",
382 "color-mapped-sRGB-bgr+alpha",
383 "color-mapped-linear-gray",
384 "color-mapped-linear-gray+alpha",
385 "color-mapped-linear-bgr",
386 "color-mapped-linear-bgr+alpha",
387
388 "sRGB-gray",
389 "alpha+sRGB-gray",
390 "sRGB-rgb",
391 "alpha+sRGB-rgb",
392 "linear-gray",
393 "alpha+linear-gray",
394 "linear-rgb",
395 "alpha+linear-rgb",
396
397 "color-mapped-sRGB-gray",
398 "color-mapped-alpha+sRGB-gray",
399 "color-mapped-sRGB-rgb",
400 "color-mapped-alpha+sRGB-rgb",
401 "color-mapped-linear-gray",
402 "color-mapped-alpha+linear-gray",
403 "color-mapped-linear-rgb",
404 "color-mapped-alpha+linear-rgb",
405
406 "sRGB-gray",
407 "alpha+sRGB-gray",
408 "sRGB-bgr",
409 "alpha+sRGB-bgr",
410 "linear-gray",
411 "alpha+linear-gray",
412 "linear-bgr",
413 "alpha+linear-bgr",
414
415 "color-mapped-sRGB-gray",
416 "color-mapped-alpha+sRGB-gray",
417 "color-mapped-sRGB-bgr",
418 "color-mapped-alpha+sRGB-bgr",
419 "color-mapped-linear-gray",
420 "color-mapped-alpha+linear-gray",
421 "color-mapped-linear-bgr",
422 "color-mapped-alpha+linear-bgr",
423 };
424
425 /* Decode an argument to a format number. */
426 static png_uint_32
427 formatof(const char *arg)
428 {
429 char *ep;
430 unsigned long format = strtoul(arg, &ep, 0);
431
432 if (ep > arg && *ep == 0 && format < FORMAT_COUNT)
433 return (png_uint_32)format;
434
435 else for (format=0; format < FORMAT_COUNT; ++format)
436 {
437 if (strcmp(format_names[format], arg) == 0)
438 return (png_uint_32)format;
439 }
440
441 fprintf(stderr, "pngstest: format name '%s' invalid\n", arg);
442 return FORMAT_COUNT;
443 }
444
445 /* Bitset/test functions for formats */
446 #define FORMAT_SET_COUNT (FORMAT_COUNT / 32)
447 typedef struct
448 {
449 png_uint_32 bits[FORMAT_SET_COUNT];
450 }
451 format_list;
452
453 static void format_init(format_list *pf)
454 {
455 int i;
456 for (i=0; i<FORMAT_SET_COUNT; ++i)
457 pf->bits[i] = 0; /* All off */
458 }
459
460 #if 0 /* currently unused */
461 static void format_clear(format_list *pf)
462 {
463 int i;
464 for (i=0; i<FORMAT_SET_COUNT; ++i)
465 pf->bits[i] = 0;
466 }
467 #endif
468
469 static int format_is_initial(format_list *pf)
470 {
471 int i;
472 for (i=0; i<FORMAT_SET_COUNT; ++i)
473 if (pf->bits[i] != 0)
474 return 0;
475
476 return 1;
477 }
478
479 static int format_set(format_list *pf, png_uint_32 format)
480 {
481 if (format < FORMAT_COUNT)
482 return pf->bits[format >> 5] |= ((png_uint_32)1) << (format & 31);
483
484 return 0;
485 }
486
487 #if 0 /* currently unused */
488 static int format_unset(format_list *pf, png_uint_32 format)
489 {
490 if (format < FORMAT_COUNT)
491 return pf->bits[format >> 5] &= ~((png_uint_32)1) << (format & 31);
492
493 return 0;
494 }
495 #endif
496
497 static int format_isset(format_list *pf, png_uint_32 format)
498 {
499 return format < FORMAT_COUNT &&
500 (pf->bits[format >> 5] & (((png_uint_32)1) << (format & 31))) != 0;
501 }
502
503 static void format_default(format_list *pf, int redundant)
504 {
505 if (redundant)
506 {
507 int i;
508
509 /* set everything, including flags that are pointless */
510 for (i=0; i<FORMAT_SET_COUNT; ++i)
511 pf->bits[i] = ~(png_uint_32)0;
512 }
513
514 else
515 {
516 png_uint_32 f;
517
518 for (f=0; f<FORMAT_COUNT; ++f)
519 {
520 /* Eliminate redundant and unsupported settings. */
521 # ifdef PNG_FORMAT_BGR_SUPPORTED
522 /* BGR is meaningless if no color: */
523 if ((f & PNG_FORMAT_FLAG_COLOR) == 0 &&
524 (f & PNG_FORMAT_FLAG_BGR) != 0)
525 # else
526 if ((f & 0x10U/*HACK: fixed value*/) != 0)
527 # endif
528 continue;
529
530 /* AFIRST is meaningless if no alpha: */
531 # ifdef PNG_FORMAT_AFIRST_SUPPORTED
532 if ((f & PNG_FORMAT_FLAG_ALPHA) == 0 &&
533 (f & PNG_FORMAT_FLAG_AFIRST) != 0)
534 # else
535 if ((f & 0x20U/*HACK: fixed value*/) != 0)
536 # endif
537 continue;
538
539 format_set(pf, f);
540 }
541 }
542 }
543
544 /* THE Image STRUCTURE */
545 /* The super-class of a png_image, contains the decoded image plus the input
546 * data necessary to re-read the file with a different format.
547 */
548 typedef struct
549 {
550 png_image image;
551 png_uint_32 opts;
552 const char *file_name;
553 int stride_extra;
554 FILE *input_file;
555 png_voidp input_memory;
556 png_size_t input_memory_size;
557 png_bytep buffer;
558 ptrdiff_t stride;
559 png_size_t bufsize;
560 png_size_t allocsize;
561 char tmpfile_name[32];
562 png_uint_16 colormap[256*4];
563 }
564 Image;
565
566 /* Initializer: also sets the permitted error limit for 16-bit operations. */
567 static void
568 newimage(Image *image)
569 {
570 memset(image, 0, sizeof *image);
571 }
572
573 /* Reset the image to be read again - only needs to rewind the FILE* at present.
574 */
575 static void
576 resetimage(Image *image)
577 {
578 if (image->input_file != NULL)
579 rewind(image->input_file);
580 }
581
582 /* Free the image buffer; the buffer is re-used on a re-read, this is just for
583 * cleanup.
584 */
585 static void
586 freebuffer(Image *image)
587 {
588 if (image->buffer) free(image->buffer);
589 image->buffer = NULL;
590 image->bufsize = 0;
591 image->allocsize = 0;
592 }
593
594 /* Delete function; cleans out all the allocated data and the temporary file in
595 * the image.
596 */
597 static void
598 freeimage(Image *image)
599 {
600 freebuffer(image);
601 png_image_free(&image->image);
602
603 if (image->input_file != NULL)
604 {
605 fclose(image->input_file);
606 image->input_file = NULL;
607 }
608
609 if (image->input_memory != NULL)
610 {
611 free(image->input_memory);
612 image->input_memory = NULL;
613 image->input_memory_size = 0;
614 }
615
616 if (image->tmpfile_name[0] != 0 && (image->opts & KEEP_TMPFILES) == 0)
617 {
618 remove(image->tmpfile_name);
619 image->tmpfile_name[0] = 0;
620 }
621 }
622
623 /* This is actually a re-initializer; allows an image structure to be re-used by
624 * freeing everything that relates to an old image.
625 */
626 static void initimage(Image *image, png_uint_32 opts, const char *file_name,
627 int stride_extra)
628 {
629 freeimage(image);
630 memset(&image->image, 0, sizeof image->image);
631 image->opts = opts;
632 image->file_name = file_name;
633 image->stride_extra = stride_extra;
634 }
635
636 /* Make sure the image buffer is big enough; allows re-use of the buffer if the
637 * image is re-read.
638 */
639 #define BUFFER_INIT8 73
640 static void
641 allocbuffer(Image *image)
642 {
643 png_size_t size = PNG_IMAGE_BUFFER_SIZE(image->image, image->stride);
644
645 if (size+32 > image->bufsize)
646 {
647 freebuffer(image);
648 image->buffer = voidcast(png_bytep, malloc(size+32));
649 if (image->buffer == NULL)
650 {
651 fflush(stdout);
652 fprintf(stderr,
653 "simpletest: out of memory allocating %lu(+32) byte buffer\n",
654 (unsigned long)size);
655 exit(1);
656 }
657 image->bufsize = size+32;
658 }
659
660 memset(image->buffer, 95, image->bufsize);
661 memset(image->buffer+16, BUFFER_INIT8, size);
662 image->allocsize = size;
663 }
664
665 /* Make sure 16 bytes match the given byte. */
666 static int
667 check16(png_const_bytep bp, int b)
668 {
669 int i = 16;
670
671 do
672 if (*bp != b) return 1;
673 while (--i);
674
675 return 0;
676 }
677
678 /* Check for overwrite in the image buffer. */
679 static void
680 checkbuffer(Image *image, const char *arg)
681 {
682 if (check16(image->buffer, 95))
683 {
684 fflush(stdout);
685 fprintf(stderr, "%s: overwrite at start of image buffer\n", arg);
686 exit(1);
687 }
688
689 if (check16(image->buffer+16+image->allocsize, 95))
690 {
691 fflush(stdout);
692 fprintf(stderr, "%s: overwrite at end of image buffer\n", arg);
693 exit(1);
694 }
695 }
696
697 /* ERROR HANDLING */
698 /* Log a terminal error, also frees the libpng part of the image if necessary.
699 */
700 static int
701 logerror(Image *image, const char *a1, const char *a2, const char *a3)
702 {
703 fflush(stdout);
704 if (image->image.warning_or_error)
705 fprintf(stderr, "%s%s%s: %s\n", a1, a2, a3, image->image.message);
706
707 else
708 fprintf(stderr, "%s%s%s\n", a1, a2, a3);
709
710 if (image->image.opaque != NULL)
711 {
712 fprintf(stderr, "%s: image opaque pointer non-NULL on error\n",
713 image->file_name);
714 png_image_free(&image->image);
715 }
716
717 return 0;
718 }
719
720 /* Log an error and close a file (just a utility to do both things in one
721 * function call.)
722 */
723 static int
724 logclose(Image *image, FILE *f, const char *name, const char *operation)
725 {
726 int e = errno;
727
728 fclose(f);
729 return logerror(image, name, operation, strerror(e));
730 }
731
732 /* Make sure the png_image has been freed - validates that libpng is doing what
733 * the spec says and freeing the image.
734 */
735 static int
736 checkopaque(Image *image)
737 {
738 if (image->image.opaque != NULL)
739 {
740 png_image_free(&image->image);
741 return logerror(image, image->file_name, ": opaque not NULL", "");
742 }
743
744 else if (image->image.warning_or_error != 0 && (image->opts & STRICT) != 0)
745 return logerror(image, image->file_name, " --strict", "");
746
747 else
748 return 1;
749 }
750
751 /* IMAGE COMPARISON/CHECKING */
752 /* Compare the pixels of two images, which should be the same but aren't. The
753 * images must have been checked for a size match.
754 */
755 typedef struct
756 {
757 /* The components, for grayscale images the gray value is in 'g' and if alpha
758 * is not present 'a' is set to 255 or 65535 according to format.
759 */
760 int r, g, b, a;
761 } Pixel;
762
763 typedef struct
764 {
765 /* The background as the original sRGB 8-bit value converted to the final
766 * integer format and as a double precision linear value in the range 0..1
767 * for with partially transparent pixels.
768 */
769 int ir, ig, ib;
770 double dr, dg, db; /* linear r,g,b scaled to 0..1 */
771 } Background;
772
773 /* Basic image formats; control the data but not the layout thereof. */
774 #define BASE_FORMATS\
775 (PNG_FORMAT_FLAG_ALPHA|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_LINEAR)
776
777 /* Read a Pixel from a buffer. The code below stores the correct routine for
778 * the format in a function pointer, these are the routines:
779 */
780 static void
781 gp_g8(Pixel *p, png_const_voidp pb)
782 {
783 png_const_bytep pp = voidcast(png_const_bytep, pb);
784
785 p->r = p->g = p->b = pp[0];
786 p->a = 255;
787 }
788
789 static void
790 gp_ga8(Pixel *p, png_const_voidp pb)
791 {
792 png_const_bytep pp = voidcast(png_const_bytep, pb);
793
794 p->r = p->g = p->b = pp[0];
795 p->a = pp[1];
796 }
797
798 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
799 static void
800 gp_ag8(Pixel *p, png_const_voidp pb)
801 {
802 png_const_bytep pp = voidcast(png_const_bytep, pb);
803
804 p->r = p->g = p->b = pp[1];
805 p->a = pp[0];
806 }
807 #endif
808
809 static void
810 gp_rgb8(Pixel *p, png_const_voidp pb)
811 {
812 png_const_bytep pp = voidcast(png_const_bytep, pb);
813
814 p->r = pp[0];
815 p->g = pp[1];
816 p->b = pp[2];
817 p->a = 255;
818 }
819
820 #ifdef PNG_FORMAT_BGR_SUPPORTED
821 static void
822 gp_bgr8(Pixel *p, png_const_voidp pb)
823 {
824 png_const_bytep pp = voidcast(png_const_bytep, pb);
825
826 p->r = pp[2];
827 p->g = pp[1];
828 p->b = pp[0];
829 p->a = 255;
830 }
831 #endif
832
833 static void
834 gp_rgba8(Pixel *p, png_const_voidp pb)
835 {
836 png_const_bytep pp = voidcast(png_const_bytep, pb);
837
838 p->r = pp[0];
839 p->g = pp[1];
840 p->b = pp[2];
841 p->a = pp[3];
842 }
843
844 #ifdef PNG_FORMAT_BGR_SUPPORTED
845 static void
846 gp_bgra8(Pixel *p, png_const_voidp pb)
847 {
848 png_const_bytep pp = voidcast(png_const_bytep, pb);
849
850 p->r = pp[2];
851 p->g = pp[1];
852 p->b = pp[0];
853 p->a = pp[3];
854 }
855 #endif
856
857 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
858 static void
859 gp_argb8(Pixel *p, png_const_voidp pb)
860 {
861 png_const_bytep pp = voidcast(png_const_bytep, pb);
862
863 p->r = pp[1];
864 p->g = pp[2];
865 p->b = pp[3];
866 p->a = pp[0];
867 }
868 #endif
869
870 #if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED)
871 static void
872 gp_abgr8(Pixel *p, png_const_voidp pb)
873 {
874 png_const_bytep pp = voidcast(png_const_bytep, pb);
875
876 p->r = pp[3];
877 p->g = pp[2];
878 p->b = pp[1];
879 p->a = pp[0];
880 }
881 #endif
882
883 static void
884 gp_g16(Pixel *p, png_const_voidp pb)
885 {
886 png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
887
888 p->r = p->g = p->b = pp[0];
889 p->a = 65535;
890 }
891
892 static void
893 gp_ga16(Pixel *p, png_const_voidp pb)
894 {
895 png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
896
897 p->r = p->g = p->b = pp[0];
898 p->a = pp[1];
899 }
900
901 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
902 static void
903 gp_ag16(Pixel *p, png_const_voidp pb)
904 {
905 png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
906
907 p->r = p->g = p->b = pp[1];
908 p->a = pp[0];
909 }
910 #endif
911
912 static void
913 gp_rgb16(Pixel *p, png_const_voidp pb)
914 {
915 png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
916
917 p->r = pp[0];
918 p->g = pp[1];
919 p->b = pp[2];
920 p->a = 65535;
921 }
922
923 #ifdef PNG_FORMAT_BGR_SUPPORTED
924 static void
925 gp_bgr16(Pixel *p, png_const_voidp pb)
926 {
927 png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
928
929 p->r = pp[2];
930 p->g = pp[1];
931 p->b = pp[0];
932 p->a = 65535;
933 }
934 #endif
935
936 static void
937 gp_rgba16(Pixel *p, png_const_voidp pb)
938 {
939 png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
940
941 p->r = pp[0];
942 p->g = pp[1];
943 p->b = pp[2];
944 p->a = pp[3];
945 }
946
947 #ifdef PNG_FORMAT_BGR_SUPPORTED
948 static void
949 gp_bgra16(Pixel *p, png_const_voidp pb)
950 {
951 png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
952
953 p->r = pp[2];
954 p->g = pp[1];
955 p->b = pp[0];
956 p->a = pp[3];
957 }
958 #endif
959
960 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
961 static void
962 gp_argb16(Pixel *p, png_const_voidp pb)
963 {
964 png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
965
966 p->r = pp[1];
967 p->g = pp[2];
968 p->b = pp[3];
969 p->a = pp[0];
970 }
971 #endif
972
973 #if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED)
974 static void
975 gp_abgr16(Pixel *p, png_const_voidp pb)
976 {
977 png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
978
979 p->r = pp[3];
980 p->g = pp[2];
981 p->b = pp[1];
982 p->a = pp[0];
983 }
984 #endif
985
986 /* Given a format, return the correct one of the above functions. */
987 static void (*
988 get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb)
989 {
990 /* The color-map flag is irrelevant here - the caller of the function
991 * returned must either pass the buffer or, for a color-mapped image, the
992 * correct entry in the color-map.
993 */
994 if (format & PNG_FORMAT_FLAG_LINEAR)
995 {
996 if (format & PNG_FORMAT_FLAG_COLOR)
997 {
998 # ifdef PNG_FORMAT_BGR_SUPPORTED
999 if (format & PNG_FORMAT_FLAG_BGR)
1000 {
1001 if (format & PNG_FORMAT_FLAG_ALPHA)
1002 {
1003 # ifdef PNG_FORMAT_AFIRST_SUPPORTED
1004 if (format & PNG_FORMAT_FLAG_AFIRST)
1005 return gp_abgr16;
1006
1007 else
1008 # endif
1009 return gp_bgra16;
1010 }
1011
1012 else
1013 return gp_bgr16;
1014 }
1015
1016 else
1017 # endif
1018 {
1019 if (format & PNG_FORMAT_FLAG_ALPHA)
1020 {
1021 # ifdef PNG_FORMAT_AFIRST_SUPPORTED
1022 if (format & PNG_FORMAT_FLAG_AFIRST)
1023 return gp_argb16;
1024
1025 else
1026 # endif
1027 return gp_rgba16;
1028 }
1029
1030 else
1031 return gp_rgb16;
1032 }
1033 }
1034
1035 else
1036 {
1037 if (format & PNG_FORMAT_FLAG_ALPHA)
1038 {
1039 # ifdef PNG_FORMAT_AFIRST_SUPPORTED
1040 if (format & PNG_FORMAT_FLAG_AFIRST)
1041 return gp_ag16;
1042
1043 else
1044 # endif
1045 return gp_ga16;
1046 }
1047
1048 else
1049 return gp_g16;
1050 }
1051 }
1052
1053 else
1054 {
1055 if (format & PNG_FORMAT_FLAG_COLOR)
1056 {
1057 # ifdef PNG_FORMAT_BGR_SUPPORTED
1058 if (format & PNG_FORMAT_FLAG_BGR)
1059 {
1060 if (format & PNG_FORMAT_FLAG_ALPHA)
1061 {
1062 # ifdef PNG_FORMAT_AFIRST_SUPPORTED
1063 if (format & PNG_FORMAT_FLAG_AFIRST)
1064 return gp_abgr8;
1065
1066 else
1067 # endif
1068 return gp_bgra8;
1069 }
1070
1071 else
1072 return gp_bgr8;
1073 }
1074
1075 else
1076 # endif
1077 {
1078 if (format & PNG_FORMAT_FLAG_ALPHA)
1079 {
1080 # ifdef PNG_FORMAT_AFIRST_SUPPORTED
1081 if (format & PNG_FORMAT_FLAG_AFIRST)
1082 return gp_argb8;
1083
1084 else
1085 # endif
1086 return gp_rgba8;
1087 }
1088
1089 else
1090 return gp_rgb8;
1091 }
1092 }
1093
1094 else
1095 {
1096 if (format & PNG_FORMAT_FLAG_ALPHA)
1097 {
1098 # ifdef PNG_FORMAT_AFIRST_SUPPORTED
1099 if (format & PNG_FORMAT_FLAG_AFIRST)
1100 return gp_ag8;
1101
1102 else
1103 # endif
1104 return gp_ga8;
1105 }
1106
1107 else
1108 return gp_g8;
1109 }
1110 }
1111 }
1112
1113 /* Convertion between pixel formats. The code above effectively eliminates the
1114 * component ordering changes leaving three basic changes:
1115 *
1116 * 1) Remove an alpha channel by pre-multiplication or compositing on a
1117 * background color. (Adding an alpha channel is a no-op.)
1118 *
1119 * 2) Remove color by mapping to grayscale. (Grayscale to color is a no-op.)
1120 *
1121 * 3) Convert between 8-bit and 16-bit components. (Both directtions are
1122 * relevant.)
1123 *
1124 * This gives the following base format conversion matrix:
1125 *
1126 * OUT: ----- 8-bit ----- ----- 16-bit -----
1127 * IN G GA RGB RGBA G GA RGB RGBA
1128 * 8 G . . . . lin lin lin lin
1129 * 8 GA bckg . bckc . pre' pre pre' pre
1130 * 8 RGB g8 g8 . . glin glin lin lin
1131 * 8 RGBA g8b g8 bckc . gpr' gpre pre' pre
1132 * 16 G sRGB sRGB sRGB sRGB . . . .
1133 * 16 GA b16g unpg b16c unpc A . A .
1134 * 16 RGB sG sG sRGB sRGB g16 g16 . .
1135 * 16 RGBA gb16 sGp cb16 sCp g16 g16' A .
1136 *
1137 * 8-bit to 8-bit:
1138 * bckg: composite on gray background
1139 * bckc: composite on color background
1140 * g8: convert sRGB components to sRGB grayscale
1141 * g8b: convert sRGB components to grayscale and composite on gray background
1142 *
1143 * 8-bit to 16-bit:
1144 * lin: make sRGB components linear, alpha := 65535
1145 * pre: make sRGB components linear and premultiply by alpha (scale alpha)
1146 * pre': as 'pre' but alpha := 65535
1147 * glin: make sRGB components linear, convert to grayscale, alpha := 65535
1148 * gpre: make sRGB components grayscale and linear and premultiply by alpha
1149 * gpr': as 'gpre' but alpha := 65535
1150 *
1151 * 16-bit to 8-bit:
1152 * sRGB: convert linear components to sRGB, alpha := 255
1153 * unpg: unpremultiply gray component and convert to sRGB (scale alpha)
1154 * unpc: unpremultiply color components and convert to sRGB (scale alpha)
1155 * b16g: composite linear onto gray background and convert the result to sRGB
1156 * b16c: composite linear onto color background and convert the result to sRGB
1157 * sG: convert linear RGB to sRGB grayscale
1158 * sGp: unpremultiply RGB then convert to sRGB grayscale
1159 * sCp: unpremultiply RGB then convert to sRGB
1160 * gb16: composite linear onto background and convert to sRGB grayscale
1161 * (order doesn't matter, the composite and grayscale operations permute)
1162 * cb16: composite linear onto background and convert to sRGB
1163 *
1164 * 16-bit to 16-bit:
1165 * A: set alpha to 65535
1166 * g16: convert linear RGB to linear grayscale (alpha := 65535)
1167 * g16': as 'g16' but alpha is unchanged
1168 */
1169 /* Simple copy: */
1170 static void
1171 gpc_noop(Pixel *out, const Pixel *in, const Background *back)
1172 {
1173 (void)back;
1174 out->r = in->r;
1175 out->g = in->g;
1176 out->b = in->b;
1177 out->a = in->a;
1178 }
1179
1180 #if ALLOW_UNUSED_GPC
1181 static void
1182 gpc_nop8(Pixel *out, const Pixel *in, const Background *back)
1183 {
1184 (void)back;
1185 if (in->a == 0)
1186 out->r = out->g = out->b = 255;
1187
1188 else
1189 {
1190 out->r = in->r;
1191 out->g = in->g;
1192 out->b = in->b;
1193 }
1194
1195 out->a = in->a;
1196 }
1197 #endif
1198
1199 #if ALLOW_UNUSED_GPC
1200 static void
1201 gpc_nop6(Pixel *out, const Pixel *in, const Background *back)
1202 {
1203 (void)back;
1204 if (in->a == 0)
1205 out->r = out->g = out->b = 65535;
1206
1207 else
1208 {
1209 out->r = in->r;
1210 out->g = in->g;
1211 out->b = in->b;
1212 }
1213
1214 out->a = in->a;
1215 }
1216 #endif
1217
1218 /* 8-bit to 8-bit conversions */
1219 /* bckg: composite on gray background */
1220 static void
1221 gpc_bckg(Pixel *out, const Pixel *in, const Background *back)
1222 {
1223 if (in->a <= 0)
1224 out->r = out->g = out->b = back->ig;
1225
1226 else if (in->a >= 255)
1227 out->r = out->g = out->b = in->g;
1228
1229 else
1230 {
1231 double a = in->a / 255.;
1232
1233 out->r = out->g = out->b = sRGB(sRGB_to_d[in->g] * a + back->dg * (1-a));
1234 }
1235
1236 out->a = 255;
1237 }
1238
1239 /* bckc: composite on color background */
1240 static void
1241 gpc_bckc(Pixel *out, const Pixel *in, const Background *back)
1242 {
1243 if (in->a <= 0)
1244 {
1245 out->r = back->ir;
1246 out->g = back->ig;
1247 out->b = back->ib;
1248 }
1249
1250 else if (in->a >= 255)
1251 {
1252 out->r = in->r;
1253 out->g = in->g;
1254 out->b = in->b;
1255 }
1256
1257 else
1258 {
1259 double a = in->a / 255.;
1260
1261 out->r = sRGB(sRGB_to_d[in->r] * a + back->dr * (1-a));
1262 out->g = sRGB(sRGB_to_d[in->g] * a + back->dg * (1-a));
1263 out->b = sRGB(sRGB_to_d[in->b] * a + back->db * (1-a));
1264 }
1265
1266 out->a = 255;
1267 }
1268
1269 /* g8: convert sRGB components to sRGB grayscale */
1270 static void
1271 gpc_g8(Pixel *out, const Pixel *in, const Background *back)
1272 {
1273 (void)back;
1274
1275 if (in->r == in->g && in->g == in->b)
1276 out->r = out->g = out->b = in->g;
1277
1278 else
1279 out->r = out->g = out->b =
1280 sRGB(YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1281
1282 out->a = in->a;
1283 }
1284
1285 /* g8b: convert sRGB components to grayscale and composite on gray background */
1286 static void
1287 gpc_g8b(Pixel *out, const Pixel *in, const Background *back)
1288 {
1289 if (in->a <= 0)
1290 out->r = out->g = out->b = back->ig;
1291
1292 else if (in->a >= 255)
1293 {
1294 if (in->r == in->g && in->g == in->b)
1295 out->r = out->g = out->b = in->g;
1296
1297 else
1298 out->r = out->g = out->b = sRGB(YfromRGB(
1299 sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1300 }
1301
1302 else
1303 {
1304 double a = in->a/255.;
1305
1306 out->r = out->g = out->b = sRGB(a * YfromRGB(sRGB_to_d[in->r],
1307 sRGB_to_d[in->g], sRGB_to_d[in->b]) + back->dg * (1-a));
1308 }
1309
1310 out->a = 255;
1311 }
1312
1313 /* 8-bit to 16-bit conversions */
1314 /* lin: make sRGB components linear, alpha := 65535 */
1315 static void
1316 gpc_lin(Pixel *out, const Pixel *in, const Background *back)
1317 {
1318 (void)back;
1319
1320 out->r = ilinear(in->r);
1321
1322 if (in->g == in->r)
1323 {
1324 out->g = out->r;
1325
1326 if (in->b == in->r)
1327 out->b = out->r;
1328
1329 else
1330 out->b = ilinear(in->b);
1331 }
1332
1333 else
1334 {
1335 out->g = ilinear(in->g);
1336
1337 if (in->b == in->r)
1338 out->b = out->r;
1339
1340 else if (in->b == in->g)
1341 out->b = out->g;
1342
1343 else
1344 out->b = ilinear(in->b);
1345 }
1346
1347 out->a = 65535;
1348 }
1349
1350 /* pre: make sRGB components linear and premultiply by alpha (scale alpha) */
1351 static void
1352 gpc_pre(Pixel *out, const Pixel *in, const Background *back)
1353 {
1354 (void)back;
1355
1356 out->r = ilineara(in->r, in->a);
1357
1358 if (in->g == in->r)
1359 {
1360 out->g = out->r;
1361
1362 if (in->b == in->r)
1363 out->b = out->r;
1364
1365 else
1366 out->b = ilineara(in->b, in->a);
1367 }
1368
1369 else
1370 {
1371 out->g = ilineara(in->g, in->a);
1372
1373 if (in->b == in->r)
1374 out->b = out->r;
1375
1376 else if (in->b == in->g)
1377 out->b = out->g;
1378
1379 else
1380 out->b = ilineara(in->b, in->a);
1381 }
1382
1383 out->a = in->a * 257;
1384 }
1385
1386 /* pre': as 'pre' but alpha := 65535 */
1387 static void
1388 gpc_preq(Pixel *out, const Pixel *in, const Background *back)
1389 {
1390 (void)back;
1391
1392 out->r = ilineara(in->r, in->a);
1393
1394 if (in->g == in->r)
1395 {
1396 out->g = out->r;
1397
1398 if (in->b == in->r)
1399 out->b = out->r;
1400
1401 else
1402 out->b = ilineara(in->b, in->a);
1403 }
1404
1405 else
1406 {
1407 out->g = ilineara(in->g, in->a);
1408
1409 if (in->b == in->r)
1410 out->b = out->r;
1411
1412 else if (in->b == in->g)
1413 out->b = out->g;
1414
1415 else
1416 out->b = ilineara(in->b, in->a);
1417 }
1418
1419 out->a = 65535;
1420 }
1421
1422 /* glin: make sRGB components linear, convert to grayscale, alpha := 65535 */
1423 static void
1424 gpc_glin(Pixel *out, const Pixel *in, const Background *back)
1425 {
1426 (void)back;
1427
1428 if (in->r == in->g && in->g == in->b)
1429 out->r = out->g = out->b = ilinear(in->g);
1430
1431 else
1432 out->r = out->g = out->b = u16d(65535 *
1433 YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1434
1435 out->a = 65535;
1436 }
1437
1438 /* gpre: make sRGB components grayscale and linear and premultiply by alpha */
1439 static void
1440 gpc_gpre(Pixel *out, const Pixel *in, const Background *back)
1441 {
1442 (void)back;
1443
1444 if (in->r == in->g && in->g == in->b)
1445 out->r = out->g = out->b = ilineara(in->g, in->a);
1446
1447 else
1448 out->r = out->g = out->b = u16d(in->a * 257 *
1449 YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1450
1451 out->a = 257 * in->a;
1452 }
1453
1454 /* gpr': as 'gpre' but alpha := 65535 */
1455 static void
1456 gpc_gprq(Pixel *out, const Pixel *in, const Background *back)
1457 {
1458 (void)back;
1459
1460 if (in->r == in->g && in->g == in->b)
1461 out->r = out->g = out->b = ilineara(in->g, in->a);
1462
1463 else
1464 out->r = out->g = out->b = u16d(in->a * 257 *
1465 YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1466
1467 out->a = 65535;
1468 }
1469
1470 /* 8-bit to 16-bit conversions for gAMA 45455 encoded values */
1471 /* Lin: make gAMA 45455 components linear, alpha := 65535 */
1472 static void
1473 gpc_Lin(Pixel *out, const Pixel *in, const Background *back)
1474 {
1475 (void)back;
1476
1477 out->r = ilinear_g22(in->r);
1478
1479 if (in->g == in->r)
1480 {
1481 out->g = out->r;
1482
1483 if (in->b == in->r)
1484 out->b = out->r;
1485
1486 else
1487 out->b = ilinear_g22(in->b);
1488 }
1489
1490 else
1491 {
1492 out->g = ilinear_g22(in->g);
1493
1494 if (in->b == in->r)
1495 out->b = out->r;
1496
1497 else if (in->b == in->g)
1498 out->b = out->g;
1499
1500 else
1501 out->b = ilinear_g22(in->b);
1502 }
1503
1504 out->a = 65535;
1505 }
1506
1507 #if ALLOW_UNUSED_GPC
1508 /* Pre: make gAMA 45455 components linear and premultiply by alpha (scale alpha)
1509 */
1510 static void
1511 gpc_Pre(Pixel *out, const Pixel *in, const Background *back)
1512 {
1513 (void)back;
1514
1515 out->r = ilineara_g22(in->r, in->a);
1516
1517 if (in->g == in->r)
1518 {
1519 out->g = out->r;
1520
1521 if (in->b == in->r)
1522 out->b = out->r;
1523
1524 else
1525 out->b = ilineara_g22(in->b, in->a);
1526 }
1527
1528 else
1529 {
1530 out->g = ilineara_g22(in->g, in->a);
1531
1532 if (in->b == in->r)
1533 out->b = out->r;
1534
1535 else if (in->b == in->g)
1536 out->b = out->g;
1537
1538 else
1539 out->b = ilineara_g22(in->b, in->a);
1540 }
1541
1542 out->a = in->a * 257;
1543 }
1544 #endif
1545
1546 #if ALLOW_UNUSED_GPC
1547 /* Pre': as 'Pre' but alpha := 65535 */
1548 static void
1549 gpc_Preq(Pixel *out, const Pixel *in, const Background *back)
1550 {
1551 (void)back;
1552
1553 out->r = ilineara_g22(in->r, in->a);
1554
1555 if (in->g == in->r)
1556 {
1557 out->g = out->r;
1558
1559 if (in->b == in->r)
1560 out->b = out->r;
1561
1562 else
1563 out->b = ilineara_g22(in->b, in->a);
1564 }
1565
1566 else
1567 {
1568 out->g = ilineara_g22(in->g, in->a);
1569
1570 if (in->b == in->r)
1571 out->b = out->r;
1572
1573 else if (in->b == in->g)
1574 out->b = out->g;
1575
1576 else
1577 out->b = ilineara_g22(in->b, in->a);
1578 }
1579
1580 out->a = 65535;
1581 }
1582 #endif
1583
1584 #if ALLOW_UNUSED_GPC
1585 /* Glin: make gAMA 45455 components linear, convert to grayscale, alpha := 65535
1586 */
1587 static void
1588 gpc_Glin(Pixel *out, const Pixel *in, const Background *back)
1589 {
1590 (void)back;
1591
1592 if (in->r == in->g && in->g == in->b)
1593 out->r = out->g = out->b = ilinear_g22(in->g);
1594
1595 else
1596 out->r = out->g = out->b = u16d(65535 *
1597 YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b]));
1598
1599 out->a = 65535;
1600 }
1601 #endif
1602
1603 #if ALLOW_UNUSED_GPC
1604 /* Gpre: make gAMA 45455 components grayscale and linear and premultiply by
1605 * alpha.
1606 */
1607 static void
1608 gpc_Gpre(Pixel *out, const Pixel *in, const Background *back)
1609 {
1610 (void)back;
1611
1612 if (in->r == in->g && in->g == in->b)
1613 out->r = out->g = out->b = ilineara_g22(in->g, in->a);
1614
1615 else
1616 out->r = out->g = out->b = u16d(in->a * 257 *
1617 YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b]));
1618
1619 out->a = 257 * in->a;
1620 }
1621 #endif
1622
1623 #if ALLOW_UNUSED_GPC
1624 /* Gpr': as 'Gpre' but alpha := 65535 */
1625 static void
1626 gpc_Gprq(Pixel *out, const Pixel *in, const Background *back)
1627 {
1628 (void)back;
1629
1630 if (in->r == in->g && in->g == in->b)
1631 out->r = out->g = out->b = ilineara_g22(in->g, in->a);
1632
1633 else
1634 out->r = out->g = out->b = u16d(in->a * 257 *
1635 YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b]));
1636
1637 out->a = 65535;
1638 }
1639 #endif
1640
1641 /* 16-bit to 8-bit conversions */
1642 /* sRGB: convert linear components to sRGB, alpha := 255 */
1643 static void
1644 gpc_sRGB(Pixel *out, const Pixel *in, const Background *back)
1645 {
1646 (void)back;
1647
1648 out->r = isRGB(in->r);
1649
1650 if (in->g == in->r)
1651 {
1652 out->g = out->r;
1653
1654 if (in->b == in->r)
1655 out->b = out->r;
1656
1657 else
1658 out->b = isRGB(in->b);
1659 }
1660
1661 else
1662 {
1663 out->g = isRGB(in->g);
1664
1665 if (in->b == in->r)
1666 out->b = out->r;
1667
1668 else if (in->b == in->g)
1669 out->b = out->g;
1670
1671 else
1672 out->b = isRGB(in->b);
1673 }
1674
1675 out->a = 255;
1676 }
1677
1678 /* unpg: unpremultiply gray component and convert to sRGB (scale alpha) */
1679 static void
1680 gpc_unpg(Pixel *out, const Pixel *in, const Background *back)
1681 {
1682 (void)back;
1683
1684 if (in->a <= 128)
1685 {
1686 out->r = out->g = out->b = 255;
1687 out->a = 0;
1688 }
1689
1690 else
1691 {
1692 out->r = out->g = out->b = sRGB((double)in->g / in->a);
1693 out->a = u8d(in->a / 257.);
1694 }
1695 }
1696
1697 /* unpc: unpremultiply color components and convert to sRGB (scale alpha) */
1698 static void
1699 gpc_unpc(Pixel *out, const Pixel *in, const Background *back)
1700 {
1701 (void)back;
1702
1703 if (in->a <= 128)
1704 {
1705 out->r = out->g = out->b = 255;
1706 out->a = 0;
1707 }
1708
1709 else
1710 {
1711 out->r = sRGB((double)in->r / in->a);
1712 out->g = sRGB((double)in->g / in->a);
1713 out->b = sRGB((double)in->b / in->a);
1714 out->a = u8d(in->a / 257.);
1715 }
1716 }
1717
1718 /* b16g: composite linear onto gray background and convert the result to sRGB */
1719 static void
1720 gpc_b16g(Pixel *out, const Pixel *in, const Background *back)
1721 {
1722 if (in->a <= 0)
1723 out->r = out->g = out->b = back->ig;
1724
1725 else
1726 {
1727 double a = in->a/65535.;
1728 double a1 = 1-a;
1729
1730 a /= 65535;
1731 out->r = out->g = out->b = sRGB(in->g * a + back->dg * a1);
1732 }
1733
1734 out->a = 255;
1735 }
1736
1737 /* b16c: composite linear onto color background and convert the result to sRGB*/
1738 static void
1739 gpc_b16c(Pixel *out, const Pixel *in, const Background *back)
1740 {
1741 if (in->a <= 0)
1742 {
1743 out->r = back->ir;
1744 out->g = back->ig;
1745 out->b = back->ib;
1746 }
1747
1748 else
1749 {
1750 double a = in->a/65535.;
1751 double a1 = 1-a;
1752
1753 a /= 65535;
1754 out->r = sRGB(in->r * a + back->dr * a1);
1755 out->g = sRGB(in->g * a + back->dg * a1);
1756 out->b = sRGB(in->b * a + back->db * a1);
1757 }
1758
1759 out->a = 255;
1760 }
1761
1762 /* sG: convert linear RGB to sRGB grayscale */
1763 static void
1764 gpc_sG(Pixel *out, const Pixel *in, const Background *back)
1765 {
1766 (void)back;
1767
1768 out->r = out->g = out->b = sRGB(YfromRGBint(in->r, in->g, in->b)/65535);
1769 out->a = 255;
1770 }
1771
1772 /* sGp: unpremultiply RGB then convert to sRGB grayscale */
1773 static void
1774 gpc_sGp(Pixel *out, const Pixel *in, const Background *back)
1775 {
1776 (void)back;
1777
1778 if (in->a <= 128)
1779 {
1780 out->r = out->g = out->b = 255;
1781 out->a = 0;
1782 }
1783
1784 else
1785 {
1786 out->r = out->g = out->b = sRGB(YfromRGBint(in->r, in->g, in->b)/in->a);
1787 out->a = u8d(in->a / 257.);
1788 }
1789 }
1790
1791 /* sCp: unpremultiply RGB then convert to sRGB */
1792 static void
1793 gpc_sCp(Pixel *out, const Pixel *in, const Background *back)
1794 {
1795 (void)back;
1796
1797 if (in->a <= 128)
1798 {
1799 out->r = out->g = out->b = 255;
1800 out->a = 0;
1801 }
1802
1803 else
1804 {
1805 out->r = sRGB((double)in->r / in->a);
1806 out->g = sRGB((double)in->g / in->a);
1807 out->b = sRGB((double)in->b / in->a);
1808 out->a = u8d(in->a / 257.);
1809 }
1810 }
1811
1812 /* gb16: composite linear onto background and convert to sRGB grayscale */
1813 /* (order doesn't matter, the composite and grayscale operations permute) */
1814 static void
1815 gpc_gb16(Pixel *out, const Pixel *in, const Background *back)
1816 {
1817 if (in->a <= 0)
1818 out->r = out->g = out->b = back->ig;
1819
1820 else if (in->a >= 65535)
1821 out->r = out->g = out->b = isRGB(in->g);
1822
1823 else
1824 {
1825 double a = in->a / 65535.;
1826 double a1 = 1-a;
1827
1828 a /= 65535;
1829 out->r = out->g = out->b = sRGB(in->g * a + back->dg * a1);
1830 }
1831
1832 out->a = 255;
1833 }
1834
1835 /* cb16: composite linear onto background and convert to sRGB */
1836 static void
1837 gpc_cb16(Pixel *out, const Pixel *in, const Background *back)
1838 {
1839 if (in->a <= 0)
1840 {
1841 out->r = back->ir;
1842 out->g = back->ig;
1843 out->b = back->ib;
1844 }
1845
1846 else if (in->a >= 65535)
1847 {
1848 out->r = isRGB(in->r);
1849 out->g = isRGB(in->g);
1850 out->b = isRGB(in->b);
1851 }
1852
1853 else
1854 {
1855 double a = in->a / 65535.;
1856 double a1 = 1-a;
1857
1858 a /= 65535;
1859 out->r = sRGB(in->r * a + back->dr * a1);
1860 out->g = sRGB(in->g * a + back->dg * a1);
1861 out->b = sRGB(in->b * a + back->db * a1);
1862 }
1863
1864 out->a = 255;
1865 }
1866
1867 /* 16-bit to 16-bit conversions */
1868 /* A: set alpha to 65535 */
1869 static void
1870 gpc_A(Pixel *out, const Pixel *in, const Background *back)
1871 {
1872 (void)back;
1873 out->r = in->r;
1874 out->g = in->g;
1875 out->b = in->b;
1876 out->a = 65535;
1877 }
1878
1879 /* g16: convert linear RGB to linear grayscale (alpha := 65535) */
1880 static void
1881 gpc_g16(Pixel *out, const Pixel *in, const Background *back)
1882 {
1883 (void)back;
1884 out->r = out->g = out->b = u16d(YfromRGBint(in->r, in->g, in->b));
1885 out->a = 65535;
1886 }
1887
1888 /* g16': as 'g16' but alpha is unchanged */
1889 static void
1890 gpc_g16q(Pixel *out, const Pixel *in, const Background *back)
1891 {
1892 (void)back;
1893 out->r = out->g = out->b = u16d(YfromRGBint(in->r, in->g, in->b));
1894 out->a = in->a;
1895 }
1896
1897 #if ALLOW_UNUSED_GPC
1898 /* Unused functions (to hide them from GCC unused function warnings) */
1899 void (* const gpc_unused[])
1900 (Pixel *out, const Pixel *in, const Background *back) =
1901 {
1902 gpc_Pre, gpc_Preq, gpc_Glin, gpc_Gpre, gpc_Gprq, gpc_nop8, gpc_nop6
1903 };
1904 #endif
1905
1906 /* OUT: ----- 8-bit ----- ----- 16-bit -----
1907 * IN G GA RGB RGBA G GA RGB RGBA
1908 * 8 G . . . . lin lin lin lin
1909 * 8 GA bckg . bckc . pre' pre pre' pre
1910 * 8 RGB g8 g8 . . glin glin lin lin
1911 * 8 RGBA g8b g8 bckc . gpr' gpre pre' pre
1912 * 16 G sRGB sRGB sRGB sRGB . . . .
1913 * 16 GA b16g unpg b16c unpc A . A .
1914 * 16 RGB sG sG sRGB sRGB g16 g16 . .
1915 * 16 RGBA gb16 sGp cb16 sCp g16 g16' A .
1916 *
1917 * The matrix is held in an array indexed thus:
1918 *
1919 * gpc_fn[out_format & BASE_FORMATS][in_format & BASE_FORMATS];
1920 */
1921 /* This will produce a compile time error if the FORMAT_FLAG values don't
1922 * match the above matrix!
1923 */
1924 #if PNG_FORMAT_FLAG_ALPHA == 1 && PNG_FORMAT_FLAG_COLOR == 2 &&\
1925 PNG_FORMAT_FLAG_LINEAR == 4
1926 static void (* const gpc_fn[8/*in*/][8/*out*/])
1927 (Pixel *out, const Pixel *in, const Background *back) =
1928 {
1929 /*out: G-8 GA-8 RGB-8 RGBA-8 G-16 GA-16 RGB-16 RGBA-16 */
1930 {gpc_noop,gpc_noop,gpc_noop,gpc_noop, gpc_Lin, gpc_Lin, gpc_Lin, gpc_Lin },
1931 {gpc_bckg,gpc_noop,gpc_bckc,gpc_noop, gpc_preq,gpc_pre, gpc_preq,gpc_pre },
1932 {gpc_g8, gpc_g8, gpc_noop,gpc_noop, gpc_glin,gpc_glin,gpc_lin, gpc_lin },
1933 {gpc_g8b, gpc_g8, gpc_bckc,gpc_noop, gpc_gprq,gpc_gpre,gpc_preq,gpc_pre },
1934 {gpc_sRGB,gpc_sRGB,gpc_sRGB,gpc_sRGB, gpc_noop,gpc_noop,gpc_noop,gpc_noop},
1935 {gpc_b16g,gpc_unpg,gpc_b16c,gpc_unpc, gpc_A, gpc_noop,gpc_A, gpc_noop},
1936 {gpc_sG, gpc_sG, gpc_sRGB,gpc_sRGB, gpc_g16, gpc_g16, gpc_noop,gpc_noop},
1937 {gpc_gb16,gpc_sGp, gpc_cb16,gpc_sCp, gpc_g16, gpc_g16q,gpc_A, gpc_noop}
1938 };
1939
1940 /* The array is repeated for the cases where both the input and output are color
1941 * mapped because then different algorithms are used.
1942 */
1943 static void (* const gpc_fn_colormapped[8/*in*/][8/*out*/])
1944 (Pixel *out, const Pixel *in, const Background *back) =
1945 {
1946 /*out: G-8 GA-8 RGB-8 RGBA-8 G-16 GA-16 RGB-16 RGBA-16 */
1947 {gpc_noop,gpc_noop,gpc_noop,gpc_noop, gpc_lin, gpc_lin, gpc_lin, gpc_lin },
1948 {gpc_bckg,gpc_noop,gpc_bckc,gpc_noop, gpc_preq,gpc_pre, gpc_preq,gpc_pre },
1949 {gpc_g8, gpc_g8, gpc_noop,gpc_noop, gpc_glin,gpc_glin,gpc_lin, gpc_lin },
1950 {gpc_g8b, gpc_g8, gpc_bckc,gpc_noop, gpc_gprq,gpc_gpre,gpc_preq,gpc_pre },
1951 {gpc_sRGB,gpc_sRGB,gpc_sRGB,gpc_sRGB, gpc_noop,gpc_noop,gpc_noop,gpc_noop},
1952 {gpc_b16g,gpc_unpg,gpc_b16c,gpc_unpc, gpc_A, gpc_noop,gpc_A, gpc_noop},
1953 {gpc_sG, gpc_sG, gpc_sRGB,gpc_sRGB, gpc_g16, gpc_g16, gpc_noop,gpc_noop},
1954 {gpc_gb16,gpc_sGp, gpc_cb16,gpc_sCp, gpc_g16, gpc_g16q,gpc_A, gpc_noop}
1955 };
1956
1957 /* The error arrays record the error in the same matrix; 64 entries, however
1958 * the different algorithms used in libpng for colormap and direct conversions
1959 * mean that four separate matrices are used (for each combination of
1960 * colormapped and direct.)
1961 *
1962 * In some cases the conversion between sRGB formats goes via a linear
1963 * intermediate; an sRGB to linear conversion (as above) is followed by a simple
1964 * linear to sRGB step with no other conversions. This is done by a separate
1965 * error array from an arbitrary 'in' format to one of the four basic outputs
1966 * (since final output is always sRGB not colormapped).
1967 *
1968 * These arrays may be modified if the --accumulate flag is set during the run;
1969 * then instead of logging errors they are simply added in.
1970 *
1971 * The three entries are currently for transparent, partially transparent and
1972 * opaque input pixel values. Notice that alpha should be exact in each case.
1973 *
1974 * Errors in alpha should only occur when converting from a direct format
1975 * to a colormapped format, when alpha is effectively smashed (so large
1976 * errors can occur.) There should be no error in the '0' and 'opaque'
1977 * values. The fourth entry in the array is used for the alpha error (and it
1978 * should always be zero for the 'via linear' case since this is never color
1979 * mapped.)
1980 *
1981 * Mapping to a colormap smashes the colors, it is necessary to have separate
1982 * values for these cases because they are much larger; it is very much
1983 * impossible to obtain a reasonable result, these are held in
1984 * gpc_error_to_colormap.
1985 */
1986 #if PNG_FORMAT_FLAG_COLORMAP == 8 /* extra check also required */
1987 /* START MACHINE GENERATED */
1988 static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =
1989 {
1990 { /* input: sRGB-gray */
1991 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
1992 { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 },
1993 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
1994 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
1995 }, { /* input: sRGB-gray+alpha */
1996 { 0, 18, 0, 0 }, { 0, 0, 0, 0 }, { 0, 20, 0, 0 }, { 0, 0, 0, 0 },
1997 { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
1998 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
1999 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2000 }, { /* input: sRGB-rgb */
2001 { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2002 { 0, 0, 893, 0 }, { 0, 0, 893, 0 }, { 0, 0, 811, 0 }, { 0, 0, 811, 0 },
2003 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2004 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2005 }, { /* input: sRGB-rgb+alpha */
2006 { 0, 4, 13, 0 }, { 0, 14, 13, 0 }, { 0, 19, 0, 0 }, { 0, 0, 0, 0 },
2007 { 0, 832, 764, 0 }, { 0, 832, 764, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
2008 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2009 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2010 }, { /* input: linear-gray */
2011 { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
2012 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2013 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2014 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2015 }, { /* input: linear-gray+alpha */
2016 { 0, 74, 9, 0 }, { 0, 20, 9, 0 }, { 0, 74, 9, 0 }, { 0, 20, 9, 0 },
2017 { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
2018 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2019 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2020 }, { /* input: linear-rgb */
2021 { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
2022 { 0, 0, 4, 0 }, { 0, 0, 4, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2023 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2024 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2025 }, { /* input: linear-rgb+alpha */
2026 { 0, 126, 143, 0 }, { 0, 9, 7, 0 }, { 0, 74, 9, 0 }, { 0, 16, 9, 0 },
2027 { 0, 4, 4, 0 }, { 0, 5, 4, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
2028 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2029 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2030 }, { /* input: color-mapped-sRGB-gray */
2031 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2032 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2033 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2034 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2035 }, { /* input: color-mapped-sRGB-gray+alpha */
2036 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2037 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2038 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2039 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2040 }, { /* input: color-mapped-sRGB-rgb */
2041 { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 8, 0 }, { 0, 0, 8, 0 },
2042 { 0, 0, 673, 0 }, { 0, 0, 673, 0 }, { 0, 0, 674, 0 }, { 0, 0, 674, 0 },
2043 { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2044 { 0, 0, 460, 0 }, { 0, 0, 460, 0 }, { 0, 0, 263, 0 }, { 0, 0, 263, 0 }
2045 }, { /* input: color-mapped-sRGB-rgb+alpha */
2046 { 0, 6, 8, 0 }, { 0, 7, 8, 0 }, { 0, 75, 8, 0 }, { 0, 9, 8, 0 },
2047 { 0, 585, 427, 0 }, { 0, 585, 427, 0 }, { 0, 717, 409, 0 }, { 0, 717, 409, 0 },
2048 { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 },
2049 { 0, 13323, 460, 0 }, { 0, 334, 460, 0 }, { 0, 16480, 263, 0 }, { 0, 243, 263, 0 }
2050 }, { /* input: color-mapped-linear-gray */
2051 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2052 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2053 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2054 { 0, 0, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2055 }, { /* input: color-mapped-linear-gray+alpha */
2056 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2057 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2058 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2059 { 0, 0, 0, 0 }, { 0, 253, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2060 }, { /* input: color-mapped-linear-rgb */
2061 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2062 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2063 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2064 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 265, 0 }, { 0, 0, 0, 0 }
2065 }, { /* input: color-mapped-linear-rgb+alpha */
2066 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2067 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2068 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2069 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 243, 265, 0 }
2070 }
2071 };
2072 static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =
2073 {
2074 { /* input: sRGB-gray */
2075 { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }
2076 }, { /* input: sRGB-gray+alpha */
2077 { 0, 15, 15, 0 }, { 0, 186, 15, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
2078 }, { /* input: sRGB-rgb */
2079 { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 15, 0 }, { 0, 0, 15, 0 }
2080 }, { /* input: sRGB-rgb+alpha */
2081 { 0, 12, 14, 0 }, { 0, 180, 14, 0 }, { 0, 14, 15, 0 }, { 0, 186, 15, 0 }
2082 }, { /* input: linear-gray */
2083 { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
2084 }, { /* input: linear-gray+alpha */
2085 { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
2086 }, { /* input: linear-rgb */
2087 { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
2088 }, { /* input: linear-rgb+alpha */
2089 { 0, 1, 1, 0 }, { 0, 8, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
2090 }, { /* input: color-mapped-sRGB-gray */
2091 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2092 }, { /* input: color-mapped-sRGB-gray+alpha */
2093 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2094 }, { /* input: color-mapped-sRGB-rgb */
2095 { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 14, 0 }, { 0, 0, 14, 0 }
2096 }, { /* input: color-mapped-sRGB-rgb+alpha */
2097 { 0, 4, 8, 0 }, { 0, 9, 8, 0 }, { 0, 8, 3, 0 }, { 0, 32, 3, 0 }
2098 }, { /* input: color-mapped-linear-gray */
2099 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2100 }, { /* input: color-mapped-linear-gray+alpha */
2101 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2102 }, { /* input: color-mapped-linear-rgb */
2103 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2104 }, { /* input: color-mapped-linear-rgb+alpha */
2105 { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2106 }
2107 };
2108 static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =
2109 {
2110 { /* input: sRGB-gray */
2111 { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
2112 { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }
2113 }, { /* input: sRGB-gray+alpha */
2114 { 0, 19, 2, 0 }, { 0, 255, 2, 25 }, { 0, 88, 2, 0 }, { 0, 255, 2, 25 },
2115 { 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 }, { 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 }
2116 }, { /* input: sRGB-rgb */
2117 { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 25, 0 }, { 0, 0, 25, 0 },
2118 { 0, 0, 937, 0 }, { 0, 0, 937, 0 }, { 0, 0, 13677, 0 }, { 0, 0, 13677, 0 }
2119 }, { /* input: sRGB-rgb+alpha */
2120 { 0, 63, 77, 0 }, { 0, 255, 19, 25 }, { 0, 220, 25, 0 }, { 0, 255, 25, 67 },
2121 { 0, 17534, 18491, 0 }, { 0, 15614, 2824, 6425 }, { 0, 14019, 13677, 0 }, { 0, 48573, 13677, 17219 }
2122 }, { /* input: linear-gray */
2123 { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 },
2124 { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }
2125 }, { /* input: linear-gray+alpha */
2126 { 0, 74, 74, 0 }, { 0, 255, 74, 25 }, { 0, 97, 74, 0 }, { 0, 255, 74, 25 },
2127 { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 }, { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 }
2128 }, { /* input: linear-rgb */
2129 { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 98, 0 }, { 0, 0, 98, 0 },
2130 { 0, 0, 18664, 0 }, { 0, 0, 18664, 0 }, { 0, 0, 24998, 0 }, { 0, 0, 24998, 0 }
2131 }, { /* input: linear-rgb+alpha */
2132 { 0, 181, 196, 0 }, { 0, 255, 61, 25 }, { 206, 187, 98, 0 }, { 0, 255, 98, 67 },
2133 { 0, 18141, 18137, 0 }, { 0, 17494, 17504, 6553 }, { 0, 24979, 24992, 0 }, { 0, 46509, 24992, 17347 }
2134 }
2135 };
2136 /* END MACHINE GENERATED */
2137 #endif /* COLORMAP flag check */
2138 #endif /* flag checks */
2139
2140 typedef struct
2141 {
2142 /* Basic pixel information: */
2143 Image* in_image; /* Input image */
2144 const Image* out_image; /* Output image */
2145
2146 /* 'background' is the value passed to the gpc_ routines, it may be NULL if
2147 * it should not be used (*this* program has an error if it crashes as a
2148 * result!)
2149 */
2150 Background background_color;
2151 const Background* background;
2152
2153 /* Precalculated values: */
2154 int in_opaque; /* Value of input alpha that is opaque */
2155 int is_palette; /* Sample values come from the palette */
2156 int accumulate; /* Accumlate component errors (don't log) */
2157 int output_8bit; /* Output is 8 bit (else 16 bit) */
2158
2159 void (*in_gp)(Pixel*, png_const_voidp);
2160 void (*out_gp)(Pixel*, png_const_voidp);
2161
2162 void (*transform)(Pixel *out, const Pixel *in, const Background *back);
2163 /* A function to perform the required transform */
2164
2165 void (*from_linear)(Pixel *out, const Pixel *in, const Background *back);
2166 /* For 'via_linear' transforms the final, from linear, step, else NULL */
2167
2168 png_uint_16 error[4];
2169 /* Three error values for transparent, partially transparent and opaque
2170 * input pixels (in turn).
2171 */
2172
2173 png_uint_16 *error_ptr;
2174 /* Where these are stored in the static array (for 'accumulate') */
2175 }
2176 Transform;
2177
2178 /* Return a 'transform' as above for the given format conversion. */
2179 static void
2180 transform_from_formats(Transform *result, Image *in_image,
2181 const Image *out_image, png_const_colorp background, int via_linear)
2182 {
2183 png_uint_32 in_format, out_format;
2184 png_uint_32 in_base, out_base;
2185
2186 memset(result, 0, sizeof *result);
2187
2188 /* Store the original images for error messages */
2189 result->in_image = in_image;
2190 result->out_image = out_image;
2191
2192 in_format = in_image->image.format;
2193 out_format = out_image->image.format;
2194
2195 if (in_format & PNG_FORMAT_FLAG_LINEAR)
2196 result->in_opaque = 65535;
2197 else
2198 result->in_opaque = 255;
2199
2200 result->output_8bit = (out_format & PNG_FORMAT_FLAG_LINEAR) == 0;
2201
2202 result->is_palette = 0; /* set by caller if required */
2203 result->accumulate = (in_image->opts & ACCUMULATE) != 0;
2204
2205 /* The loaders (which need the ordering information) */
2206 result->in_gp = get_pixel(in_format);
2207 result->out_gp = get_pixel(out_format);
2208
2209 /* Remove the ordering information: */
2210 in_format &= BASE_FORMATS | PNG_FORMAT_FLAG_COLORMAP;
2211 in_base = in_format & BASE_FORMATS;
2212 out_format &= BASE_FORMATS | PNG_FORMAT_FLAG_COLORMAP;
2213 out_base = out_format & BASE_FORMATS;
2214
2215 if (via_linear)
2216 {
2217 /* Check for an error in this program: */
2218 if (out_format & (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLORMAP))
2219 {
2220 fprintf(stderr, "internal transform via linear error 0x%x->0x%x\n",
2221 in_format, out_format);
2222 exit(1);
2223 }
2224
2225 result->transform = gpc_fn[in_base][out_base | PNG_FORMAT_FLAG_LINEAR];
2226 result->from_linear = gpc_fn[out_base | PNG_FORMAT_FLAG_LINEAR][out_base];
2227 result->error_ptr = gpc_error_via_linear[in_format][out_format];
2228 }
2229
2230 else if (~in_format & out_format & PNG_FORMAT_FLAG_COLORMAP)
2231 {
2232 /* The input is not colormapped but the output is, the errors will
2233 * typically be large (only the grayscale-no-alpha case permits preserving
2234 * even 8-bit values.)
2235 */
2236 result->transform = gpc_fn[in_base][out_base];
2237 result->from_linear = NULL;
2238 result->error_ptr = gpc_error_to_colormap[in_base][out_base];
2239 }
2240
2241 else
2242 {
2243 /* The caller handles the colormap->pixel value conversion, so the
2244 * transform function just gets a pixel value, however because libpng
2245 * currently contains a different implementation for mapping a colormap if
2246 * both input and output are colormapped we need different conversion
2247 * functions to deal with errors in the libpng implementation.
2248 */
2249 if (in_format & out_format & PNG_FORMAT_FLAG_COLORMAP)
2250 result->transform = gpc_fn_colormapped[in_base][out_base];
2251 else
2252 result->transform = gpc_fn[in_base][out_base];
2253 result->from_linear = NULL;
2254 result->error_ptr = gpc_error[in_format][out_format];
2255 }
2256
2257 /* Follow the libpng simplified API rules to work out what to pass to the gpc
2258 * routines as a background value, if one is not required pass NULL so that
2259 * this program crashes in the even of a programming error.
2260 */
2261 result->background = NULL; /* default: not required */
2262
2263 /* Rule 1: background only need be supplied if alpha is to be removed */
2264 if (in_format & ~out_format & PNG_FORMAT_FLAG_ALPHA)
2265 {
2266 /* The input value is 'NULL' to use the background and (otherwise) an sRGB
2267 * background color (to use a solid color). The code above uses a fixed
2268 * byte value, BUFFER_INIT8, for buffer even for 16-bit output. For
2269 * linear (16-bit) output the sRGB background color is ignored; the
2270 * composition is always on the background (so BUFFER_INIT8 * 257), except
2271 * that for the colormap (i.e. linear colormapped output) black is used.
2272 */
2273 result->background = &result->background_color;
2274
2275 if (out_format & PNG_FORMAT_FLAG_LINEAR || via_linear)
2276 {
2277 if (out_format & PNG_FORMAT_FLAG_COLORMAP)
2278 {
2279 result->background_color.ir =
2280 result->background_color.ig =
2281 result->background_color.ib = 0;
2282 result->background_color.dr =
2283 result->background_color.dg =
2284 result->background_color.db = 0;
2285 }
2286
2287 else
2288 {
2289 result->background_color.ir =
2290 result->background_color.ig =
2291 result->background_color.ib = BUFFER_INIT8 * 257;
2292 result->background_color.dr =
2293 result->background_color.dg =
2294 result->background_color.db = 0;
2295 }
2296 }
2297
2298 else /* sRGB output */
2299 {
2300 if (background != NULL)
2301 {
2302 if (out_format & PNG_FORMAT_FLAG_COLOR)
2303 {
2304 result->background_color.ir = background->red;
2305 result->background_color.ig = background->green;
2306 result->background_color.ib = background->blue;
2307 /* TODO: sometimes libpng uses the power law conversion here, how
2308 * to handle this?
2309 */
2310 result->background_color.dr = sRGB_to_d[background->red];
2311 result->background_color.dg = sRGB_to_d[background->green];
2312 result->background_color.db = sRGB_to_d[background->blue];
2313 }
2314
2315 else /* grayscale: libpng only looks at 'g' */
2316 {
2317 result->background_color.ir =
2318 result->background_color.ig =
2319 result->background_color.ib = background->green;
2320 /* TODO: sometimes libpng uses the power law conversion here, how
2321 * to handle this?
2322 */
2323 result->background_color.dr =
2324 result->background_color.dg =
2325 result->background_color.db = sRGB_to_d[background->green];
2326 }
2327 }
2328
2329 else if ((out_format & PNG_FORMAT_FLAG_COLORMAP) == 0)
2330 {
2331 result->background_color.ir =
2332 result->background_color.ig =
2333 result->background_color.ib = BUFFER_INIT8;
2334 /* TODO: sometimes libpng uses the power law conversion here, how
2335 * to handle this?
2336 */
2337 result->background_color.dr =
2338 result->background_color.dg =
2339 result->background_color.db = sRGB_to_d[BUFFER_INIT8];
2340 }
2341
2342 /* Else the output is colormapped and a background color must be
2343 * provided; if pngstest crashes then that is a bug in this program
2344 * (though libpng should png_error as well.)
2345 */
2346 else
2347 result->background = NULL;
2348 }
2349 }
2350
2351 if (result->background == NULL)
2352 {
2353 result->background_color.ir =
2354 result->background_color.ig =
2355 result->background_color.ib = -1; /* not used */
2356 result->background_color.dr =
2357 result->background_color.dg =
2358 result->background_color.db = 1E30; /* not used */
2359 }
2360
2361
2362 /* Copy the error values into the Transform: */
2363 result->error[0] = result->error_ptr[0];
2364 result->error[1] = result->error_ptr[1];
2365 result->error[2] = result->error_ptr[2];
2366 result->error[3] = result->error_ptr[3];
2367 }
2368
2369
2370 /* Compare two pixels.
2371 *
2372 * OLD error values:
2373 static int error_to_linear = 811; * by experiment *
2374 static int error_to_linear_grayscale = 424; * by experiment *
2375 static int error_to_sRGB = 6; * by experiment *
2376 static int error_to_sRGB_grayscale = 17; * libpng error by calculation +
2377 2 by experiment *
2378 static int error_in_compose = 2; * by experiment *
2379 static int error_in_premultiply = 1;
2380 *
2381 * The following is *just* the result of a round trip from 8-bit sRGB to linear
2382 * then back to 8-bit sRGB when it is done by libpng. There are two problems:
2383 *
2384 * 1) libpng currently uses a 2.2 power law with no linear segment, this results
2385 * in instability in the low values and even with 16-bit precision sRGB(1) ends
2386 * up mapping to sRGB(0) as a result of rounding in the 16-bit representation.
2387 * This gives an error of 1 in the handling of value 1 only.
2388 *
2389 * 2) libpng currently uses an intermediate 8-bit linear value in gamma
2390 * correction of 8-bit values. This results in many more errors, the worse of
2391 * which is mapping sRGB(14) to sRGB(0).
2392 *
2393 * The general 'error_via_linear' is more complex because of pre-multiplication,
2394 * this compounds the 8-bit errors according to the alpha value of the pixel.
2395 * As a result 256 values are pre-calculated for error_via_linear.
2396 */
2397 #if 0
2398 static int error_in_libpng_gamma;
2399 static int error_via_linear[256]; /* Indexed by 8-bit alpha */
2400
2401 static void
2402 init_error_via_linear(void)
2403 {
2404 int alpha;
2405
2406 error_via_linear[0] = 255; /* transparent pixel */
2407
2408 for (alpha=1; alpha<=255; ++alpha)
2409 {
2410 /* 16-bit values less than 128.5 get rounded to 8-bit 0 and so the worst
2411 * case error arises with 16-bit 128.5, work out what sRGB
2412 * (non-associated) value generates 128.5; any value less than this is
2413 * going to map to 0, so the worst error is floor(value).
2414 *
2415 * Note that errors are considerably higher (more than a factor of 2)
2416 * because libpng uses a simple power law for sRGB data at present.
2417 *
2418 * Add .1 for arithmetic errors inside libpng.
2419 */
2420 double v = floor(255*pow(.5/*(128.5 * 255 / 65535)*/ / alpha, 1/2.2)+.1);
2421
2422 error_via_linear[alpha] = (int)v;
2423 }
2424
2425 /* This is actually 14.99, but, despite the closeness to 15, 14 seems to work
2426 * ok in this case.
2427 */
2428 error_in_libpng_gamma = 14;
2429 }
2430 #endif
2431
2432 static void
2433 print_pixel(char string[64], const Pixel *pixel, png_uint_32 format)
2434 {
2435 switch (format & (PNG_FORMAT_FLAG_ALPHA|PNG_FORMAT_FLAG_COLOR))
2436 {
2437 case 0:
2438 sprintf(string, "%s(%d)", format_names[format], pixel->g);
2439 break;
2440
2441 case PNG_FORMAT_FLAG_ALPHA:
2442 sprintf(string, "%s(%d,%d)", format_names[format], pixel->g,
2443 pixel->a);
2444 break;
2445
2446 case PNG_FORMAT_FLAG_COLOR:
2447 sprintf(string, "%s(%d,%d,%d)", format_names[format],
2448 pixel->r, pixel->g, pixel->b);
2449 break;
2450
2451 case PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA:
2452 sprintf(string, "%s(%d,%d,%d,%d)", format_names[format],
2453 pixel->r, pixel->g, pixel->b, pixel->a);
2454 break;
2455
2456 default:
2457 sprintf(string, "invalid-format");
2458 break;
2459 }
2460 }
2461
2462 static int
2463 logpixel(const Transform *transform, png_uint_32 x, png_uint_32 y,
2464 const Pixel *in, const Pixel *calc, const Pixel *out, const char *reason)
2465 {
2466 const png_uint_32 in_format = transform->in_image->image.format;
2467 const png_uint_32 out_format = transform->out_image->image.format;
2468
2469 png_uint_32 back_format = out_format & ~PNG_FORMAT_FLAG_ALPHA;
2470 const char *via_linear = "";
2471
2472 char pixel_in[64], pixel_calc[64], pixel_out[64], pixel_loc[64];
2473 char background_info[100];
2474
2475 print_pixel(pixel_in, in, in_format);
2476 print_pixel(pixel_calc, calc, out_format);
2477 print_pixel(pixel_out, out, out_format);
2478
2479 if (transform->is_palette)
2480 sprintf(pixel_loc, "palette: %lu", (unsigned long)y);
2481 else
2482 sprintf(pixel_loc, "%lu,%lu", (unsigned long)x, (unsigned long)y);
2483
2484 if (transform->from_linear != NULL)
2485 {
2486 via_linear = " (via linear)";
2487 /* And as a result the *read* format which did any background processing
2488 * was itself linear, so the background color information is also
2489 * linear.
2490 */
2491 back_format |= PNG_FORMAT_FLAG_LINEAR;
2492 }
2493
2494 if (transform->background != NULL)
2495 {
2496 Pixel back;
2497 char pixel_back[64];
2498
2499 back.r = transform->background->ir;
2500 back.g = transform->background->ig;
2501 back.b = transform->background->ib;
2502 back.a = -1; /* not used */
2503
2504 print_pixel(pixel_back, &back, back_format);
2505 sprintf(background_info, " on background %s", pixel_back);
2506 }
2507
2508 else
2509 background_info[0] = 0;
2510
2511 if (transform->in_image->file_name != transform->out_image->file_name)
2512 {
2513 char error_buffer[512];
2514 sprintf(error_buffer,
2515 "(%s) %s error%s:\n %s%s ->\n %s\n not: %s.\n"
2516 "Use --preserve and examine: ", pixel_loc, reason, via_linear,
2517 pixel_in, background_info, pixel_out, pixel_calc);
2518 return logerror(transform->in_image, transform->in_image->file_name,
2519 error_buffer, transform->out_image->file_name);
2520 }
2521
2522 else
2523 {
2524 char error_buffer[512];
2525 sprintf(error_buffer,
2526 "(%s) %s error%s:\n %s%s ->\n %s\n not: %s.\n"
2527 " The error happened when reading the original file with this format.",
2528 pixel_loc, reason, via_linear, pixel_in, background_info, pixel_out,
2529 pixel_calc);
2530 return logerror(transform->in_image, transform->in_image->file_name,
2531 error_buffer, "");
2532 }
2533 }
2534
2535 static int
2536 cmppixel(Transform *transform, png_const_voidp in, png_const_voidp out,
2537 png_uint_32 x, png_uint_32 y/*or palette index*/)
2538 {
2539 int maxerr;
2540 png_const_charp errmsg;
2541 Pixel pixel_in, pixel_calc, pixel_out;
2542
2543 transform->in_gp(&pixel_in, in);
2544
2545 if (transform->from_linear == NULL)
2546 transform->transform(&pixel_calc, &pixel_in, transform->background);
2547
2548 else
2549 {
2550 transform->transform(&pixel_out, &pixel_in, transform->background);
2551 transform->from_linear(&pixel_calc, &pixel_out, NULL);
2552 }
2553
2554 transform->out_gp(&pixel_out, out);
2555
2556 /* Eliminate the case where the input and output values match exactly. */
2557 if (pixel_calc.a == pixel_out.a && pixel_calc.r == pixel_out.r &&
2558 pixel_calc.g == pixel_out.g && pixel_calc.b == pixel_out.b)
2559 return 1;
2560
2561 /* Eliminate the case where the output pixel is transparent and the output
2562 * is 8-bit - any component values are valid. Don't check the input alpha
2563 * here to also skip the 16-bit small alpha cases.
2564 */
2565 if (transform->output_8bit && pixel_calc.a == 0 && pixel_out.a == 0)
2566 return 1;
2567
2568 /* Check for alpha errors first; an alpha error can damage the components too
2569 * so avoid spurious checks on components if one is found.
2570 */
2571 errmsg = NULL;
2572 {
2573 int err_a = abs(pixel_calc.a-pixel_out.a);
2574
2575 if (err_a > transform->error[3])
2576 {
2577 /* If accumulating check the components too */
2578 if (transform->accumulate)
2579 transform->error[3] = (png_uint_16)err_a;
2580
2581 else
2582 errmsg = "alpha";
2583 }
2584 }
2585
2586 /* Now if *either* of the output alphas are 0 but alpha is within tolerance
2587 * eliminate the 8-bit component comparison.
2588 */
2589 if (errmsg == NULL && transform->output_8bit &&
2590 (pixel_calc.a == 0 || pixel_out.a == 0))
2591 return 1;
2592
2593 if (errmsg == NULL) /* else just signal an alpha error */
2594 {
2595 int err_r = abs(pixel_calc.r - pixel_out.r);
2596 int err_g = abs(pixel_calc.g - pixel_out.g);
2597 int err_b = abs(pixel_calc.b - pixel_out.b);
2598 int limit;
2599
2600 if ((err_r | err_g | err_b) == 0)
2601 return 1; /* exact match */
2602
2603 /* Mismatch on a component, check the input alpha */
2604 if (pixel_in.a >= transform->in_opaque)
2605 {
2606 errmsg = "opaque component";
2607 limit = 2; /* opaque */
2608 }
2609
2610 else if (pixel_in.a > 0)
2611 {
2612 errmsg = "alpha component";
2613 limit = 1; /* partially transparent */
2614 }
2615
2616 else
2617 {
2618 errmsg = "transparent component (background)";
2619 limit = 0; /* transparent */
2620 }
2621
2622 maxerr = err_r;
2623 if (maxerr < err_g) maxerr = err_g;
2624 if (maxerr < err_b) maxerr = err_b;
2625
2626 if (maxerr <= transform->error[limit])
2627 return 1; /* within the error limits */
2628
2629 /* Handle a component mis-match; log it, just return an error code, or
2630 * accumulate it.
2631 */
2632 if (transform->accumulate)
2633 {
2634 transform->error[limit] = (png_uint_16)maxerr;
2635 return 1; /* to cause the caller to keep going */
2636 }
2637 }
2638
2639 /* Failure to match and not accumulating, so the error must be logged. */
2640 return logpixel(transform, x, y, &pixel_in, &pixel_calc, &pixel_out, errmsg);
2641 }
2642
2643 static png_byte
2644 component_loc(png_byte loc[4], png_uint_32 format)
2645 {
2646 /* Given a format return the number of channels and the location of
2647 * each channel.
2648 *
2649 * The mask 'loc' contains the component offset of the channels in the
2650 * following order. Note that if 'format' is grayscale the entries 1-3 must
2651 * all contain the location of the gray channel.
2652 *
2653 * 0: alpha
2654 * 1: red or gray
2655 * 2: green or gray
2656 * 3: blue or gray
2657 */
2658 png_byte channels;
2659
2660 if (format & PNG_FORMAT_FLAG_COLOR)
2661 {
2662 channels = 3;
2663
2664 loc[2] = 1;
2665
2666 # ifdef PNG_FORMAT_BGR_SUPPORTED
2667 if (format & PNG_FORMAT_FLAG_BGR)
2668 {
2669 loc[1] = 2;
2670 loc[3] = 0;
2671 }
2672
2673 else
2674 # endif
2675 {
2676 loc[1] = 0;
2677 loc[3] = 2;
2678 }
2679 }
2680
2681 else
2682 {
2683 channels = 1;
2684 loc[1] = loc[2] = loc[3] = 0;
2685 }
2686
2687 if (format & PNG_FORMAT_FLAG_ALPHA)
2688 {
2689 # ifdef PNG_FORMAT_AFIRST_SUPPORTED
2690 if (format & PNG_FORMAT_FLAG_AFIRST)
2691 {
2692 loc[0] = 0;
2693 ++loc[1];
2694 ++loc[2];
2695 ++loc[3];
2696 }
2697
2698 else
2699 # endif
2700 loc[0] = channels;
2701
2702 ++channels;
2703 }
2704
2705 else
2706 loc[0] = 4; /* not present */
2707
2708 return channels;
2709 }
2710
2711 /* Compare two images, the original 'a', which was written out then read back in
2712 * to * give image 'b'. The formats may have been changed.
2713 */
2714 static int
2715 compare_two_images(Image *a, Image *b, int via_linear,
2716 png_const_colorp background)
2717 {
2718 ptrdiff_t stridea = a->stride;
2719 ptrdiff_t strideb = b->stride;
2720 png_const_bytep rowa = a->buffer+16;
2721 png_const_bytep rowb = b->buffer+16;
2722 const png_uint_32 width = a->image.width;
2723 const png_uint_32 height = a->image.height;
2724 const png_uint_32 formata = a->image.format;
2725 const png_uint_32 formatb = b->image.format;
2726 const unsigned int a_sample = PNG_IMAGE_SAMPLE_SIZE(formata);
2727 const unsigned int b_sample = PNG_IMAGE_SAMPLE_SIZE(formatb);
2728 int alpha_added, alpha_removed;
2729 int bchannels;
2730 int btoa[4];
2731 png_uint_32 y;
2732 Transform tr;
2733
2734 /* This should never happen: */
2735 if (width != b->image.width || height != b->image.height)
2736 return logerror(a, a->file_name, ": width x height changed: ",
2737 b->file_name);
2738
2739 /* Set up the background and the transform */
2740 transform_from_formats(&tr, a, b, background, via_linear);
2741
2742 /* Find the first row and inter-row space. */
2743 if (!(formata & PNG_FORMAT_FLAG_COLORMAP) &&
2744 (formata & PNG_FORMAT_FLAG_LINEAR))
2745 stridea *= 2;
2746
2747 if (!(formatb & PNG_FORMAT_FLAG_COLORMAP) &&
2748 (formatb & PNG_FORMAT_FLAG_LINEAR))
2749 strideb *= 2;
2750
2751 if (stridea < 0) rowa += (height-1) * (-stridea);
2752 if (strideb < 0) rowb += (height-1) * (-strideb);
2753
2754 /* First shortcut the two colormap case by comparing the image data; if it
2755 * matches then we expect the colormaps to match, although this is not
2756 * absolutely necessary for an image match. If the colormaps fail to match
2757 * then there is a problem in libpng.
2758 */
2759 if (formata & formatb & PNG_FORMAT_FLAG_COLORMAP)
2760 {
2761 /* Only check colormap entries that actually exist; */
2762 png_const_bytep ppa, ppb;
2763 int match;
2764 png_byte in_use[256], amax = 0, bmax = 0;
2765
2766 memset(in_use, 0, sizeof in_use);
2767
2768 ppa = rowa;
2769 ppb = rowb;
2770
2771 /* Do this the slow way to accumulate the 'in_use' flags, don't break out
2772 * of the loop until the end; this validates the color-mapped data to
2773 * ensure all pixels are valid color-map indexes.
2774 */
2775 for (y=0, match=1; y<height && match; ++y, ppa += stridea, ppb += strideb)
2776 {
2777 png_uint_32 x;
2778
2779 for (x=0; x<width; ++x)
2780 {
2781 png_byte bval = ppb[x];
2782 png_byte aval = ppa[x];
2783
2784 if (bval > bmax)
2785 bmax = bval;
2786
2787 if (bval != aval)
2788 match = 0;
2789
2790 in_use[aval] = 1;
2791 if (aval > amax)
2792 amax = aval;
2793 }
2794 }
2795
2796 /* If the buffers match then the colormaps must too. */
2797 if (match)
2798 {
2799 /* Do the color-maps match, entry by entry? Only check the 'in_use'
2800 * entries. An error here should be logged as a color-map error.
2801 */
2802 png_const_bytep a_cmap = (png_const_bytep)a->colormap;
2803 png_const_bytep b_cmap = (png_const_bytep)b->colormap;
2804 int result = 1; /* match by default */
2805
2806 /* This is used in logpixel to get the error message correct. */
2807 tr.is_palette = 1;
2808
2809 for (y=0; y<256; ++y, a_cmap += a_sample, b_cmap += b_sample)
2810 if (in_use[y])
2811 {
2812 /* The colormap entries should be valid, but because libpng doesn't
2813 * do any checking at present the original image may contain invalid
2814 * pixel values. These cause an error here (at present) unless
2815 * accumulating errors in which case the program just ignores them.
2816 */
2817 if (y >= a->image.colormap_entries)
2818 {
2819 if ((a->opts & ACCUMULATE) == 0)
2820 {
2821 char pindex[9];
2822 sprintf(pindex, "%lu[%lu]", (unsigned long)y,
2823 (unsigned long)a->image.colormap_entries);
2824 logerror(a, a->file_name, ": bad pixel index: ", pindex);
2825 }
2826 result = 0;
2827 }
2828
2829 else if (y >= b->image.colormap_entries)
2830 {
2831 if ((a->opts & ACCUMULATE) == 0)
2832 {
2833 char pindex[9];
2834 sprintf(pindex, "%lu[%lu]", (unsigned long)y,
2835 (unsigned long)b->image.colormap_entries);
2836 logerror(b, b->file_name, ": bad pixel index: ", pindex);
2837 }
2838 result = 0;
2839 }
2840
2841 /* All the mismatches are logged here; there can only be 256! */
2842 else if (!cmppixel(&tr, a_cmap, b_cmap, 0, y))
2843 result = 0;
2844 }
2845
2846 /* If reqested copy the error values back from the Transform. */
2847 if (a->opts & ACCUMULATE)
2848 {
2849 tr.error_ptr[0] = tr.error[0];
2850 tr.error_ptr[1] = tr.error[1];
2851 tr.error_ptr[2] = tr.error[2];
2852 tr.error_ptr[3] = tr.error[3];
2853 result = 1; /* force a continue */
2854 }
2855
2856 return result;
2857 }
2858
2859 /* else the image buffers don't match pixel-wise so compare sample values
2860 * instead, but first validate that the pixel indexes are in range (but
2861 * only if not accumulating, when the error is ignored.)
2862 */
2863 else if ((a->opts & ACCUMULATE) == 0)
2864 {
2865 /* Check the original image first,
2866 * TODO: deal with input images with bad pixel values?
2867 */
2868 if (amax >= a->image.colormap_entries)
2869 {
2870 char pindex[9];
2871 sprintf(pindex, "%d[%lu]", amax,
2872 (unsigned long)a->image.colormap_entries);
2873 return logerror(a, a->file_name, ": bad pixel index: ", pindex);
2874 }
2875
2876 else if (bmax >= b->image.colormap_entries)
2877 {
2878 char pindex[9];
2879 sprintf(pindex, "%d[%lu]", bmax,
2880 (unsigned long)b->image.colormap_entries);
2881 return logerror(b, b->file_name, ": bad pixel index: ", pindex);
2882 }
2883 }
2884 }
2885
2886 /* We can directly compare pixel values without the need to use the read
2887 * or transform support (i.e. a memory compare) if:
2888 *
2889 * 1) The bit depth has not changed.
2890 * 2) RGB to grayscale has not been done (the reverse is ok; we just compare
2891 * the three RGB values to the original grayscale.)
2892 * 3) An alpha channel has not been removed from an 8-bit format, or the
2893 * 8-bit alpha value of the pixel was 255 (opaque).
2894 *
2895 * If an alpha channel has been *added* then it must have the relevant opaque
2896 * value (255 or 65535).
2897 *
2898 * The fist two the tests (in the order given above) (using the boolean
2899 * equivalence !a && !b == !(a || b))
2900 */
2901 if (!(((formata ^ formatb) & PNG_FORMAT_FLAG_LINEAR) |
2902 (formata & (formatb ^ PNG_FORMAT_FLAG_COLOR) & PNG_FORMAT_FLAG_COLOR)))
2903 {
2904 /* Was an alpha channel changed? */
2905 const png_uint_32 alpha_changed = (formata ^ formatb) &
2906 PNG_FORMAT_FLAG_ALPHA;
2907
2908 /* Was an alpha channel removed? (The third test.) If so the direct
2909 * comparison is only possible if the input alpha is opaque.
2910 */
2911 alpha_removed = (formata & alpha_changed) != 0;
2912
2913 /* Was an alpha channel added? */
2914 alpha_added = (formatb & alpha_changed) != 0;
2915
2916 /* The channels may have been moved between input and output, this finds
2917 * out how, recording the result in the btoa array, which says where in
2918 * 'a' to find each channel of 'b'. If alpha was added then btoa[alpha]
2919 * ends up as 4 (and is not used.)
2920 */
2921 {
2922 int i;
2923 png_byte aloc[4];
2924 png_byte bloc[4];
2925
2926 /* The following are used only if the formats match, except that
2927 * 'bchannels' is a flag for matching formats. btoa[x] says, for each
2928 * channel in b, where to find the corresponding value in a, for the
2929 * bchannels. achannels may be different for a gray to rgb transform
2930 * (a will be 1 or 2, b will be 3 or 4 channels.)
2931 */
2932 (void)component_loc(aloc, formata);
2933 bchannels = component_loc(bloc, formatb);
2934
2935 /* Hence the btoa array. */
2936 for (i=0; i<4; ++i) if (bloc[i] < 4)
2937 btoa[bloc[i]] = aloc[i]; /* may be '4' for alpha */
2938
2939 if (alpha_added)
2940 alpha_added = bloc[0]; /* location of alpha channel in image b */
2941
2942 else
2943 alpha_added = 4; /* Won't match an image b channel */
2944
2945 if (alpha_removed)
2946 alpha_removed = aloc[0]; /* location of alpha channel in image a */
2947
2948 else
2949 alpha_removed = 4;
2950 }
2951 }
2952
2953 else
2954 {
2955 /* Direct compare is not possible, cancel out all the corresponding local
2956 * variables.
2957 */
2958 bchannels = 0;
2959 alpha_removed = alpha_added = 4;
2960 btoa[3] = btoa[2] = btoa[1] = btoa[0] = 4; /* 4 == not present */
2961 }
2962
2963 for (y=0; y<height; ++y, rowa += stridea, rowb += strideb)
2964 {
2965 png_const_bytep ppa, ppb;
2966 png_uint_32 x;
2967
2968 for (x=0, ppa=rowa, ppb=rowb; x<width; ++x)
2969 {
2970 png_const_bytep psa, psb;
2971
2972 if (formata & PNG_FORMAT_FLAG_COLORMAP)
2973 psa = (png_const_bytep)a->colormap + a_sample * *ppa++;
2974 else
2975 psa = ppa, ppa += a_sample;
2976
2977 if (formatb & PNG_FORMAT_FLAG_COLORMAP)
2978 psb = (png_const_bytep)b->colormap + b_sample * *ppb++;
2979 else
2980 psb = ppb, ppb += b_sample;
2981
2982 /* Do the fast test if possible. */
2983 if (bchannels)
2984 {
2985 /* Check each 'b' channel against either the corresponding 'a'
2986 * channel or the opaque alpha value, as appropriate. If
2987 * alpha_removed value is set (not 4) then also do this only if the
2988 * 'a' alpha channel (alpha_removed) is opaque; only relevant for
2989 * the 8-bit case.
2990 */
2991 if (formatb & PNG_FORMAT_FLAG_LINEAR) /* 16-bit checks */
2992 {
2993 png_const_uint_16p pua = aligncastconst(png_const_uint_16p, psa);
2994 png_const_uint_16p pub = aligncastconst(png_const_uint_16p, psb);
2995
2996 switch (bchannels)
2997 {
2998 case 4:
2999 if (pua[btoa[3]] != pub[3]) break;
3000 case 3:
3001 if (pua[btoa[2]] != pub[2]) break;
3002 case 2:
3003 if (pua[btoa[1]] != pub[1]) break;
3004 case 1:
3005 if (pua[btoa[0]] != pub[0]) break;
3006 if (alpha_added != 4 && pub[alpha_added] != 65535) break;
3007 continue; /* x loop */
3008 default:
3009 break; /* impossible */
3010 }
3011 }
3012
3013 else if (alpha_removed == 4 || psa[alpha_removed] == 255)
3014 {
3015 switch (bchannels)
3016 {
3017 case 4:
3018 if (psa[btoa[3]] != psb[3]) break;
3019 case 3:
3020 if (psa[btoa[2]] != psb[2]) break;
3021 case 2:
3022 if (psa[btoa[1]] != psb[1]) break;
3023 case 1:
3024 if (psa[btoa[0]] != psb[0]) break;
3025 if (alpha_added != 4 && psb[alpha_added] != 255) break;
3026 continue; /* x loop */
3027 default:
3028 break; /* impossible */
3029 }
3030 }
3031 }
3032
3033 /* If we get to here the fast match failed; do the slow match for this
3034 * pixel.
3035 */
3036 if (!cmppixel(&tr, psa, psb, x, y) && (a->opts & KEEP_GOING) == 0)
3037 return 0; /* error case */
3038 }
3039 }
3040
3041 /* If reqested copy the error values back from the Transform. */
3042 if (a->opts & ACCUMULATE)
3043 {
3044 tr.error_ptr[0] = tr.error[0];
3045 tr.error_ptr[1] = tr.error[1];
3046 tr.error_ptr[2] = tr.error[2];
3047 tr.error_ptr[3] = tr.error[3];
3048 }
3049
3050 return 1;
3051 }
3052
3053 /* Read the file; how the read gets done depends on which of input_file and
3054 * input_memory have been set.
3055 */
3056 static int
3057 read_file(Image *image, png_uint_32 format, png_const_colorp background)
3058 {
3059 memset(&image->image, 0, sizeof image->image);
3060 image->image.version = PNG_IMAGE_VERSION;
3061
3062 if (image->input_memory != NULL)
3063 {
3064 if (!png_image_begin_read_from_memory(&image->image, image->input_memory,
3065 image->input_memory_size))
3066 return logerror(image, "memory init: ", image->file_name, "");
3067 }
3068
3069 # ifdef PNG_STDIO_SUPPORTED
3070 else if (image->input_file != NULL)
3071 {
3072 if (!png_image_begin_read_from_stdio(&image->image, image->input_file))
3073 return logerror(image, "stdio init: ", image->file_name, "");
3074 }
3075
3076 else
3077 {
3078 if (!png_image_begin_read_from_file(&image->image, image->file_name))
3079 return logerror(image, "file init: ", image->file_name, "");
3080 }
3081 # else
3082 else
3083 {
3084 return logerror(image, "unsupported file/stdio init: ",
3085 image->file_name, "");
3086 }
3087 # endif
3088
3089 /* This must be set after the begin_read call: */
3090 if (image->opts & sRGB_16BIT)
3091 image->image.flags |= PNG_IMAGE_FLAG_16BIT_sRGB;
3092
3093 /* Have an initialized image with all the data we need plus, maybe, an
3094 * allocated file (myfile) or buffer (mybuffer) that need to be freed.
3095 */
3096 {
3097 int result;
3098 png_uint_32 image_format;
3099
3100 /* Print both original and output formats. */
3101 image_format = image->image.format;
3102
3103 if (image->opts & VERBOSE)
3104 {
3105 printf("%s %lu x %lu %s -> %s", image->file_name,
3106 (unsigned long)image->image.width,
3107 (unsigned long)image->image.height,
3108 format_names[image_format & FORMAT_MASK],
3109 (format & FORMAT_NO_CHANGE) != 0 || image->image.format == format
3110 ? "no change" : format_names[format & FORMAT_MASK]);
3111
3112 if (background != NULL)
3113 printf(" background(%d,%d,%d)\n", background->red,
3114 background->green, background->blue);
3115 else
3116 printf("\n");
3117
3118 fflush(stdout);
3119 }
3120
3121 /* 'NO_CHANGE' combined with the color-map flag forces the base format
3122 * flags to be set on read to ensure that the original representation is
3123 * not lost in the pass through a colormap format.
3124 */
3125 if ((format & FORMAT_NO_CHANGE) != 0)
3126 {
3127 if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0 &&
3128 (image_format & PNG_FORMAT_FLAG_COLORMAP) != 0)
3129 format = (image_format & ~BASE_FORMATS) | (format & BASE_FORMATS);
3130
3131 else
3132 format = image_format;
3133 }
3134
3135 image->image.format = format;
3136
3137 image->stride = PNG_IMAGE_ROW_STRIDE(image->image) + image->stride_extra;
3138 allocbuffer(image);
3139
3140 result = png_image_finish_read(&image->image, background,
3141 image->buffer+16, (png_int_32)image->stride, image->colormap);
3142
3143 checkbuffer(image, image->file_name);
3144
3145 if (result)
3146 return checkopaque(image);
3147
3148 else
3149 return logerror(image, image->file_name, ": image read failed", "");
3150 }
3151 }
3152
3153 /* Reads from a filename, which must be in image->file_name, but uses
3154 * image->opts to choose the method. The file is always read in its native
3155 * format (the one the simplified API suggests).
3156 */
3157 static int
3158 read_one_file(Image *image)
3159 {
3160 if (!(image->opts & READ_FILE) || (image->opts & USE_STDIO))
3161 {
3162 /* memory or stdio. */
3163 FILE *f = fopen(image->file_name, "rb");
3164
3165 if (f != NULL)
3166 {
3167 if (image->opts & READ_FILE)
3168 image->input_file = f;
3169
3170 else /* memory */
3171 {
3172 if (fseek(f, 0, SEEK_END) == 0)
3173 {
3174 long int cb = ftell(f);
3175
3176 if (cb > 0 && (unsigned long int)cb < (size_t)~(size_t)0)
3177 {
3178 png_bytep b = voidcast(png_bytep, malloc((size_t)cb));
3179
3180 if (b != NULL)
3181 {
3182 rewind(f);
3183
3184 if (fread(b, (size_t)cb, 1, f) == 1)
3185 {
3186 fclose(f);
3187 image->input_memory_size = cb;
3188 image->input_memory = b;
3189 }
3190
3191 else
3192 {
3193 free(b);
3194 return logclose(image, f, image->file_name,
3195 ": read failed: ");
3196 }
3197 }
3198
3199 else
3200 return logclose(image, f, image->file_name,
3201 ": out of memory: ");
3202 }
3203
3204 else if (cb == 0)
3205 return logclose(image, f, image->file_name,
3206 ": zero length: ");
3207
3208 else
3209 return logclose(image, f, image->file_name,
3210 ": tell failed: ");
3211 }
3212
3213 else
3214 return logclose(image, f, image->file_name, ": seek failed: ");
3215 }
3216 }
3217
3218 else
3219 return logerror(image, image->file_name, ": open failed: ",
3220 strerror(errno));
3221 }
3222
3223 return read_file(image, FORMAT_NO_CHANGE, NULL);
3224 }
3225
3226 #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
3227 static int
3228 write_one_file(Image *output, Image *image, int convert_to_8bit)
3229 {
3230 if (image->opts & FAST_WRITE)
3231 image->image.flags |= PNG_IMAGE_FLAG_FAST;
3232
3233 if (image->opts & USE_STDIO)
3234 {
3235 FILE *f = tmpfile();
3236
3237 if (f != NULL)
3238 {
3239 if (png_image_write_to_stdio(&image->image, f, convert_to_8bit,
3240 image->buffer+16, (png_int_32)image->stride, image->colormap))
3241 {
3242 if (fflush(f) == 0)
3243 {
3244 rewind(f);
3245 initimage(output, image->opts, "tmpfile", image->stride_extra);
3246 output->input_file = f;
3247 if (!checkopaque(image))
3248 return 0;
3249 }
3250
3251 else
3252 return logclose(image, f, "tmpfile", ": flush: ");
3253 }
3254
3255 else
3256 {
3257 fclose(f);
3258 return logerror(image, "tmpfile", ": write failed", "");
3259 }
3260 }
3261
3262 else
3263 return logerror(image, "tmpfile", ": open: ", strerror(errno));
3264 }
3265
3266 else
3267 {
3268 static int counter = 0;
3269 char name[32];
3270
3271 sprintf(name, "%s%d.png", tmpf, ++counter);
3272
3273 if (png_image_write_to_file(&image->image, name, convert_to_8bit,
3274 image->buffer+16, (png_int_32)image->stride, image->colormap))
3275 {
3276 initimage(output, image->opts, output->tmpfile_name,
3277 image->stride_extra);
3278 /* Afterwards, or freeimage will delete it! */
3279 strcpy(output->tmpfile_name, name);
3280
3281 if (!checkopaque(image))
3282 return 0;
3283 }
3284
3285 else
3286 return logerror(image, name, ": write failed", "");
3287 }
3288
3289 /* 'output' has an initialized temporary image, read this back in and compare
3290 * this against the original: there should be no change since the original
3291 * format was written unmodified unless 'convert_to_8bit' was specified.
3292 * However, if the original image was color-mapped, a simple read will zap
3293 * the linear, color and maybe alpha flags, this will cause spurious failures
3294 * under some circumstances.
3295 */
3296 if (read_file(output, image->image.format | FORMAT_NO_CHANGE, NULL))
3297 {
3298 png_uint_32 original_format = image->image.format;
3299
3300 if (convert_to_8bit)
3301 original_format &= ~PNG_FORMAT_FLAG_LINEAR;
3302
3303 if ((output->image.format & BASE_FORMATS) !=
3304 (original_format & BASE_FORMATS))
3305 return logerror(image, image->file_name, ": format changed on read: ",
3306 output->file_name);
3307
3308 return compare_two_images(image, output, 0/*via linear*/, NULL);
3309 }
3310
3311 else
3312 return logerror(output, output->tmpfile_name,
3313 ": read of new file failed", "");
3314 }
3315 #endif
3316
3317 static int
3318 testimage(Image *image, png_uint_32 opts, format_list *pf)
3319 {
3320 int result;
3321 Image copy;
3322
3323 /* Copy the original data, stealing it from 'image' */
3324 checkopaque(image);
3325 copy = *image;
3326
3327 copy.opts = opts;
3328 copy.buffer = NULL;
3329 copy.bufsize = 0;
3330 copy.allocsize = 0;
3331
3332 image->input_file = NULL;
3333 image->input_memory = NULL;
3334 image->input_memory_size = 0;
3335 image->tmpfile_name[0] = 0;
3336
3337 {
3338 png_uint_32 counter;
3339 Image output;
3340
3341 newimage(&output);
3342
3343 result = 1;
3344
3345 /* Use the low bit of 'counter' to indicate whether or not to do alpha
3346 * removal with a background color or by composting onto the image; this
3347 * step gets skipped if it isn't relevant
3348 */
3349 for (counter=0; counter<2*FORMAT_COUNT; ++counter)
3350 if (format_isset(pf, counter >> 1))
3351 {
3352 png_uint_32 format = counter >> 1;
3353
3354 png_color background_color;
3355 png_colorp background = NULL;
3356
3357 /* If there is a format change that removes the alpha channel then
3358 * the background is relevant. If the output is 8-bit color-mapped
3359 * then a background color *must* be provided, otherwise there are
3360 * two tests to do - one with a color, the other with NULL. The
3361 * NULL test happens second.
3362 */
3363 if ((counter & 1) == 0)
3364 {
3365 if ((format & PNG_FORMAT_FLAG_ALPHA) == 0 &&
3366 (image->image.format & PNG_FORMAT_FLAG_ALPHA) != 0)
3367 {
3368 /* Alpha/transparency will be removed, the background is
3369 * relevant: make it a color the first time
3370 */
3371 random_color(&background_color);
3372 background = &background_color;
3373
3374 /* BUT if the output is to a color-mapped 8-bit format then
3375 * the background must always be a color, so increment 'counter'
3376 * to skip the NULL test.
3377 */
3378 if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0 &&
3379 (format & PNG_FORMAT_FLAG_LINEAR) == 0)
3380 ++counter;
3381 }
3382
3383 /* Otherwise an alpha channel is not being eliminated, just leave
3384 * background NULL and skip the (counter & 1) NULL test.
3385 */
3386 else
3387 ++counter;
3388 }
3389 /* else just use NULL for background */
3390
3391 resetimage(&copy);
3392 copy.opts = opts; /* in case read_file needs to change it */
3393
3394 result = read_file(&copy, format, background);
3395 if (!result)
3396 break;
3397
3398 /* Make sure the file just read matches the original file. */
3399 result = compare_two_images(image, &copy, 0/*via linear*/, background);
3400 if (!result)
3401 break;
3402
3403 # ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
3404 /* Write the *copy* just made to a new file to make sure the write
3405 * side works ok. Check the conversion to sRGB if the copy is
3406 * linear.
3407 */
3408 output.opts = opts;
3409 result = write_one_file(&output, &copy, 0/*convert to 8bit*/);
3410 if (!result)
3411 break;
3412
3413 /* Validate against the original too; the background is needed here
3414 * as well so that compare_two_images knows what color was used.
3415 */
3416 result = compare_two_images(image, &output, 0, background);
3417 if (!result)
3418 break;
3419
3420 if ((format & PNG_FORMAT_FLAG_LINEAR) != 0 &&
3421 (format & PNG_FORMAT_FLAG_COLORMAP) == 0)
3422 {
3423 /* 'output' is linear, convert to the corresponding sRGB format.
3424 */
3425 output.opts = opts;
3426 result = write_one_file(&output, &copy, 1/*convert to 8bit*/);
3427 if (!result)
3428 break;
3429
3430 /* This may involve a conversion via linear; in the ideal world
3431 * this would round-trip correctly, but libpng 1.5.7 is not the
3432 * ideal world so allow a drift (error_via_linear).
3433 *
3434 * 'image' has an alpha channel but 'output' does not then there
3435 * will a strip-alpha-channel operation (because 'output' is
3436 * linear), handle this by composing on black when doing the
3437 * comparison.
3438 */
3439 result = compare_two_images(image, &output, 1/*via_linear*/,
3440 background);
3441 if (!result)
3442 break;
3443 }
3444 # endif /* PNG_SIMPLIFIED_WRITE_SUPPORTED */
3445 }
3446
3447 freeimage(&output);
3448 }
3449
3450 freeimage(&copy);
3451
3452 return result;
3453 }
3454
3455 static int
3456 test_one_file(const char *file_name, format_list *formats, png_uint_32 opts,
3457 int stride_extra, int log_pass)
3458 {
3459 int result;
3460 Image image;
3461
3462 newimage(&image);
3463 initimage(&image, opts, file_name, stride_extra);
3464 result = read_one_file(&image);
3465 if (result)
3466 result = testimage(&image, opts, formats);
3467 freeimage(&image);
3468
3469 /* Ensure that stderr is flushed into any log file */
3470 fflush(stderr);
3471
3472 if (log_pass)
3473 {
3474 if (result)
3475 printf("PASS:");
3476
3477 else
3478 printf("FAIL:");
3479
3480 # ifndef PNG_SIMPLIFIED_WRITE_SUPPORTED
3481 printf(" (no write)");
3482 # endif
3483
3484 print_opts(opts);
3485 printf(" %s\n", file_name);
3486 /* stdout may not be line-buffered if it is piped to a file, so: */
3487 fflush(stdout);
3488 }
3489
3490 else if (!result)
3491 exit(1);
3492
3493 return result;
3494 }
3495
3496 int
3497 main(int argc, char **argv)
3498 {
3499 png_uint_32 opts = FAST_WRITE;
3500 format_list formats;
3501 const char *touch = NULL;
3502 int log_pass = 0;
3503 int redundant = 0;
3504 int stride_extra = 0;
3505 int retval = 0;
3506 int c;
3507
3508 init_sRGB_to_d();
3509 #if 0
3510 init_error_via_linear();
3511 #endif
3512 format_init(&formats);
3513
3514 for (c=1; c<argc; ++c)
3515 {
3516 const char *arg = argv[c];
3517
3518 if (strcmp(arg, "--log") == 0)
3519 log_pass = 1;
3520 else if (strcmp(arg, "--fresh") == 0)
3521 {
3522 memset(gpc_error, 0, sizeof gpc_error);
3523 memset(gpc_error_via_linear, 0, sizeof gpc_error_via_linear);
3524 }
3525 else if (strcmp(arg, "--file") == 0)
3526 # ifdef PNG_STDIO_SUPPORTED
3527 opts |= READ_FILE;
3528 # else
3529 return 77; /* skipped: no support */
3530 # endif
3531 else if (strcmp(arg, "--memory") == 0)
3532 opts &= ~READ_FILE;
3533 else if (strcmp(arg, "--stdio") == 0)
3534 # ifdef PNG_STDIO_SUPPORTED
3535 opts |= USE_STDIO;
3536 # else
3537 return 77; /* skipped: no support */
3538 # endif
3539 else if (strcmp(arg, "--name") == 0)
3540 opts &= ~USE_STDIO;
3541 else if (strcmp(arg, "--verbose") == 0)
3542 opts |= VERBOSE;
3543 else if (strcmp(arg, "--quiet") == 0)
3544 opts &= ~VERBOSE;
3545 else if (strcmp(arg, "--preserve") == 0)
3546 opts |= KEEP_TMPFILES;
3547 else if (strcmp(arg, "--nopreserve") == 0)
3548 opts &= ~KEEP_TMPFILES;
3549 else if (strcmp(arg, "--keep-going") == 0)
3550 opts |= KEEP_GOING;
3551 else if (strcmp(arg, "--fast") == 0)
3552 opts |= FAST_WRITE;
3553 else if (strcmp(arg, "--slow") == 0)
3554 opts &= ~FAST_WRITE;
3555 else if (strcmp(arg, "--accumulate") == 0)
3556 opts |= ACCUMULATE;
3557 else if (strcmp(arg, "--redundant") == 0)
3558 redundant = 1;
3559 else if (strcmp(arg, "--stop") == 0)
3560 opts &= ~KEEP_GOING;
3561 else if (strcmp(arg, "--strict") == 0)
3562 opts |= STRICT;
3563 else if (strcmp(arg, "--sRGB-16bit") == 0)
3564 opts |= sRGB_16BIT;
3565 else if (strcmp(arg, "--linear-16bit") == 0)
3566 opts &= ~sRGB_16BIT;
3567 else if (strcmp(arg, "--tmpfile") == 0)
3568 {
3569 if (c+1 < argc)
3570 {
3571 if (strlen(argv[++c]) >= sizeof tmpf)
3572 {
3573 fflush(stdout);
3574 fprintf(stderr, "%s: %s is too long for a temp file prefix\n",
3575 argv[0], argv[c]);
3576 exit(99);
3577 }
3578
3579 /* Safe: checked above */
3580 strcpy(tmpf, argv[c]);
3581 }
3582
3583 else
3584 {
3585 fflush(stdout);
3586 fprintf(stderr, "%s: %s requires a temporary file prefix\n",
3587 argv[0], arg);
3588 exit(99);
3589 }
3590 }
3591 else if (strcmp(arg, "--touch") == 0)
3592 {
3593 if (c+1 < argc)
3594 touch = argv[++c];
3595
3596 else
3597 {
3598 fflush(stdout);
3599 fprintf(stderr, "%s: %s requires a file name argument\n",
3600 argv[0], arg);
3601 exit(99);
3602 }
3603 }
3604 else if (arg[0] == '+')
3605 {
3606 png_uint_32 format = formatof(arg+1);
3607
3608 if (format > FORMAT_COUNT)
3609 exit(99);
3610
3611 format_set(&formats, format);
3612 }
3613 else if (arg[0] == '-' && arg[1] != 0 && (arg[1] != '0' || arg[2] != 0))
3614 {
3615 fflush(stdout);
3616 fprintf(stderr, "%s: unknown option: %s\n", argv[0], arg);
3617 exit(99);
3618 }
3619 else
3620 {
3621 if (format_is_initial(&formats))
3622 format_default(&formats, redundant);
3623
3624 if (arg[0] == '-')
3625 {
3626 const int term = (arg[1] == '0' ? 0 : '\n');
3627 unsigned int ich = 0;
3628
3629 /* Loop reading files, use a static buffer to simplify this and just
3630 * stop if the name gets to long.
3631 */
3632 static char buffer[4096];
3633
3634 do
3635 {
3636 int ch = getchar();
3637
3638 /* Don't allow '\0' in file names, and terminate with '\n' or,
3639 * for -0, just '\0' (use -print0 to find to make this work!)
3640 */
3641 if (ch == EOF || ch == term || ch == 0)
3642 {
3643 buffer[ich] = 0;
3644
3645 if (ich > 0 && !test_one_file(buffer, &formats, opts,
3646 stride_extra, log_pass))
3647 retval = 1;
3648
3649 if (ch == EOF)
3650 break;
3651
3652 ich = 0;
3653 --ich; /* so that the increment below sets it to 0 again */
3654 }
3655
3656 else
3657 buffer[ich] = (char)ch;
3658 } while (++ich < sizeof buffer);
3659
3660 if (ich)
3661 {
3662 buffer[32] = 0;
3663 buffer[4095] = 0;
3664 fprintf(stderr, "%s...%s: file name too long\n", buffer,
3665 buffer+(4096-32));
3666 exit(99);
3667 }
3668 }
3669
3670 else if (!test_one_file(arg, &formats, opts, stride_extra, log_pass))
3671 retval = 1;
3672 }
3673 }
3674
3675 if (opts & ACCUMULATE)
3676 {
3677 unsigned int in;
3678
3679 printf("static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =\n");
3680 printf("{\n");
3681 for (in=0; in<16; ++in)
3682 {
3683 unsigned int out;
3684 printf(" { /* input: %s */\n ", format_names[in]);
3685 for (out=0; out<16; ++out)
3686 {
3687 unsigned int alpha;
3688 printf(" {");
3689 for (alpha=0; alpha<4; ++alpha)
3690 {
3691 printf(" %d", gpc_error[in][out][alpha]);
3692 if (alpha < 3) putchar(',');
3693 }
3694 printf(" }");
3695 if (out < 15)
3696 {
3697 putchar(',');
3698 if (out % 4 == 3) printf("\n ");
3699 }
3700 }
3701 printf("\n }");
3702
3703 if (in < 15)
3704 putchar(',');
3705 else
3706 putchar('\n');
3707 }
3708 printf("};\n");
3709
3710 printf("static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =\n");
3711 printf("{\n");
3712 for (in=0; in<16; ++in)
3713 {
3714 unsigned int out;
3715 printf(" { /* input: %s */\n ", format_names[in]);
3716 for (out=0; out<4; ++out)
3717 {
3718 unsigned int alpha;
3719 printf(" {");
3720 for (alpha=0; alpha<4; ++alpha)
3721 {
3722 printf(" %d", gpc_error_via_linear[in][out][alpha]);
3723 if (alpha < 3) putchar(',');
3724 }
3725 printf(" }");
3726 if (out < 3)
3727 putchar(',');
3728 }
3729 printf("\n }");
3730
3731 if (in < 15)
3732 putchar(',');
3733 else
3734 putchar('\n');
3735 }
3736 printf("};\n");
3737
3738 printf("static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =\n");
3739 printf("{\n");
3740 for (in=0; in<8; ++in)
3741 {
3742 unsigned int out;
3743 printf(" { /* input: %s */\n ", format_names[in]);
3744 for (out=0; out<8; ++out)
3745 {
3746 unsigned int alpha;
3747 printf(" {");
3748 for (alpha=0; alpha<4; ++alpha)
3749 {
3750 printf(" %d", gpc_error_to_colormap[in][out][alpha]);
3751 if (alpha < 3) putchar(',');
3752 }
3753 printf(" }");
3754 if (out < 7)
3755 {
3756 putchar(',');
3757 if (out % 4 == 3) printf("\n ");
3758 }
3759 }
3760 printf("\n }");
3761
3762 if (in < 7)
3763 putchar(',');
3764 else
3765 putchar('\n');
3766 }
3767 printf("};\n");
3768 }
3769
3770 if (retval == 0 && touch != NULL)
3771 {
3772 FILE *fsuccess = fopen(touch, "wt");
3773
3774 if (fsuccess != NULL)
3775 {
3776 int error = 0;
3777 fprintf(fsuccess, "PNG simple API tests succeeded\n");
3778 fflush(fsuccess);
3779 error = ferror(fsuccess);
3780
3781 if (fclose(fsuccess) || error)
3782 {
3783 fflush(stdout);
3784 fprintf(stderr, "%s: write failed\n", touch);
3785 exit(99);
3786 }
3787 }
3788
3789 else
3790 {
3791 fflush(stdout);
3792 fprintf(stderr, "%s: open failed\n", touch);
3793 exit(99);
3794 }
3795 }
3796
3797 return retval;
3798 }
3799
3800 #else /* !PNG_SIMPLIFIED_READ_SUPPORTED */
3801 int main(void)
3802 {
3803 fprintf(stderr, "pngstest: no read support in libpng, test skipped\n");
3804 /* So the test is skipped: */
3805 return 77;
3806 }
3807 #endif /* PNG_SIMPLIFIED_READ_SUPPORTED */
Nit language project; an oo programing language and its tool suite.