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