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