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