2 /* pngvalid.c - validate libpng by constructing then reading png files.
4 * Last changed in libpng 1.6.21 [January 15, 2016]
5 * Copyright (c) 2014-2016 Glenn Randers-Pehrson
6 * Written by John Cunningham Bowler
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
13 * This is a C program that is intended to be linked against libpng. It
14 * generates bitmaps internally, stores them as PNG files (using the
15 * sequential write code) then reads them back (using the sequential
16 * read code) and validates that the result has the correct data.
18 * The program can be modified and extended to test the correctness of
19 * transformations performed by libpng.
22 #define _POSIX_SOURCE 1
23 #define _ISOC99_SOURCE 1 /* For floating point */
24 #define _GNU_SOURCE 1 /* For the floating point exception extension */
29 #if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
33 #ifdef HAVE_FEENABLEEXCEPT /* from config.h, if included */
38 # define FE_DIVBYZERO 0
44 # define FE_OVERFLOW 0
47 /* Define the following to use this test against your installed libpng, rather
48 * than the one being built here:
50 #ifdef PNG_FREESTANDING_TESTS
53 # include "../../png.h"
56 #ifdef PNG_ZLIB_HEADER
57 # include PNG_ZLIB_HEADER
59 # include <zlib.h> /* For crc32 */
62 /* 1.6.1 added support for the configure test harness, which uses 77 to indicate
63 * a skipped test, in earlier versions we need to succeed on a skipped test, so:
65 #if PNG_LIBPNG_VER < 10601
71 /* pngvalid requires write support and one of the fixed or floating point APIs.
73 #if defined(PNG_WRITE_SUPPORTED) &&\
74 (defined(PNG_FIXED_POINT_SUPPORTED) || defined(PNG_FLOATING_POINT_SUPPORTED))
76 #if PNG_LIBPNG_VER < 10500
77 /* This deliberately lacks the const. */
78 typedef png_byte *png_const_bytep;
80 /* This is copied from 1.5.1 png.h: */
81 #define PNG_INTERLACE_ADAM7_PASSES 7
82 #define PNG_PASS_START_ROW(pass) (((1U&~(pass))<<(3-((pass)>>1)))&7)
83 #define PNG_PASS_START_COL(pass) (((1U& (pass))<<(3-(((pass)+1)>>1)))&7)
84 #define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
85 #define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
86 #define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
87 -1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
88 #define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
89 -1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
90 #define PNG_ROW_FROM_PASS_ROW(yIn, pass) \
91 (((yIn)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
92 #define PNG_COL_FROM_PASS_COL(xIn, pass) \
93 (((xIn)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
94 #define PNG_PASS_MASK(pass,off) ( \
95 ((0x110145AFU>>(((7-(off))-(pass))<<2)) & 0xFU) | \
96 ((0x01145AF0U>>(((7-(off))-(pass))<<2)) & 0xF0U))
97 #define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
98 ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
99 #define PNG_COL_IN_INTERLACE_PASS(x, pass) \
100 ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
102 /* These are needed too for the default build: */
103 #define PNG_WRITE_16BIT_SUPPORTED
104 #define PNG_READ_16BIT_SUPPORTED
106 /* This comes from pnglibconf.h afer 1.5: */
107 #define PNG_FP_1 100000
108 #define PNG_GAMMA_THRESHOLD_FIXED\
109 ((png_fixed_point)(PNG_GAMMA_THRESHOLD * PNG_FP_1))
112 #if PNG_LIBPNG_VER < 10600
113 /* 1.6.0 constifies many APIs, the following exists to allow pngvalid to be
114 * compiled against earlier versions.
116 # define png_const_structp png_structp
119 #ifndef RELEASE_BUILD
120 /* RELEASE_BUILD is true for releases and release candidates: */
121 # define RELEASE_BUILD (PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC)
124 # define debugonly(something)
125 #else /* !RELEASE_BUILD */
126 # define debugonly(something) something
127 #endif /* !RELEASE_BUILD */
129 #include <float.h> /* For floating point constants */
130 #include <stdlib.h> /* For malloc */
131 #include <string.h> /* For memcpy, memset */
132 #include <math.h> /* For floor */
134 /* Unused formal parameter errors are removed using the following macro which is
135 * expected to have no bad effects on performance.
138 # if defined(__GNUC__) || defined(_MSC_VER)
139 # define UNUSED(param) (void)param;
141 # define UNUSED(param)
145 /***************************** EXCEPTION HANDLING *****************************/
146 #ifdef PNG_FREESTANDING_TESTS
147 # include <cexcept.h>
149 # include "../visupng/cexcept.h"
153 # define this not_the_cpp_this
154 # define new not_the_cpp_new
155 # define voidcast(type, value) static_cast<type>(value)
157 # define voidcast(type, value) (value)
158 #endif /* __cplusplus */
161 define_exception_type(struct png_store*);
163 /* The following are macros to reduce typing everywhere where the well known
164 * name 'the_exception_context' must be defined.
166 #define anon_context(ps) struct exception_context *the_exception_context = \
167 &(ps)->exception_context
168 #define context(ps,fault) anon_context(ps); png_store *fault
170 /* This macro returns the number of elements in an array as an (unsigned int),
171 * it is necessary to avoid the inability of certain versions of GCC to use
172 * the value of a compile-time constant when performing range checks. It must
173 * be passed an array name.
175 #define ARRAY_SIZE(a) ((unsigned int)((sizeof (a))/(sizeof (a)[0])))
177 /* GCC BUG 66447 (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66447) requires
178 * some broken GCC versions to be fixed up to avoid invalid whining about auto
179 * variables that are *not* changed within the scope of a setjmp being changed.
181 * Feel free to extend the list of broken versions.
183 #define is_gnu(major,minor)\
184 (defined __GNUC__) && __GNUC__ == (major) && __GNUC_MINOR__ == (minor)
185 #define is_gnu_patch(major,minor,patch)\
186 is_gnu(major,minor) && __GNUC_PATCHLEVEL__ == 0
187 /* For the moment just do it always; all versions of GCC seem to be broken: */
189 const void * volatile make_volatile_for_gnu;
190 # define gnu_volatile(x) make_volatile_for_gnu = &x;
191 #else /* !GNUC broken versions */
192 # define gnu_volatile(x)
193 #endif /* !GNUC broken versions */
195 /******************************* UTILITIES ************************************/
196 /* Error handling is particularly problematic in production code - error
197 * handlers often themselves have bugs which lead to programs that detect
198 * minor errors crashing. The following functions deal with one very
199 * common class of errors in error handlers - attempting to format error or
200 * warning messages into buffers that are too small.
202 static size_t safecat(char *buffer, size_t bufsize, size_t pos,
205 while (pos < bufsize && cat != NULL && *cat != 0)
206 buffer[pos++] = *cat++;
215 static size_t safecatn(char *buffer, size_t bufsize, size_t pos, int n)
218 sprintf(number, "%d", n);
219 return safecat(buffer, bufsize, pos, number);
222 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
223 static size_t safecatd(char *buffer, size_t bufsize, size_t pos, double d,
227 sprintf(number, "%.*f", precision, d);
228 return safecat(buffer, bufsize, pos, number);
232 static const char invalid[] = "invalid";
233 static const char sep[] = ": ";
235 static const char *colour_types[8] =
237 "grayscale", invalid, "truecolour", "indexed-colour",
238 "grayscale with alpha", invalid, "truecolour with alpha", invalid
241 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
242 /* Convert a double precision value to fixed point. */
243 static png_fixed_point
246 d = floor(d * PNG_FP_1 + .5);
247 return (png_fixed_point)d;
249 #endif /* PNG_READ_SUPPORTED */
251 /* Generate random bytes. This uses a boring repeatable algorithm and it
252 * is implemented here so that it gives the same set of numbers on every
253 * architecture. It's a linear congruential generator (Knuth or Sedgewick
254 * "Algorithms") but it comes from the 'feedback taps' table in Horowitz and
255 * Hill, "The Art of Electronics" (Pseudo-Random Bit Sequences and Noise
259 make_random_bytes(png_uint_32* seed, void* pv, size_t size)
261 png_uint_32 u0 = seed[0], u1 = seed[1];
262 png_bytep bytes = voidcast(png_bytep, pv);
264 /* There are thirty three bits, the next bit in the sequence is bit-33 XOR
265 * bit-20. The top 1 bit is in u1, the bottom 32 are in u0.
268 for (i=0; i<size; ++i)
270 /* First generate 8 new bits then shift them in at the end. */
271 png_uint_32 u = ((u0 >> (20-8)) ^ ((u1 << 7) | (u0 >> (32-7)))) & 0xff;
276 *bytes++ = (png_byte)u;
284 make_four_random_bytes(png_uint_32* seed, png_bytep bytes)
286 make_random_bytes(seed, bytes, 4);
289 #if defined PNG_READ_SUPPORTED || defined PNG_WRITE_tRNS_SUPPORTED ||\
290 defined PNG_WRITE_FILTER_SUPPORTED
292 randomize(void *pv, size_t size)
294 static png_uint_32 random_seed[2] = {0x56789abc, 0xd};
295 make_random_bytes(random_seed, pv, size);
298 #define R8(this) randomize(&(this), sizeof (this))
300 static void r16(png_uint_16p p16, size_t count)
304 for (i=0; i<count; ++i)
307 randomize(b2, sizeof b2);
308 *p16++ = png_get_uint_16(b2);
314 r16(&(this), (sizeof (this))/2U/*(sizeof (png_uint_16))*/)
317 r16(&(this), (sizeof (this))/(sizeof (png_uint_16)))
320 #if defined PNG_READ_RGB_TO_GRAY_SUPPORTED ||\
321 defined PNG_READ_FILLER_SUPPORTED
322 static void r32(png_uint_32p p32, size_t count)
326 for (i=0; i<count; ++i)
329 randomize(b4, sizeof b4);
330 *p32++ = png_get_uint_32(b4);
336 r32(&(this), (sizeof (this))/4U/*(sizeof (png_uint_32))*/)
339 r32(&(this), (sizeof (this))/(sizeof (png_uint_32)))
342 #endif /* READ_FILLER || READ_RGB_TO_GRAY */
344 #endif /* READ || WRITE_tRNS || WRITE_FILTER */
346 #if defined PNG_READ_TRANSFORMS_SUPPORTED ||\
347 defined PNG_WRITE_FILTER_SUPPORTED
349 random_mod(unsigned int max)
355 return x % max; /* 0 .. max-1 */
357 #endif /* READ_TRANSFORMS || WRITE_FILTER */
359 #if (defined PNG_READ_RGB_TO_GRAY_SUPPORTED) ||\
360 (defined PNG_READ_FILLER_SUPPORTED)
370 #endif /* READ_RGB_TO_GRAY || READ_FILLER */
372 /* A numeric ID based on PNG file characteristics. The 'do_interlace' field
373 * simply records whether pngvalid did the interlace itself or whether it
374 * was done by libpng. Width and height must be less than 256. 'palette' is an
375 * index of the palette to use for formats with a palette otherwise a boolean
376 * indicating if a tRNS chunk was generated.
378 #define FILEID(col, depth, palette, interlace, width, height, do_interlace) \
379 ((png_uint_32)((col) + ((depth)<<3) + ((palette)<<8) + ((interlace)<<13) + \
380 (((do_interlace)!=0)<<15) + ((width)<<16) + ((height)<<24)))
382 #define COL_FROM_ID(id) ((png_byte)((id)& 0x7U))
383 #define DEPTH_FROM_ID(id) ((png_byte)(((id) >> 3) & 0x1fU))
384 #define PALETTE_FROM_ID(id) (((id) >> 8) & 0x1f)
385 #define INTERLACE_FROM_ID(id) ((png_byte)(((id) >> 13) & 0x3))
386 #define DO_INTERLACE_FROM_ID(id) ((int)(((id)>>15) & 1))
387 #define WIDTH_FROM_ID(id) (((id)>>16) & 0xff)
388 #define HEIGHT_FROM_ID(id) (((id)>>24) & 0xff)
390 /* Utility to construct a standard name for a standard image. */
392 standard_name(char *buffer, size_t bufsize, size_t pos, png_byte colour_type,
393 int bit_depth, unsigned int npalette, int interlace_type,
394 png_uint_32 w, png_uint_32 h, int do_interlace)
396 pos = safecat(buffer, bufsize, pos, colour_types[colour_type]);
397 if (colour_type == 3) /* must have a palette */
399 pos = safecat(buffer, bufsize, pos, "[");
400 pos = safecatn(buffer, bufsize, pos, npalette);
401 pos = safecat(buffer, bufsize, pos, "]");
404 else if (npalette != 0)
405 pos = safecat(buffer, bufsize, pos, "+tRNS");
407 pos = safecat(buffer, bufsize, pos, " ");
408 pos = safecatn(buffer, bufsize, pos, bit_depth);
409 pos = safecat(buffer, bufsize, pos, " bit");
411 if (interlace_type != PNG_INTERLACE_NONE)
413 pos = safecat(buffer, bufsize, pos, " interlaced");
415 pos = safecat(buffer, bufsize, pos, "(pngvalid)");
417 pos = safecat(buffer, bufsize, pos, "(libpng)");
422 pos = safecat(buffer, bufsize, pos, " ");
423 pos = safecatn(buffer, bufsize, pos, w);
424 pos = safecat(buffer, bufsize, pos, "x");
425 pos = safecatn(buffer, bufsize, pos, h);
432 standard_name_from_id(char *buffer, size_t bufsize, size_t pos, png_uint_32 id)
434 return standard_name(buffer, bufsize, pos, COL_FROM_ID(id),
435 DEPTH_FROM_ID(id), PALETTE_FROM_ID(id), INTERLACE_FROM_ID(id),
436 WIDTH_FROM_ID(id), HEIGHT_FROM_ID(id), DO_INTERLACE_FROM_ID(id));
439 /* Convenience API and defines to list valid formats. Note that 16 bit read and
440 * write support is required to do 16 bit read tests (we must be able to make a
441 * 16 bit image to test!)
443 #ifdef PNG_WRITE_16BIT_SUPPORTED
444 # define WRITE_BDHI 4
445 # ifdef PNG_READ_16BIT_SUPPORTED
450 # define WRITE_BDHI 3
456 /* The following defines the number of different palettes to generate for
457 * each log bit depth of a colour type 3 standard image.
459 #define PALETTE_COUNT(bit_depth) ((bit_depth) > 4 ? 1U : 16U)
462 next_format(png_bytep colour_type, png_bytep bit_depth,
463 unsigned int* palette_number, int low_depth_gray, int tRNS)
476 if (*colour_type < 4/*no alpha channel*/)
478 /* Add multiple palettes for colour type 3, one image with tRNS
479 * and one without for other non-alpha formats:
481 unsigned int pn = ++*palette_number;
482 png_byte ct = *colour_type;
484 if (((ct == 0/*GRAY*/ || ct/*RGB*/ == 2) && tRNS && pn < 2) ||
485 (ct == 3/*PALETTE*/ && pn < PALETTE_COUNT(*bit_depth)))
488 /* No: next bit depth */
492 *bit_depth = (png_byte)(*bit_depth << 1);
494 /* Palette images are restricted to 8 bit depth */
497 || (*colour_type != 3 && *bit_depth <= 16)
502 /* Move to the next color type, or return 0 at the end. */
503 switch (*colour_type)
530 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
532 sample(png_const_bytep row, png_byte colour_type, png_byte bit_depth,
533 png_uint_32 x, unsigned int sample_index, int swap16, int littleendian)
535 png_uint_32 bit_index, result;
537 /* Find a sample index for the desired sample: */
541 if ((colour_type & 1) == 0) /* !palette */
547 bit_index += x; /* Alpha channel */
549 /* Multiple channels; select one: */
550 if (colour_type & (2+4))
551 bit_index += sample_index * bit_depth;
554 /* Return the sample from the row as an integer. */
555 row += bit_index >> 3;
561 else if (bit_depth > 8)
564 return (*++row << 8) + result;
566 return (result << 8) + *++row;
569 /* Less than 8 bits per sample. By default PNG has the big end of
570 * the egg on the left of the screen, but if littleendian is set
571 * then the big end is on the right.
576 bit_index = 8-bit_index-bit_depth;
578 return (result >> bit_index) & ((1U<<bit_depth)-1);
580 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
582 /* Copy a single pixel, of a given size, from one buffer to another -
583 * while this is basically bit addressed there is an implicit assumption
584 * that pixels 8 or more bits in size are byte aligned and that pixels
585 * do not otherwise cross byte boundaries. (This is, so far as I know,
586 * universally true in bitmap computer graphics. [JCB 20101212])
588 * NOTE: The to and from buffers may be the same.
591 pixel_copy(png_bytep toBuffer, png_uint_32 toIndex,
592 png_const_bytep fromBuffer, png_uint_32 fromIndex, unsigned int pixelSize,
595 /* Assume we can multiply by 'size' without overflow because we are
596 * just working in a single buffer.
598 toIndex *= pixelSize;
599 fromIndex *= pixelSize;
600 if (pixelSize < 8) /* Sub-byte */
602 /* Mask to select the location of the copied pixel: */
603 unsigned int destMask = ((1U<<pixelSize)-1) <<
604 (littleendian ? toIndex&7 : 8-pixelSize-(toIndex&7));
605 /* The following read the entire pixels and clears the extra: */
606 unsigned int destByte = toBuffer[toIndex >> 3] & ~destMask;
607 unsigned int sourceByte = fromBuffer[fromIndex >> 3];
609 /* Don't rely on << or >> supporting '0' here, just in case: */
613 if (fromIndex > 0) sourceByte >>= fromIndex;
614 if ((toIndex & 7) > 0) sourceByte <<= toIndex & 7;
619 if (fromIndex > 0) sourceByte <<= fromIndex;
620 if ((toIndex & 7) > 0) sourceByte >>= toIndex & 7;
623 toBuffer[toIndex >> 3] = (png_byte)(destByte | (sourceByte & destMask));
625 else /* One or more bytes */
626 memmove(toBuffer+(toIndex>>3), fromBuffer+(fromIndex>>3), pixelSize>>3);
629 #ifdef PNG_READ_SUPPORTED
630 /* Copy a complete row of pixels, taking into account potential partial
634 row_copy(png_bytep toBuffer, png_const_bytep fromBuffer, unsigned int bitWidth,
637 memcpy(toBuffer, fromBuffer, bitWidth >> 3);
639 if ((bitWidth & 7) != 0)
643 toBuffer += bitWidth >> 3;
644 fromBuffer += bitWidth >> 3;
646 mask = 0xff << (bitWidth & 7);
648 mask = 0xff >> (bitWidth & 7);
649 *toBuffer = (png_byte)((*toBuffer & mask) | (*fromBuffer & ~mask));
653 /* Compare pixels - they are assumed to start at the first byte in the
657 pixel_cmp(png_const_bytep pa, png_const_bytep pb, png_uint_32 bit_width)
659 #if PNG_LIBPNG_VER < 10506
660 if (memcmp(pa, pb, bit_width>>3) == 0)
664 if ((bit_width & 7) == 0) return 0;
666 /* Ok, any differences? */
667 p = pa[bit_width >> 3];
668 p ^= pb[bit_width >> 3];
670 if (p == 0) return 0;
672 /* There are, but they may not be significant, remove the bits
673 * after the end (the low order bits in PNG.)
678 if (p == 0) return 0;
681 /* From libpng-1.5.6 the overwrite should be fixed, so compare the trailing
684 if (memcmp(pa, pb, (bit_width+7)>>3) == 0)
688 /* Return the index of the changed byte. */
690 png_uint_32 where = 0;
692 while (pa[where] == pb[where]) ++where;
696 #endif /* PNG_READ_SUPPORTED */
698 /*************************** BASIC PNG FILE WRITING ***************************/
699 /* A png_store takes data from the sequential writer or provides data
700 * to the sequential reader. It can also store the result of a PNG
701 * write for later retrieval.
703 #define STORE_BUFFER_SIZE 500 /* arbitrary */
704 typedef struct png_store_buffer
706 struct png_store_buffer* prev; /* NOTE: stored in reverse order */
707 png_byte buffer[STORE_BUFFER_SIZE];
710 #define FILE_NAME_SIZE 64
712 typedef struct store_palette_entry /* record of a single palette entry */
718 } store_palette_entry, store_palette[256];
720 typedef struct png_store_file
722 struct png_store_file* next; /* as many as you like... */
723 char name[FILE_NAME_SIZE];
724 png_uint_32 id; /* must be correct (see FILEID) */
725 png_size_t datacount; /* In this (the last) buffer */
726 png_store_buffer data; /* Last buffer in file */
727 int npalette; /* Number of entries in palette */
728 store_palette_entry* palette; /* May be NULL */
731 /* The following is a pool of memory allocated by a single libpng read or write
734 typedef struct store_pool
736 struct png_store *store; /* Back pointer */
737 struct store_memory *list; /* List of allocated memory */
738 png_byte mark[4]; /* Before and after data */
740 /* Statistics for this run. */
741 png_alloc_size_t max; /* Maximum single allocation */
742 png_alloc_size_t current; /* Current allocation */
743 png_alloc_size_t limit; /* Highest current allocation */
744 png_alloc_size_t total; /* Total allocation */
746 /* Overall statistics (retained across successive runs). */
747 png_alloc_size_t max_max;
748 png_alloc_size_t max_limit;
749 png_alloc_size_t max_total;
752 typedef struct png_store
754 /* For cexcept.h exception handling - simply store one of these;
755 * the context is a self pointer but it may point to a different
756 * png_store (in fact it never does in this program.)
758 struct exception_context
761 unsigned int verbose :1;
762 unsigned int treat_warnings_as_errors :1;
763 unsigned int expect_error :1;
764 unsigned int expect_warning :1;
765 unsigned int saw_warning :1;
766 unsigned int speed :1;
767 unsigned int progressive :1; /* use progressive read */
768 unsigned int validated :1; /* used as a temporary flag */
771 int noptions; /* number of options below: */
773 unsigned char option; /* option number, 0..30 */
774 unsigned char setting; /* setting (unset,invalid,on,off) */
776 char test[128]; /* Name of test */
780 png_structp pread; /* Used to read a saved file */
782 png_store_file* current; /* Set when reading */
783 png_store_buffer* next; /* Set when reading */
784 png_size_t readpos; /* Position in *next */
785 png_byte* image; /* Buffer for reading interlaced images */
786 png_size_t cb_image; /* Size of this buffer */
787 png_size_t cb_row; /* Row size of the image(s) */
788 png_uint_32 image_h; /* Number of rows in a single image */
789 store_pool read_memory_pool;
792 png_store_file* saved;
793 png_structp pwrite; /* Used when writing a new file */
795 png_size_t writepos; /* Position in .new */
796 char wname[FILE_NAME_SIZE];
797 png_store_buffer new; /* The end of the new PNG file being written. */
798 store_pool write_memory_pool;
799 store_palette_entry* palette;
803 /* Initialization and cleanup */
805 store_pool_mark(png_bytep mark)
807 static png_uint_32 store_seed[2] = { 0x12345678, 1};
809 make_four_random_bytes(store_seed, mark);
812 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
813 /* Use this for random 32 bit values; this function makes sure the result is
825 store_pool_mark(mark);
826 result = png_get_uint_32(mark);
832 #endif /* PNG_READ_SUPPORTED */
835 store_pool_init(png_store *ps, store_pool *pool)
837 memset(pool, 0, sizeof *pool);
841 pool->max = pool->current = pool->limit = pool->total = 0;
842 pool->max_max = pool->max_limit = pool->max_total = 0;
843 store_pool_mark(pool->mark);
847 store_init(png_store* ps)
849 memset(ps, 0, sizeof *ps);
850 init_exception_context(&ps->exception_context);
851 store_pool_init(ps, &ps->read_memory_pool);
852 store_pool_init(ps, &ps->write_memory_pool);
854 ps->treat_warnings_as_errors = 0;
855 ps->expect_error = 0;
856 ps->expect_warning = 0;
861 ps->nerrors = ps->nwarnings = 0;
864 ps->saved = ps->current = NULL;
881 store_freebuffer(png_store_buffer* psb)
885 store_freebuffer(psb->prev);
892 store_freenew(png_store *ps)
894 store_freebuffer(&ps->new);
896 if (ps->palette != NULL)
905 store_storenew(png_store *ps)
907 png_store_buffer *pb;
909 if (ps->writepos != STORE_BUFFER_SIZE)
910 png_error(ps->pwrite, "invalid store call");
912 pb = voidcast(png_store_buffer*, malloc(sizeof *pb));
915 png_error(ps->pwrite, "store new: OOM");
923 store_freefile(png_store_file **ppf)
927 store_freefile(&(*ppf)->next);
929 store_freebuffer(&(*ppf)->data);
930 (*ppf)->datacount = 0;
931 if ((*ppf)->palette != NULL)
933 free((*ppf)->palette);
934 (*ppf)->palette = NULL;
935 (*ppf)->npalette = 0;
942 /* Main interface to file storeage, after writing a new PNG file (see the API
943 * below) call store_storefile to store the result with the given name and id.
946 store_storefile(png_store *ps, png_uint_32 id)
948 png_store_file *pf = voidcast(png_store_file*, malloc(sizeof *pf));
950 png_error(ps->pwrite, "storefile: OOM");
951 safecat(pf->name, sizeof pf->name, 0, ps->wname);
954 pf->datacount = ps->writepos;
957 pf->palette = ps->palette;
958 pf->npalette = ps->npalette;
963 pf->next = ps->saved;
967 /* Generate an error message (in the given buffer) */
969 store_message(png_store *ps, png_const_structp pp, char *buffer, size_t bufsize,
970 size_t pos, const char *msg)
972 if (pp != NULL && pp == ps->pread)
975 pos = safecat(buffer, bufsize, pos, "read: ");
977 if (ps->current != NULL)
979 pos = safecat(buffer, bufsize, pos, ps->current->name);
980 pos = safecat(buffer, bufsize, pos, sep);
984 else if (pp != NULL && pp == ps->pwrite)
987 pos = safecat(buffer, bufsize, pos, "write: ");
988 pos = safecat(buffer, bufsize, pos, ps->wname);
989 pos = safecat(buffer, bufsize, pos, sep);
994 /* Neither reading nor writing (or a memory error in struct delete) */
995 pos = safecat(buffer, bufsize, pos, "pngvalid: ");
998 if (ps->test[0] != 0)
1000 pos = safecat(buffer, bufsize, pos, ps->test);
1001 pos = safecat(buffer, bufsize, pos, sep);
1003 pos = safecat(buffer, bufsize, pos, msg);
1007 /* Verbose output to the error stream: */
1009 store_verbose(png_store *ps, png_const_structp pp, png_const_charp prefix,
1010 png_const_charp message)
1015 fputs(prefix, stderr);
1017 (void)store_message(ps, pp, buffer, sizeof buffer, 0, message);
1018 fputs(buffer, stderr);
1019 fputc('\n', stderr);
1022 /* Log an error or warning - the relevant count is always incremented. */
1024 store_log(png_store* ps, png_const_structp pp, png_const_charp message,
1027 /* The warning is copied to the error buffer if there are no errors and it is
1028 * the first warning. The error is copied to the error buffer if it is the
1029 * first error (overwriting any prior warnings).
1031 if (is_error ? (ps->nerrors)++ == 0 :
1032 (ps->nwarnings)++ == 0 && ps->nerrors == 0)
1033 store_message(ps, pp, ps->error, sizeof ps->error, 0, message);
1036 store_verbose(ps, pp, is_error ? "error: " : "warning: ", message);
1039 #ifdef PNG_READ_SUPPORTED
1040 /* Internal error function, called with a png_store but no libpng stuff. */
1042 internal_error(png_store *ps, png_const_charp message)
1044 store_log(ps, NULL, message, 1 /* error */);
1046 /* And finally throw an exception. */
1048 struct exception_context *the_exception_context = &ps->exception_context;
1052 #endif /* PNG_READ_SUPPORTED */
1054 /* Functions to use as PNG callbacks. */
1055 static void PNGCBAPI
1056 store_error(png_structp ppIn, png_const_charp message) /* PNG_NORETURN */
1058 png_const_structp pp = ppIn;
1059 png_store *ps = voidcast(png_store*, png_get_error_ptr(pp));
1061 if (!ps->expect_error)
1062 store_log(ps, pp, message, 1 /* error */);
1064 /* And finally throw an exception. */
1066 struct exception_context *the_exception_context = &ps->exception_context;
1071 static void PNGCBAPI
1072 store_warning(png_structp ppIn, png_const_charp message)
1074 png_const_structp pp = ppIn;
1075 png_store *ps = voidcast(png_store*, png_get_error_ptr(pp));
1077 if (!ps->expect_warning)
1078 store_log(ps, pp, message, 0 /* warning */);
1080 ps->saw_warning = 1;
1083 /* These somewhat odd functions are used when reading an image to ensure that
1084 * the buffer is big enough, the png_structp is for errors.
1086 /* Return a single row from the correct image. */
1088 store_image_row(const png_store* ps, png_const_structp pp, int nImage,
1091 png_size_t coffset = (nImage * ps->image_h + y) * (ps->cb_row + 5) + 2;
1093 if (ps->image == NULL)
1094 png_error(pp, "no allocated image");
1096 if (coffset + ps->cb_row + 3 > ps->cb_image)
1097 png_error(pp, "image too small");
1099 return ps->image + coffset;
1103 store_image_free(png_store *ps, png_const_structp pp)
1105 if (ps->image != NULL)
1107 png_bytep image = ps->image;
1109 if (image[-1] != 0xed || image[ps->cb_image] != 0xfe)
1112 png_error(pp, "png_store image overwrite (1)");
1114 store_log(ps, NULL, "png_store image overwrite (2)", 1);
1125 store_ensure_image(png_store *ps, png_const_structp pp, int nImages,
1126 png_size_t cbRow, png_uint_32 cRows)
1128 png_size_t cb = nImages * cRows * (cbRow + 5);
1130 if (ps->cb_image < cb)
1134 store_image_free(ps, pp);
1136 /* The buffer is deliberately mis-aligned. */
1137 image = voidcast(png_bytep, malloc(cb+2));
1140 /* Called from the startup - ignore the error for the moment. */
1144 png_error(pp, "OOM allocating image buffer");
1147 /* These magic tags are used to detect overwrites above. */
1156 /* We have an adequate sized image; lay out the rows. There are 2 bytes at
1157 * the start and three at the end of each (this ensures that the row
1158 * alignment starts out odd - 2+1 and changes for larger images on each row.)
1161 ps->image_h = cRows;
1163 /* For error checking, the whole buffer is set to 10110010 (0xb2 - 178).
1164 * This deliberately doesn't match the bits in the size test image which are
1165 * outside the image; these are set to 0xff (all 1). To make the row
1166 * comparison work in the 'size' test case the size rows are pre-initialized
1167 * to the same value prior to calling 'standard_row'.
1169 memset(ps->image, 178, cb);
1171 /* Then put in the marks. */
1172 while (--nImages >= 0)
1176 for (y=0; y<cRows; ++y)
1178 png_bytep row = store_image_row(ps, pp, nImages, y);
1190 #ifdef PNG_READ_SUPPORTED
1192 store_image_check(const png_store* ps, png_const_structp pp, int iImage)
1194 png_const_bytep image = ps->image;
1196 if (image[-1] != 0xed || image[ps->cb_image] != 0xfe)
1197 png_error(pp, "image overwrite");
1200 png_size_t cbRow = ps->cb_row;
1201 png_uint_32 rows = ps->image_h;
1203 image += iImage * (cbRow+5) * ps->image_h;
1205 image += 2; /* skip image first row markers */
1209 if (image[-2] != 190 || image[-1] != 239)
1210 png_error(pp, "row start overwritten");
1212 if (image[cbRow] != 222 || image[cbRow+1] != 173 ||
1213 image[cbRow+2] != 17)
1214 png_error(pp, "row end overwritten");
1220 #endif /* PNG_READ_SUPPORTED */
1222 static void PNGCBAPI
1223 store_write(png_structp ppIn, png_bytep pb, png_size_t st)
1225 png_const_structp pp = ppIn;
1226 png_store *ps = voidcast(png_store*, png_get_io_ptr(pp));
1228 if (ps->pwrite != pp)
1229 png_error(pp, "store state damaged");
1235 if (ps->writepos >= STORE_BUFFER_SIZE)
1240 if (cb > STORE_BUFFER_SIZE - ps->writepos)
1241 cb = STORE_BUFFER_SIZE - ps->writepos;
1243 memcpy(ps->new.buffer + ps->writepos, pb, cb);
1250 static void PNGCBAPI
1251 store_flush(png_structp ppIn)
1253 UNUSED(ppIn) /*DOES NOTHING*/
1256 #ifdef PNG_READ_SUPPORTED
1258 store_read_buffer_size(png_store *ps)
1260 /* Return the bytes available for read in the current buffer. */
1261 if (ps->next != &ps->current->data)
1262 return STORE_BUFFER_SIZE;
1264 return ps->current->datacount;
1267 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
1268 /* Return total bytes available for read. */
1270 store_read_buffer_avail(png_store *ps)
1272 if (ps->current != NULL && ps->next != NULL)
1274 png_store_buffer *next = &ps->current->data;
1275 size_t cbAvail = ps->current->datacount;
1277 while (next != ps->next && next != NULL)
1280 cbAvail += STORE_BUFFER_SIZE;
1283 if (next != ps->next)
1284 png_error(ps->pread, "buffer read error");
1286 if (cbAvail > ps->readpos)
1287 return cbAvail - ps->readpos;
1295 store_read_buffer_next(png_store *ps)
1297 png_store_buffer *pbOld = ps->next;
1298 png_store_buffer *pbNew = &ps->current->data;
1301 while (pbNew != NULL && pbNew->prev != pbOld)
1302 pbNew = pbNew->prev;
1311 png_error(ps->pread, "buffer lost");
1314 return 0; /* EOF or error */
1317 /* Need separate implementation and callback to allow use of the same code
1318 * during progressive read, where the io_ptr is set internally by libpng.
1321 store_read_imp(png_store *ps, png_bytep pb, png_size_t st)
1323 if (ps->current == NULL || ps->next == NULL)
1324 png_error(ps->pread, "store state damaged");
1328 size_t cbAvail = store_read_buffer_size(ps) - ps->readpos;
1332 if (cbAvail > st) cbAvail = st;
1333 memcpy(pb, ps->next->buffer + ps->readpos, cbAvail);
1336 ps->readpos += cbAvail;
1339 else if (!store_read_buffer_next(ps))
1340 png_error(ps->pread, "read beyond end of file");
1344 static void PNGCBAPI
1345 store_read(png_structp ppIn, png_bytep pb, png_size_t st)
1347 png_const_structp pp = ppIn;
1348 png_store *ps = voidcast(png_store*, png_get_io_ptr(pp));
1350 if (ps == NULL || ps->pread != pp)
1351 png_error(pp, "bad store read call");
1353 store_read_imp(ps, pb, st);
1357 store_progressive_read(png_store *ps, png_structp pp, png_infop pi)
1359 /* Notice that a call to store_read will cause this function to fail because
1360 * readpos will be set.
1362 if (ps->pread != pp || ps->current == NULL || ps->next == NULL)
1363 png_error(pp, "store state damaged (progressive)");
1367 if (ps->readpos != 0)
1368 png_error(pp, "store_read called during progressive read");
1370 png_process_data(pp, pi, ps->next->buffer, store_read_buffer_size(ps));
1372 while (store_read_buffer_next(ps));
1374 #endif /* PNG_READ_SUPPORTED */
1376 /* The caller must fill this in: */
1377 static store_palette_entry *
1378 store_write_palette(png_store *ps, int npalette)
1380 if (ps->pwrite == NULL)
1381 store_log(ps, NULL, "attempt to write palette without write stream", 1);
1383 if (ps->palette != NULL)
1384 png_error(ps->pwrite, "multiple store_write_palette calls");
1386 /* This function can only return NULL if called with '0'! */
1389 ps->palette = voidcast(store_palette_entry*, malloc(npalette *
1390 sizeof *ps->palette));
1392 if (ps->palette == NULL)
1393 png_error(ps->pwrite, "store new palette: OOM");
1395 ps->npalette = npalette;
1401 #ifdef PNG_READ_SUPPORTED
1402 static store_palette_entry *
1403 store_current_palette(png_store *ps, int *npalette)
1405 /* This is an internal error (the call has been made outside a read
1408 if (ps->current == NULL)
1410 store_log(ps, ps->pread, "no current stream for palette", 1);
1414 /* The result may be null if there is no palette. */
1415 *npalette = ps->current->npalette;
1416 return ps->current->palette;
1418 #endif /* PNG_READ_SUPPORTED */
1420 /***************************** MEMORY MANAGEMENT*** ***************************/
1421 #ifdef PNG_USER_MEM_SUPPORTED
1422 /* A store_memory is simply the header for an allocated block of memory. The
1423 * pointer returned to libpng is just after the end of the header block, the
1424 * allocated memory is followed by a second copy of the 'mark'.
1426 typedef struct store_memory
1428 store_pool *pool; /* Originating pool */
1429 struct store_memory *next; /* Singly linked list */
1430 png_alloc_size_t size; /* Size of memory allocated */
1431 png_byte mark[4]; /* ID marker */
1434 /* Handle a fatal error in memory allocation. This calls png_error if the
1435 * libpng struct is non-NULL, else it outputs a message and returns. This means
1436 * that a memory problem while libpng is running will abort (png_error) the
1437 * handling of particular file while one in cleanup (after the destroy of the
1438 * struct has returned) will simply keep going and free (or attempt to free)
1442 store_pool_error(png_store *ps, png_const_structp pp, const char *msg)
1447 /* Else we have to do it ourselves. png_error eventually calls store_log,
1448 * above. store_log accepts a NULL png_structp - it just changes what gets
1449 * output by store_message.
1451 store_log(ps, pp, msg, 1 /* error */);
1455 store_memory_free(png_const_structp pp, store_pool *pool, store_memory *memory)
1457 /* Note that pp may be NULL (see store_pool_delete below), the caller has
1458 * found 'memory' in pool->list *and* unlinked this entry, so this is a valid
1459 * pointer (for sure), but the contents may have been trashed.
1461 if (memory->pool != pool)
1462 store_pool_error(pool->store, pp, "memory corrupted (pool)");
1464 else if (memcmp(memory->mark, pool->mark, sizeof memory->mark) != 0)
1465 store_pool_error(pool->store, pp, "memory corrupted (start)");
1467 /* It should be safe to read the size field now. */
1470 png_alloc_size_t cb = memory->size;
1473 store_pool_error(pool->store, pp, "memory corrupted (size)");
1475 else if (memcmp((png_bytep)(memory+1)+cb, pool->mark, sizeof pool->mark)
1477 store_pool_error(pool->store, pp, "memory corrupted (end)");
1479 /* Finally give the library a chance to find problems too: */
1482 pool->current -= cb;
1489 store_pool_delete(png_store *ps, store_pool *pool)
1491 if (pool->list != NULL)
1493 fprintf(stderr, "%s: %s %s: memory lost (list follows):\n", ps->test,
1494 pool == &ps->read_memory_pool ? "read" : "write",
1495 pool == &ps->read_memory_pool ? (ps->current != NULL ?
1496 ps->current->name : "unknown file") : ps->wname);
1501 store_memory *next = pool->list;
1502 pool->list = next->next;
1505 fprintf(stderr, "\t%lu bytes @ %p\n",
1506 (unsigned long)next->size, (const void*)(next+1));
1507 /* The NULL means this will always return, even if the memory is
1510 store_memory_free(NULL, pool, next);
1512 while (pool->list != NULL);
1515 /* And reset the other fields too for the next time. */
1516 if (pool->max > pool->max_max) pool->max_max = pool->max;
1518 if (pool->current != 0) /* unexpected internal error */
1519 fprintf(stderr, "%s: %s %s: memory counter mismatch (internal error)\n",
1520 ps->test, pool == &ps->read_memory_pool ? "read" : "write",
1521 pool == &ps->read_memory_pool ? (ps->current != NULL ?
1522 ps->current->name : "unknown file") : ps->wname);
1525 if (pool->limit > pool->max_limit)
1526 pool->max_limit = pool->limit;
1530 if (pool->total > pool->max_total)
1531 pool->max_total = pool->total;
1535 /* Get a new mark too. */
1536 store_pool_mark(pool->mark);
1539 /* The memory callbacks: */
1540 static png_voidp PNGCBAPI
1541 store_malloc(png_structp ppIn, png_alloc_size_t cb)
1543 png_const_structp pp = ppIn;
1544 store_pool *pool = voidcast(store_pool*, png_get_mem_ptr(pp));
1545 store_memory *new = voidcast(store_memory*, malloc(cb + (sizeof *new) +
1546 (sizeof pool->mark)));
1553 pool->current += cb;
1555 if (pool->current > pool->limit)
1556 pool->limit = pool->current;
1561 memcpy(new->mark, pool->mark, sizeof new->mark);
1562 memcpy((png_byte*)(new+1) + cb, pool->mark, sizeof pool->mark);
1564 new->next = pool->list;
1571 /* NOTE: the PNG user malloc function cannot use the png_ptr it is passed
1572 * other than to retrieve the allocation pointer! libpng calls the
1573 * store_malloc callback in two basic cases:
1575 * 1) From png_malloc; png_malloc will do a png_error itself if NULL is
1577 * 2) From png_struct or png_info structure creation; png_malloc is
1578 * to return so cleanup can be performed.
1580 * To handle this store_malloc can log a message, but can't do anything
1583 store_log(pool->store, pp, "out of memory", 1 /* is_error */);
1589 static void PNGCBAPI
1590 store_free(png_structp ppIn, png_voidp memory)
1592 png_const_structp pp = ppIn;
1593 store_pool *pool = voidcast(store_pool*, png_get_mem_ptr(pp));
1594 store_memory *this = voidcast(store_memory*, memory), **test;
1596 /* Because libpng calls store_free with a dummy png_struct when deleting
1597 * png_struct or png_info via png_destroy_struct_2 it is necessary to check
1598 * the passed in png_structp to ensure it is valid, and not pass it to
1599 * png_error if it is not.
1601 if (pp != pool->store->pread && pp != pool->store->pwrite)
1604 /* First check that this 'memory' really is valid memory - it must be in the
1605 * pool list. If it is, use the shared memory_free function to free it.
1608 for (test = &pool->list; *test != this; test = &(*test)->next)
1612 store_pool_error(pool->store, pp, "bad pointer to free");
1617 /* Unlink this entry, *test == this. */
1620 store_memory_free(pp, pool, this);
1622 #endif /* PNG_USER_MEM_SUPPORTED */
1624 /* Setup functions. */
1625 /* Cleanup when aborting a write or after storing the new file. */
1627 store_write_reset(png_store *ps)
1629 if (ps->pwrite != NULL)
1634 png_destroy_write_struct(&ps->pwrite, &ps->piwrite);
1638 /* memory corruption: continue. */
1645 /* And make sure that all the memory has been freed - this will output
1646 * spurious errors in the case of memory corruption above, but this is safe.
1648 # ifdef PNG_USER_MEM_SUPPORTED
1649 store_pool_delete(ps, &ps->write_memory_pool);
1655 /* The following is the main write function, it returns a png_struct and,
1656 * optionally, a png_info suitable for writiing a new PNG file. Use
1657 * store_storefile above to record this file after it has been written. The
1658 * returned libpng structures as destroyed by store_write_reset above.
1661 set_store_for_write(png_store *ps, png_infopp ppi, const char *name)
1667 if (ps->pwrite != NULL)
1668 png_error(ps->pwrite, "write store already in use");
1670 store_write_reset(ps);
1671 safecat(ps->wname, sizeof ps->wname, 0, name);
1673 /* Don't do the slow memory checks if doing a speed test, also if user
1674 * memory is not supported we can't do it anyway.
1676 # ifdef PNG_USER_MEM_SUPPORTED
1678 ps->pwrite = png_create_write_struct_2(PNG_LIBPNG_VER_STRING,
1679 ps, store_error, store_warning, &ps->write_memory_pool,
1680 store_malloc, store_free);
1684 ps->pwrite = png_create_write_struct(PNG_LIBPNG_VER_STRING,
1685 ps, store_error, store_warning);
1687 png_set_write_fn(ps->pwrite, ps, store_write, store_flush);
1689 # ifdef PNG_SET_OPTION_SUPPORTED
1692 for (opt=0; opt<ps->noptions; ++opt)
1693 if (png_set_option(ps->pwrite, ps->options[opt].option,
1694 ps->options[opt].setting) == PNG_OPTION_INVALID)
1695 png_error(ps->pwrite, "png option invalid");
1700 *ppi = ps->piwrite = png_create_info_struct(ps->pwrite);
1709 /* Cleanup when finished reading (either due to error or in the success case).
1710 * This routine exists even when there is no read support to make the code
1711 * tidier (avoid a mass of ifdefs) and so easier to maintain.
1714 store_read_reset(png_store *ps)
1716 # ifdef PNG_READ_SUPPORTED
1717 if (ps->pread != NULL)
1722 png_destroy_read_struct(&ps->pread, &ps->piread, NULL);
1726 /* error already output: continue */
1734 # ifdef PNG_USER_MEM_SUPPORTED
1735 /* Always do this to be safe. */
1736 store_pool_delete(ps, &ps->read_memory_pool);
1745 #ifdef PNG_READ_SUPPORTED
1747 store_read_set(png_store *ps, png_uint_32 id)
1749 png_store_file *pf = ps->saved;
1757 store_read_buffer_next(ps);
1766 char msg[FILE_NAME_SIZE+64];
1768 pos = standard_name_from_id(msg, sizeof msg, 0, id);
1769 pos = safecat(msg, sizeof msg, pos, ": file not found");
1770 png_error(ps->pread, msg);
1774 /* The main interface for reading a saved file - pass the id number of the file
1775 * to retrieve. Ids must be unique or the earlier file will be hidden. The API
1776 * returns a png_struct and, optionally, a png_info. Both of these will be
1777 * destroyed by store_read_reset above.
1780 set_store_for_read(png_store *ps, png_infopp ppi, png_uint_32 id,
1783 /* Set the name for png_error */
1784 safecat(ps->test, sizeof ps->test, 0, name);
1786 if (ps->pread != NULL)
1787 png_error(ps->pread, "read store already in use");
1789 store_read_reset(ps);
1791 /* Both the create APIs can return NULL if used in their default mode
1792 * (because there is no other way of handling an error because the jmp_buf
1793 * by default is stored in png_struct and that has not been allocated!)
1794 * However, given that store_error works correctly in these circumstances
1795 * we don't ever expect NULL in this program.
1797 # ifdef PNG_USER_MEM_SUPPORTED
1799 ps->pread = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, ps,
1800 store_error, store_warning, &ps->read_memory_pool, store_malloc,
1805 ps->pread = png_create_read_struct(PNG_LIBPNG_VER_STRING, ps, store_error,
1808 if (ps->pread == NULL)
1810 struct exception_context *the_exception_context = &ps->exception_context;
1812 store_log(ps, NULL, "png_create_read_struct returned NULL (unexpected)",
1818 # ifdef PNG_SET_OPTION_SUPPORTED
1821 for (opt=0; opt<ps->noptions; ++opt)
1822 if (png_set_option(ps->pread, ps->options[opt].option,
1823 ps->options[opt].setting) == PNG_OPTION_INVALID)
1824 png_error(ps->pread, "png option invalid");
1828 store_read_set(ps, id);
1831 *ppi = ps->piread = png_create_info_struct(ps->pread);
1835 #endif /* PNG_READ_SUPPORTED */
1837 /* The overall cleanup of a store simply calls the above then removes all the
1838 * saved files. This does not delete the store itself.
1841 store_delete(png_store *ps)
1843 store_write_reset(ps);
1844 store_read_reset(ps);
1845 store_freefile(&ps->saved);
1846 store_image_free(ps, NULL);
1849 /*********************** PNG FILE MODIFICATION ON READ ************************/
1850 /* Files may be modified on read. The following structure contains a complete
1851 * png_store together with extra members to handle modification and a special
1852 * read callback for libpng. To use this the 'modifications' field must be set
1853 * to a list of png_modification structures that actually perform the
1854 * modification, otherwise a png_modifier is functionally equivalent to a
1855 * png_store. There is a special read function, set_modifier_for_read, which
1856 * replaces set_store_for_read.
1858 typedef enum modifier_state
1860 modifier_start, /* Initial value */
1861 modifier_signature, /* Have a signature */
1862 modifier_IHDR /* Have an IHDR */
1865 typedef struct CIE_color
1867 /* A single CIE tristimulus value, representing the unique response of a
1868 * standard observer to a variety of light spectra. The observer recognizes
1869 * all spectra that produce this response as the same color, therefore this
1870 * is effectively a description of a color.
1875 typedef struct color_encoding
1877 /* A description of an (R,G,B) encoding of color (as defined above); this
1878 * includes the actual colors of the (R,G,B) triples (1,0,0), (0,1,0) and
1879 * (0,0,1) plus an encoding value that is used to encode the linear
1880 * components R, G and B to give the actual values R^gamma, G^gamma and
1881 * B^gamma that are stored.
1883 double gamma; /* Encoding (file) gamma of space */
1884 CIE_color red, green, blue; /* End points */
1887 #ifdef PNG_READ_SUPPORTED
1888 #if defined PNG_READ_TRANSFORMS_SUPPORTED && defined PNG_READ_cHRM_SUPPORTED
1890 chromaticity_x(CIE_color c)
1892 return c.X / (c.X + c.Y + c.Z);
1896 chromaticity_y(CIE_color c)
1898 return c.Y / (c.X + c.Y + c.Z);
1902 white_point(const color_encoding *encoding)
1906 white.X = encoding->red.X + encoding->green.X + encoding->blue.X;
1907 white.Y = encoding->red.Y + encoding->green.Y + encoding->blue.Y;
1908 white.Z = encoding->red.Z + encoding->green.Z + encoding->blue.Z;
1912 #endif /* READ_TRANSFORMS && READ_cHRM */
1914 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1916 normalize_color_encoding(color_encoding *encoding)
1918 const double whiteY = encoding->red.Y + encoding->green.Y +
1923 encoding->red.X /= whiteY;
1924 encoding->red.Y /= whiteY;
1925 encoding->red.Z /= whiteY;
1926 encoding->green.X /= whiteY;
1927 encoding->green.Y /= whiteY;
1928 encoding->green.Z /= whiteY;
1929 encoding->blue.X /= whiteY;
1930 encoding->blue.Y /= whiteY;
1931 encoding->blue.Z /= whiteY;
1936 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
1938 safecat_color_encoding(char *buffer, size_t bufsize, size_t pos,
1939 const color_encoding *e, double encoding_gamma)
1943 if (encoding_gamma != 0)
1944 pos = safecat(buffer, bufsize, pos, "(");
1945 pos = safecat(buffer, bufsize, pos, "R(");
1946 pos = safecatd(buffer, bufsize, pos, e->red.X, 4);
1947 pos = safecat(buffer, bufsize, pos, ",");
1948 pos = safecatd(buffer, bufsize, pos, e->red.Y, 4);
1949 pos = safecat(buffer, bufsize, pos, ",");
1950 pos = safecatd(buffer, bufsize, pos, e->red.Z, 4);
1951 pos = safecat(buffer, bufsize, pos, "),G(");
1952 pos = safecatd(buffer, bufsize, pos, e->green.X, 4);
1953 pos = safecat(buffer, bufsize, pos, ",");
1954 pos = safecatd(buffer, bufsize, pos, e->green.Y, 4);
1955 pos = safecat(buffer, bufsize, pos, ",");
1956 pos = safecatd(buffer, bufsize, pos, e->green.Z, 4);
1957 pos = safecat(buffer, bufsize, pos, "),B(");
1958 pos = safecatd(buffer, bufsize, pos, e->blue.X, 4);
1959 pos = safecat(buffer, bufsize, pos, ",");
1960 pos = safecatd(buffer, bufsize, pos, e->blue.Y, 4);
1961 pos = safecat(buffer, bufsize, pos, ",");
1962 pos = safecatd(buffer, bufsize, pos, e->blue.Z, 4);
1963 pos = safecat(buffer, bufsize, pos, ")");
1964 if (encoding_gamma != 0)
1965 pos = safecat(buffer, bufsize, pos, ")");
1968 if (encoding_gamma != 0)
1970 pos = safecat(buffer, bufsize, pos, "^");
1971 pos = safecatd(buffer, bufsize, pos, encoding_gamma, 5);
1976 #endif /* READ_TRANSFORMS */
1977 #endif /* PNG_READ_SUPPORTED */
1979 typedef struct png_modifier
1981 png_store this; /* I am a png_store */
1982 struct png_modification *modifications; /* Changes to make */
1984 modifier_state state; /* My state */
1986 /* Information from IHDR: */
1987 png_byte bit_depth; /* From IHDR */
1988 png_byte colour_type; /* From IHDR */
1990 /* While handling PLTE, IDAT and IEND these chunks may be pended to allow
1991 * other chunks to be inserted.
1993 png_uint_32 pending_len;
1994 png_uint_32 pending_chunk;
1998 unsigned int ngammas;
1999 unsigned int ngamma_tests; /* Number of gamma tests to run*/
2000 double current_gamma; /* 0 if not set */
2001 const color_encoding *encodings;
2002 unsigned int nencodings;
2003 const color_encoding *current_encoding; /* If an encoding has been set */
2004 unsigned int encoding_counter; /* For iteration */
2005 int encoding_ignored; /* Something overwrote it */
2007 /* Control variables used to iterate through possible encodings, the
2008 * following must be set to 0 and tested by the function that uses the
2009 * png_modifier because the modifier only sets it to 1 (true.)
2011 unsigned int repeat :1; /* Repeat this transform test. */
2012 unsigned int test_uses_encoding :1;
2014 /* Lowest sbit to test (pre-1.7 libpng fails for sbit < 8) */
2017 /* Error control - these are the limits on errors accepted by the gamma tests
2020 double maxout8; /* Maximum output value error */
2021 double maxabs8; /* Absolute sample error 0..1 */
2022 double maxcalc8; /* Absolute sample error 0..1 */
2023 double maxpc8; /* Percentage sample error 0..100% */
2024 double maxout16; /* Maximum output value error */
2025 double maxabs16; /* Absolute sample error 0..1 */
2026 double maxcalc16;/* Absolute sample error 0..1 */
2027 double maxcalcG; /* Absolute sample error 0..1 */
2028 double maxpc16; /* Percentage sample error 0..100% */
2030 /* This is set by transforms that need to allow a higher limit, it is an
2031 * internal check on pngvalid to ensure that the calculated error limits are
2032 * not ridiculous; without this it is too easy to make a mistake in pngvalid
2033 * that allows any value through.
2035 * NOTE: this is not checked in release builds.
2037 double limit; /* limit on error values, normally 4E-3 */
2039 /* Log limits - values above this are logged, but not necessarily
2042 double log8; /* Absolute error in 8 bits to log */
2043 double log16; /* Absolute error in 16 bits to log */
2045 /* Logged 8 and 16 bit errors ('output' values): */
2046 double error_gray_2;
2047 double error_gray_4;
2048 double error_gray_8;
2049 double error_gray_16;
2050 double error_color_8;
2051 double error_color_16;
2052 double error_indexed;
2055 /* Whether to call png_read_update_info, not png_read_start_image, and how
2056 * many times to call it.
2058 int use_update_info;
2060 /* Whether or not to interlace. */
2061 int interlace_type :9; /* int, but must store '1' */
2063 /* Run the standard tests? */
2064 unsigned int test_standard :1;
2066 /* Run the odd-sized image and interlace read/write tests? */
2067 unsigned int test_size :1;
2069 /* Run tests on reading with a combination of transforms, */
2070 unsigned int test_transform :1;
2071 unsigned int test_tRNS :1; /* Includes tRNS images */
2073 /* When to use the use_input_precision option, this controls the gamma
2074 * validation code checks. If set any value that is within the transformed
2075 * range input-.5 to input+.5 will be accepted, otherwise the value must be
2076 * within the normal limits. It should not be necessary to set this; the
2077 * result should always be exact within the permitted error limits.
2079 unsigned int use_input_precision :1;
2080 unsigned int use_input_precision_sbit :1;
2081 unsigned int use_input_precision_16to8 :1;
2083 /* If set assume that the calculation bit depth is set by the input
2084 * precision, not the output precision.
2086 unsigned int calculations_use_input_precision :1;
2088 /* If set assume that the calculations are done in 16 bits even if the sample
2091 unsigned int assume_16_bit_calculations :1;
2093 /* Which gamma tests to run: */
2094 unsigned int test_gamma_threshold :1;
2095 unsigned int test_gamma_transform :1; /* main tests */
2096 unsigned int test_gamma_sbit :1;
2097 unsigned int test_gamma_scale16 :1;
2098 unsigned int test_gamma_background :1;
2099 unsigned int test_gamma_alpha_mode :1;
2100 unsigned int test_gamma_expand16 :1;
2101 unsigned int test_exhaustive :1;
2103 /* Whether or not to run the low-bit-depth grayscale tests. This fails on
2104 * gamma images in some cases because of gross inaccuracies in the grayscale
2105 * gamma handling for low bit depth.
2107 unsigned int test_lbg :1;
2108 unsigned int test_lbg_gamma_threshold :1;
2109 unsigned int test_lbg_gamma_transform :1;
2110 unsigned int test_lbg_gamma_sbit :1;
2111 unsigned int test_lbg_gamma_composition :1;
2113 unsigned int log :1; /* Log max error */
2115 /* Buffer information, the buffer size limits the size of the chunks that can
2116 * be modified - they must fit (including header and CRC) into the buffer!
2118 size_t flush; /* Count of bytes to flush */
2119 size_t buffer_count; /* Bytes in buffer */
2120 size_t buffer_position; /* Position in buffer */
2121 png_byte buffer[1024];
2124 /* This returns true if the test should be stopped now because it has already
2125 * failed and it is running silently.
2127 static int fail(png_modifier *pm)
2129 return !pm->log && !pm->this.verbose && (pm->this.nerrors > 0 ||
2130 (pm->this.treat_warnings_as_errors && pm->this.nwarnings > 0));
2134 modifier_init(png_modifier *pm)
2136 memset(pm, 0, sizeof *pm);
2137 store_init(&pm->this);
2138 pm->modifications = NULL;
2139 pm->state = modifier_start;
2142 pm->ngamma_tests = 0;
2144 pm->current_gamma = 0;
2147 pm->current_encoding = 0;
2148 pm->encoding_counter = 0;
2149 pm->encoding_ignored = 0;
2151 pm->test_uses_encoding = 0;
2152 pm->maxout8 = pm->maxpc8 = pm->maxabs8 = pm->maxcalc8 = 0;
2153 pm->maxout16 = pm->maxpc16 = pm->maxabs16 = pm->maxcalc16 = 0;
2156 pm->log8 = pm->log16 = 0; /* Means 'off' */
2157 pm->error_gray_2 = pm->error_gray_4 = pm->error_gray_8 = 0;
2158 pm->error_gray_16 = pm->error_color_8 = pm->error_color_16 = 0;
2159 pm->error_indexed = 0;
2160 pm->use_update_info = 0;
2161 pm->interlace_type = PNG_INTERLACE_NONE;
2162 pm->test_standard = 0;
2164 pm->test_transform = 0;
2165 # ifdef PNG_WRITE_tRNS_SUPPORTED
2170 pm->use_input_precision = 0;
2171 pm->use_input_precision_sbit = 0;
2172 pm->use_input_precision_16to8 = 0;
2173 pm->calculations_use_input_precision = 0;
2174 pm->assume_16_bit_calculations = 0;
2175 pm->test_gamma_threshold = 0;
2176 pm->test_gamma_transform = 0;
2177 pm->test_gamma_sbit = 0;
2178 pm->test_gamma_scale16 = 0;
2179 pm->test_gamma_background = 0;
2180 pm->test_gamma_alpha_mode = 0;
2181 pm->test_gamma_expand16 = 0;
2183 pm->test_lbg_gamma_threshold = 1;
2184 pm->test_lbg_gamma_transform = 1;
2185 pm->test_lbg_gamma_sbit = 1;
2186 pm->test_lbg_gamma_composition = 1;
2187 pm->test_exhaustive = 0;
2190 /* Rely on the memset for all the other fields - there are no pointers */
2193 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
2195 /* This controls use of checks that explicitly know how libpng digitizes the
2196 * samples in calculations; setting this circumvents simple error limit checking
2197 * in the rgb_to_gray check, replacing it with an exact copy of the libpng 1.5
2200 #define DIGITIZE PNG_LIBPNG_VER < 10700
2202 /* If pm->calculations_use_input_precision is set then operations will happen
2203 * with the precision of the input, not the precision of the output depth.
2205 * If pm->assume_16_bit_calculations is set then even 8 bit calculations use 16
2206 * bit precision. This only affects those of the following limits that pertain
2207 * to a calculation - not a digitization operation - unless the following API is
2210 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
2212 static double digitize(double value, int depth, int do_round)
2214 /* 'value' is in the range 0 to 1, the result is the same value rounded to a
2215 * multiple of the digitization factor - 8 or 16 bits depending on both the
2216 * sample depth and the 'assume' setting. Digitization is normally by
2217 * rounding and 'do_round' should be 1, if it is 0 the digitized value will
2220 const unsigned int digitization_factor = (1U << depth) -1;
2222 /* Limiting the range is done as a convenience to the caller - it's easier to
2223 * do it once here than every time at the call site.
2228 else if (value >= 1)
2231 value *= digitization_factor;
2232 if (do_round) value += .5;
2233 return floor(value)/digitization_factor;
2236 #endif /* RGB_TO_GRAY */
2238 #ifdef PNG_READ_GAMMA_SUPPORTED
2239 static double abserr(const png_modifier *pm, int in_depth, int out_depth)
2241 /* Absolute error permitted in linear values - affected by the bit depth of
2244 if (pm->assume_16_bit_calculations ||
2245 (pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
2246 return pm->maxabs16;
2251 static double calcerr(const png_modifier *pm, int in_depth, int out_depth)
2253 /* Error in the linear composition arithmetic - only relevant when
2254 * composition actually happens (0 < alpha < 1).
2256 if ((pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
2257 return pm->maxcalc16;
2258 else if (pm->assume_16_bit_calculations)
2259 return pm->maxcalcG;
2261 return pm->maxcalc8;
2264 static double pcerr(const png_modifier *pm, int in_depth, int out_depth)
2266 /* Percentage error permitted in the linear values. Note that the specified
2267 * value is a percentage but this routine returns a simple number.
2269 if (pm->assume_16_bit_calculations ||
2270 (pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
2271 return pm->maxpc16 * .01;
2273 return pm->maxpc8 * .01;
2276 /* Output error - the error in the encoded value. This is determined by the
2277 * digitization of the output so can be +/-0.5 in the actual output value. In
2278 * the expand_16 case with the current code in libpng the expand happens after
2279 * all the calculations are done in 8 bit arithmetic, so even though the output
2280 * depth is 16 the output error is determined by the 8 bit calculation.
2282 * This limit is not determined by the bit depth of internal calculations.
2284 * The specified parameter does *not* include the base .5 digitization error but
2287 static double outerr(const png_modifier *pm, int in_depth, int out_depth)
2289 /* There is a serious error in the 2 and 4 bit grayscale transform because
2290 * the gamma table value (8 bits) is simply shifted, not rounded, so the
2291 * error in 4 bit grayscale gamma is up to the value below. This is a hack
2292 * to allow pngvalid to succeed:
2294 * TODO: fix this in libpng
2302 if ((pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
2303 return pm->maxout16;
2305 /* This is the case where the value was calculated at 8-bit precision then
2306 * scaled to 16 bits.
2308 else if (out_depth == 16)
2309 return pm->maxout8 * 257;
2315 /* This does the same thing as the above however it returns the value to log,
2316 * rather than raising a warning. This is useful for debugging to track down
2317 * exactly what set of parameters cause high error values.
2319 static double outlog(const png_modifier *pm, int in_depth, int out_depth)
2321 /* The command line parameters are either 8 bit (0..255) or 16 bit (0..65535)
2322 * and so must be adjusted for low bit depth grayscale:
2326 if (pm->log8 == 0) /* switched off */
2330 return pm->log8 / 255 * ((1<<out_depth)-1);
2335 if ((pm->calculations_use_input_precision ? in_depth : out_depth) == 16)
2343 /* This is the case where the value was calculated at 8-bit precision then
2344 * scaled to 16 bits.
2349 return pm->log8 * 257;
2352 /* This complements the above by providing the appropriate quantization for the
2353 * final value. Normally this would just be quantization to an integral value,
2354 * but in the 8 bit calculation case it's actually quantization to a multiple of
2357 static int output_quantization_factor(const png_modifier *pm, int in_depth,
2360 if (out_depth == 16 && in_depth != 16 &&
2361 pm->calculations_use_input_precision)
2366 #endif /* PNG_READ_GAMMA_SUPPORTED */
2368 /* One modification structure must be provided for each chunk to be modified (in
2369 * fact more than one can be provided if multiple separate changes are desired
2370 * for a single chunk.) Modifications include adding a new chunk when a
2371 * suitable chunk does not exist.
2373 * The caller of modify_fn will reset the CRC of the chunk and record 'modified'
2374 * or 'added' as appropriate if the modify_fn returns 1 (true). If the
2375 * modify_fn is NULL the chunk is simply removed.
2377 typedef struct png_modification
2379 struct png_modification *next;
2382 /* If the following is NULL all matching chunks will be removed: */
2383 int (*modify_fn)(struct png_modifier *pm,
2384 struct png_modification *me, int add);
2386 /* If the following is set to PLTE, IDAT or IEND and the chunk has not been
2387 * found and modified (and there is a modify_fn) the modify_fn will be called
2388 * to add the chunk before the relevant chunk.
2391 unsigned int modified :1; /* Chunk was modified */
2392 unsigned int added :1; /* Chunk was added */
2393 unsigned int removed :1; /* Chunk was removed */
2397 modification_reset(png_modification *pmm)
2404 modification_reset(pmm->next);
2409 modification_init(png_modification *pmm)
2411 memset(pmm, 0, sizeof *pmm);
2414 pmm->modify_fn = NULL;
2416 modification_reset(pmm);
2419 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
2421 modifier_current_encoding(const png_modifier *pm, color_encoding *ce)
2423 if (pm->current_encoding != 0)
2424 *ce = *pm->current_encoding;
2427 memset(ce, 0, sizeof *ce);
2429 ce->gamma = pm->current_gamma;
2433 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
2435 safecat_current_encoding(char *buffer, size_t bufsize, size_t pos,
2436 const png_modifier *pm)
2438 pos = safecat_color_encoding(buffer, bufsize, pos, pm->current_encoding,
2441 if (pm->encoding_ignored)
2442 pos = safecat(buffer, bufsize, pos, "[overridden]");
2448 /* Iterate through the usefully testable color encodings. An encoding is one
2451 * 1) Nothing (no color space, no gamma).
2452 * 2) Just a gamma value from the gamma array (including 1.0)
2453 * 3) A color space from the encodings array with the corresponding gamma.
2454 * 4) The same, but with gamma 1.0 (only really useful with 16 bit calculations)
2456 * The iterator selects these in turn, the randomizer selects one at random,
2457 * which is used depends on the setting of the 'test_exhaustive' flag. Notice
2458 * that this function changes the colour space encoding so it must only be
2459 * called on completion of the previous test. This is what 'modifier_reset'
2462 * After the function has been called the 'repeat' flag will still be set; the
2463 * caller of modifier_reset must reset it at the start of each run of the test!
2466 modifier_total_encodings(const png_modifier *pm)
2468 return 1 + /* (1) nothing */
2469 pm->ngammas + /* (2) gamma values to test */
2470 pm->nencodings + /* (3) total number of encodings */
2471 /* The following test only works after the first time through the
2472 * png_modifier code because 'bit_depth' is set when the IHDR is read.
2473 * modifier_reset, below, preserves the setting until after it has called
2474 * the iterate function (also below.)
2476 * For this reason do not rely on this function outside a call to
2479 ((pm->bit_depth == 16 || pm->assume_16_bit_calculations) ?
2480 pm->nencodings : 0); /* (4) encodings with gamma == 1.0 */
2484 modifier_encoding_iterate(png_modifier *pm)
2486 if (!pm->repeat && /* Else something needs the current encoding again. */
2487 pm->test_uses_encoding) /* Some transform is encoding dependent */
2489 if (pm->test_exhaustive)
2491 if (++pm->encoding_counter >= modifier_total_encodings(pm))
2492 pm->encoding_counter = 0; /* This will stop the repeat */
2497 /* Not exhaustive - choose an encoding at random; generate a number in
2498 * the range 1..(max-1), so the result is always non-zero:
2500 if (pm->encoding_counter == 0)
2501 pm->encoding_counter = random_mod(modifier_total_encodings(pm)-1)+1;
2503 pm->encoding_counter = 0;
2506 if (pm->encoding_counter > 0)
2510 else if (!pm->repeat)
2511 pm->encoding_counter = 0;
2515 modifier_reset(png_modifier *pm)
2517 store_read_reset(&pm->this);
2519 pm->pending_len = pm->pending_chunk = 0;
2520 pm->flush = pm->buffer_count = pm->buffer_position = 0;
2521 pm->modifications = NULL;
2522 pm->state = modifier_start;
2523 modifier_encoding_iterate(pm);
2524 /* The following must be set in the next run. In particular
2525 * test_uses_encodings must be set in the _ini function of each transform
2526 * that looks at the encodings. (Not the 'add' function!)
2528 pm->test_uses_encoding = 0;
2529 pm->current_gamma = 0;
2530 pm->current_encoding = 0;
2531 pm->encoding_ignored = 0;
2532 /* These only become value after IHDR is read: */
2533 pm->bit_depth = pm->colour_type = 0;
2536 /* The following must be called before anything else to get the encoding set up
2537 * on the modifier. In particular it must be called before the transform init
2538 * functions are called.
2541 modifier_set_encoding(png_modifier *pm)
2543 /* Set the encoding to the one specified by the current encoding counter,
2544 * first clear out all the settings - this corresponds to an encoding_counter
2547 pm->current_gamma = 0;
2548 pm->current_encoding = 0;
2549 pm->encoding_ignored = 0; /* not ignored yet - happens in _ini functions. */
2551 /* Now, if required, set the gamma and encoding fields. */
2552 if (pm->encoding_counter > 0)
2554 /* The gammas[] array is an array of screen gammas, not encoding gammas,
2555 * so we need the inverse:
2557 if (pm->encoding_counter <= pm->ngammas)
2558 pm->current_gamma = 1/pm->gammas[pm->encoding_counter-1];
2562 unsigned int i = pm->encoding_counter - pm->ngammas;
2564 if (i >= pm->nencodings)
2566 i %= pm->nencodings;
2567 pm->current_gamma = 1; /* Linear, only in the 16 bit case */
2571 pm->current_gamma = pm->encodings[i].gamma;
2573 pm->current_encoding = pm->encodings + i;
2578 /* Enquiry functions to find out what is set. Notice that there is an implicit
2579 * assumption below that the first encoding in the list is the one for sRGB.
2582 modifier_color_encoding_is_sRGB(const png_modifier *pm)
2584 return pm->current_encoding != 0 && pm->current_encoding == pm->encodings &&
2585 pm->current_encoding->gamma == pm->current_gamma;
2589 modifier_color_encoding_is_set(const png_modifier *pm)
2591 return pm->current_gamma != 0;
2594 /* Convenience macros. */
2595 #define CHUNK(a,b,c,d) (((a)<<24)+((b)<<16)+((c)<<8)+(d))
2596 #define CHUNK_IHDR CHUNK(73,72,68,82)
2597 #define CHUNK_PLTE CHUNK(80,76,84,69)
2598 #define CHUNK_IDAT CHUNK(73,68,65,84)
2599 #define CHUNK_IEND CHUNK(73,69,78,68)
2600 #define CHUNK_cHRM CHUNK(99,72,82,77)
2601 #define CHUNK_gAMA CHUNK(103,65,77,65)
2602 #define CHUNK_sBIT CHUNK(115,66,73,84)
2603 #define CHUNK_sRGB CHUNK(115,82,71,66)
2605 /* The guts of modification are performed during a read. */
2607 modifier_crc(png_bytep buffer)
2609 /* Recalculate the chunk CRC - a complete chunk must be in
2610 * the buffer, at the start.
2612 uInt datalen = png_get_uint_32(buffer);
2613 uLong crc = crc32(0, buffer+4, datalen+4);
2614 /* The cast to png_uint_32 is safe because a crc32 is always a 32 bit value.
2616 png_save_uint_32(buffer+datalen+8, (png_uint_32)crc);
2620 modifier_setbuffer(png_modifier *pm)
2622 modifier_crc(pm->buffer);
2623 pm->buffer_count = png_get_uint_32(pm->buffer)+12;
2624 pm->buffer_position = 0;
2627 /* Separate the callback into the actual implementation (which is passed the
2628 * png_modifier explicitly) and the callback, which gets the modifier from the
2632 modifier_read_imp(png_modifier *pm, png_bytep pb, png_size_t st)
2637 png_uint_32 len, chunk;
2638 png_modification *mod;
2640 if (pm->buffer_position >= pm->buffer_count) switch (pm->state)
2642 static png_byte sign[8] = { 137, 80, 78, 71, 13, 10, 26, 10 };
2643 case modifier_start:
2644 store_read_imp(&pm->this, pm->buffer, 8); /* size of signature. */
2645 pm->buffer_count = 8;
2646 pm->buffer_position = 0;
2648 if (memcmp(pm->buffer, sign, 8) != 0)
2649 png_error(pm->this.pread, "invalid PNG file signature");
2650 pm->state = modifier_signature;
2653 case modifier_signature:
2654 store_read_imp(&pm->this, pm->buffer, 13+12); /* size of IHDR */
2655 pm->buffer_count = 13+12;
2656 pm->buffer_position = 0;
2658 if (png_get_uint_32(pm->buffer) != 13 ||
2659 png_get_uint_32(pm->buffer+4) != CHUNK_IHDR)
2660 png_error(pm->this.pread, "invalid IHDR");
2662 /* Check the list of modifiers for modifications to the IHDR. */
2663 mod = pm->modifications;
2666 if (mod->chunk == CHUNK_IHDR && mod->modify_fn &&
2667 (*mod->modify_fn)(pm, mod, 0))
2670 modifier_setbuffer(pm);
2673 /* Ignore removal or add if IHDR! */
2677 /* Cache information from the IHDR (the modified one.) */
2678 pm->bit_depth = pm->buffer[8+8];
2679 pm->colour_type = pm->buffer[8+8+1];
2681 pm->state = modifier_IHDR;
2687 /* Read a new chunk and process it until we see PLTE, IDAT or
2688 * IEND. 'flush' indicates that there is still some data to
2689 * output from the preceding chunk.
2691 if ((cb = pm->flush) > 0)
2693 if (cb > st) cb = st;
2695 store_read_imp(&pm->this, pb, cb);
2698 if (st == 0) return;
2701 /* No more bytes to flush, read a header, or handle a pending
2704 if (pm->pending_chunk != 0)
2706 png_save_uint_32(pm->buffer, pm->pending_len);
2707 png_save_uint_32(pm->buffer+4, pm->pending_chunk);
2708 pm->pending_len = 0;
2709 pm->pending_chunk = 0;
2712 store_read_imp(&pm->this, pm->buffer, 8);
2714 pm->buffer_count = 8;
2715 pm->buffer_position = 0;
2717 /* Check for something to modify or a terminator chunk. */
2718 len = png_get_uint_32(pm->buffer);
2719 chunk = png_get_uint_32(pm->buffer+4);
2721 /* Terminators first, they may have to be delayed for added
2724 if (chunk == CHUNK_PLTE || chunk == CHUNK_IDAT ||
2725 chunk == CHUNK_IEND)
2727 mod = pm->modifications;
2731 if ((mod->add == chunk ||
2732 (mod->add == CHUNK_PLTE && chunk == CHUNK_IDAT)) &&
2733 mod->modify_fn != NULL && !mod->modified && !mod->added)
2735 /* Regardless of what the modify function does do not run
2740 if ((*mod->modify_fn)(pm, mod, 1 /*add*/))
2742 /* Reset the CRC on a new chunk */
2743 if (pm->buffer_count > 0)
2744 modifier_setbuffer(pm);
2748 pm->buffer_position = 0;
2752 /* The buffer has been filled with something (we assume)
2753 * so output this. Pend the current chunk.
2755 pm->pending_len = len;
2756 pm->pending_chunk = chunk;
2757 break; /* out of while */
2764 /* Don't do any further processing if the buffer was modified -
2765 * otherwise the code will end up modifying a chunk that was
2769 break; /* out of switch */
2772 /* If we get to here then this chunk may need to be modified. To
2773 * do this it must be less than 1024 bytes in total size, otherwise
2774 * it just gets flushed.
2776 if (len+12 <= sizeof pm->buffer)
2778 store_read_imp(&pm->this, pm->buffer+pm->buffer_count,
2779 len+12-pm->buffer_count);
2780 pm->buffer_count = len+12;
2782 /* Check for a modification, else leave it be. */
2783 mod = pm->modifications;
2786 if (mod->chunk == chunk)
2788 if (mod->modify_fn == NULL)
2790 /* Remove this chunk */
2791 pm->buffer_count = pm->buffer_position = 0;
2793 break; /* Terminate the while loop */
2796 else if ((*mod->modify_fn)(pm, mod, 0))
2799 /* The chunk may have been removed: */
2800 if (pm->buffer_count == 0)
2802 pm->buffer_position = 0;
2805 modifier_setbuffer(pm);
2814 pm->flush = len+12 - pm->buffer_count; /* data + crc */
2816 /* Take the data from the buffer (if there is any). */
2820 /* Here to read from the modifier buffer (not directly from
2821 * the store, as in the flush case above.)
2823 cb = pm->buffer_count - pm->buffer_position;
2828 memcpy(pb, pm->buffer + pm->buffer_position, cb);
2831 pm->buffer_position += cb;
2836 static void PNGCBAPI
2837 modifier_read(png_structp ppIn, png_bytep pb, png_size_t st)
2839 png_const_structp pp = ppIn;
2840 png_modifier *pm = voidcast(png_modifier*, png_get_io_ptr(pp));
2842 if (pm == NULL || pm->this.pread != pp)
2843 png_error(pp, "bad modifier_read call");
2845 modifier_read_imp(pm, pb, st);
2848 /* Like store_progressive_read but the data is getting changed as we go so we
2849 * need a local buffer.
2852 modifier_progressive_read(png_modifier *pm, png_structp pp, png_infop pi)
2854 if (pm->this.pread != pp || pm->this.current == NULL ||
2855 pm->this.next == NULL)
2856 png_error(pp, "store state damaged (progressive)");
2858 /* This is another Horowitz and Hill random noise generator. In this case
2859 * the aim is to stress the progressive reader with truly horrible variable
2860 * buffer sizes in the range 1..500, so a sequence of 9 bit random numbers
2861 * is generated. We could probably just count from 1 to 32767 and get as
2866 static png_uint_32 noise = 1;
2867 png_size_t cb, cbAvail;
2868 png_byte buffer[512];
2870 /* Generate 15 more bits of stuff: */
2871 noise = (noise << 9) | ((noise ^ (noise >> (9-5))) & 0x1ff);
2874 /* Check that this number of bytes are available (in the current buffer.)
2875 * (This doesn't quite work - the modifier might delete a chunk; unlikely
2876 * but possible, it doesn't happen at present because the modifier only
2877 * adds chunks to standard images.)
2879 cbAvail = store_read_buffer_avail(&pm->this);
2880 if (pm->buffer_count > pm->buffer_position)
2881 cbAvail += pm->buffer_count - pm->buffer_position;
2885 /* Check for EOF: */
2892 modifier_read_imp(pm, buffer, cb);
2893 png_process_data(pp, pi, buffer, cb);
2896 /* Check the invariants at the end (if this fails it's a problem in this
2899 if (pm->buffer_count > pm->buffer_position ||
2900 pm->this.next != &pm->this.current->data ||
2901 pm->this.readpos < pm->this.current->datacount)
2902 png_error(pp, "progressive read implementation error");
2905 /* Set up a modifier. */
2907 set_modifier_for_read(png_modifier *pm, png_infopp ppi, png_uint_32 id,
2910 /* Do this first so that the modifier fields are cleared even if an error
2911 * happens allocating the png_struct. No allocation is done here so no
2912 * cleanup is required.
2914 pm->state = modifier_start;
2916 pm->colour_type = 255;
2918 pm->pending_len = 0;
2919 pm->pending_chunk = 0;
2921 pm->buffer_count = 0;
2922 pm->buffer_position = 0;
2924 return set_store_for_read(&pm->this, ppi, id, name);
2928 /******************************** MODIFICATIONS *******************************/
2929 /* Standard modifications to add chunks. These do not require the _SUPPORTED
2930 * macros because the chunks can be there regardless of whether this specific
2931 * libpng supports them.
2933 typedef struct gama_modification
2935 png_modification this;
2936 png_fixed_point gamma;
2937 } gama_modification;
2940 gama_modify(png_modifier *pm, png_modification *me, int add)
2943 /* This simply dumps the given gamma value into the buffer. */
2944 png_save_uint_32(pm->buffer, 4);
2945 png_save_uint_32(pm->buffer+4, CHUNK_gAMA);
2946 png_save_uint_32(pm->buffer+8, ((gama_modification*)me)->gamma);
2951 gama_modification_init(gama_modification *me, png_modifier *pm, double gammad)
2955 modification_init(&me->this);
2956 me->this.chunk = CHUNK_gAMA;
2957 me->this.modify_fn = gama_modify;
2958 me->this.add = CHUNK_PLTE;
2960 me->gamma = (png_fixed_point)g;
2961 me->this.next = pm->modifications;
2962 pm->modifications = &me->this;
2965 typedef struct chrm_modification
2967 png_modification this;
2968 const color_encoding *encoding;
2969 png_fixed_point wx, wy, rx, ry, gx, gy, bx, by;
2970 } chrm_modification;
2973 chrm_modify(png_modifier *pm, png_modification *me, int add)
2976 /* As with gAMA this just adds the required cHRM chunk to the buffer. */
2977 png_save_uint_32(pm->buffer , 32);
2978 png_save_uint_32(pm->buffer+ 4, CHUNK_cHRM);
2979 png_save_uint_32(pm->buffer+ 8, ((chrm_modification*)me)->wx);
2980 png_save_uint_32(pm->buffer+12, ((chrm_modification*)me)->wy);
2981 png_save_uint_32(pm->buffer+16, ((chrm_modification*)me)->rx);
2982 png_save_uint_32(pm->buffer+20, ((chrm_modification*)me)->ry);
2983 png_save_uint_32(pm->buffer+24, ((chrm_modification*)me)->gx);
2984 png_save_uint_32(pm->buffer+28, ((chrm_modification*)me)->gy);
2985 png_save_uint_32(pm->buffer+32, ((chrm_modification*)me)->bx);
2986 png_save_uint_32(pm->buffer+36, ((chrm_modification*)me)->by);
2991 chrm_modification_init(chrm_modification *me, png_modifier *pm,
2992 const color_encoding *encoding)
2994 CIE_color white = white_point(encoding);
2996 /* Original end points: */
2997 me->encoding = encoding;
2999 /* Chromaticities (in fixed point): */
3000 me->wx = fix(chromaticity_x(white));
3001 me->wy = fix(chromaticity_y(white));
3003 me->rx = fix(chromaticity_x(encoding->red));
3004 me->ry = fix(chromaticity_y(encoding->red));
3005 me->gx = fix(chromaticity_x(encoding->green));
3006 me->gy = fix(chromaticity_y(encoding->green));
3007 me->bx = fix(chromaticity_x(encoding->blue));
3008 me->by = fix(chromaticity_y(encoding->blue));
3010 modification_init(&me->this);
3011 me->this.chunk = CHUNK_cHRM;
3012 me->this.modify_fn = chrm_modify;
3013 me->this.add = CHUNK_PLTE;
3014 me->this.next = pm->modifications;
3015 pm->modifications = &me->this;
3018 typedef struct srgb_modification
3020 png_modification this;
3022 } srgb_modification;
3025 srgb_modify(png_modifier *pm, png_modification *me, int add)
3028 /* As above, ignore add and just make a new chunk */
3029 png_save_uint_32(pm->buffer, 1);
3030 png_save_uint_32(pm->buffer+4, CHUNK_sRGB);
3031 pm->buffer[8] = ((srgb_modification*)me)->intent;
3036 srgb_modification_init(srgb_modification *me, png_modifier *pm, png_byte intent)
3038 modification_init(&me->this);
3039 me->this.chunk = CHUNK_sBIT;
3041 if (intent <= 3) /* if valid, else *delete* sRGB chunks */
3043 me->this.modify_fn = srgb_modify;
3044 me->this.add = CHUNK_PLTE;
3045 me->intent = intent;
3050 me->this.modify_fn = 0;
3055 me->this.next = pm->modifications;
3056 pm->modifications = &me->this;
3059 #ifdef PNG_READ_GAMMA_SUPPORTED
3060 typedef struct sbit_modification
3062 png_modification this;
3064 } sbit_modification;
3067 sbit_modify(png_modifier *pm, png_modification *me, int add)
3069 png_byte sbit = ((sbit_modification*)me)->sbit;
3070 if (pm->bit_depth > sbit)
3073 switch (pm->colour_type)
3093 png_error(pm->this.pread,
3094 "unexpected colour type in sBIT modification");
3097 png_save_uint_32(pm->buffer, cb);
3098 png_save_uint_32(pm->buffer+4, CHUNK_sBIT);
3101 (pm->buffer+8)[--cb] = sbit;
3107 /* Remove the sBIT chunk */
3108 pm->buffer_count = pm->buffer_position = 0;
3112 return 0; /* do nothing */
3116 sbit_modification_init(sbit_modification *me, png_modifier *pm, png_byte sbit)
3118 modification_init(&me->this);
3119 me->this.chunk = CHUNK_sBIT;
3120 me->this.modify_fn = sbit_modify;
3121 me->this.add = CHUNK_PLTE;
3123 me->this.next = pm->modifications;
3124 pm->modifications = &me->this;
3126 #endif /* PNG_READ_GAMMA_SUPPORTED */
3127 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
3129 /***************************** STANDARD PNG FILES *****************************/
3130 /* Standard files - write and save standard files. */
3131 /* There are two basic forms of standard images. Those which attempt to have
3132 * all the possible pixel values (not possible for 16bpp images, but a range of
3133 * values are produced) and those which have a range of image sizes. The former
3134 * are used for testing transforms, in particular gamma correction and bit
3135 * reduction and increase. The latter are reserved for testing the behavior of
3136 * libpng with respect to 'odd' image sizes - particularly small images where
3137 * rows become 1 byte and interlace passes disappear.
3139 * The first, most useful, set are the 'transform' images, the second set of
3140 * small images are the 'size' images.
3142 * The transform files are constructed with rows which fit into a 1024 byte row
3143 * buffer. This makes allocation easier below. Further regardless of the file
3144 * format every row has 128 pixels (giving 1024 bytes for 64bpp formats).
3146 * Files are stored with no gAMA or sBIT chunks, with a PLTE only when needed
3147 * and with an ID derived from the colour type, bit depth and interlace type
3148 * as above (FILEID). The width (128) and height (variable) are not stored in
3149 * the FILEID - instead the fields are set to 0, indicating a transform file.
3151 * The size files ar constructed with rows a maximum of 128 bytes wide, allowing
3152 * a maximum width of 16 pixels (for the 64bpp case.) They also have a maximum
3153 * height of 16 rows. The width and height are stored in the FILEID and, being
3154 * non-zero, indicate a size file.
3156 * Because the PNG filter code is typically the largest CPU consumer within
3157 * libpng itself there is a tendency to attempt to optimize it. This results in
3158 * special case code which needs to be validated. To cause this to happen the
3159 * 'size' images are made to use each possible filter, in so far as this is
3160 * possible for smaller images.
3162 * For palette image (colour type 3) multiple transform images are stored with
3163 * the same bit depth to allow testing of more colour combinations -
3164 * particularly important for testing the gamma code because libpng uses a
3165 * different code path for palette images. For size images a single palette is
3169 /* Make a 'standard' palette. Because there are only 256 entries in a palette
3170 * (maximum) this actually makes a random palette in the hope that enough tests
3171 * will catch enough errors. (Note that the same palette isn't produced every
3172 * time for the same test - it depends on what previous tests have been run -
3173 * but a given set of arguments to pngvalid will always produce the same palette
3174 * at the same test! This is why pseudo-random number generators are useful for
3177 * The store must be open for write when this is called, otherwise an internal
3178 * error will occur. This routine contains its own magic number seed, so the
3179 * palettes generated don't change if there are intervening errors (changing the
3180 * calls to the store_mark seed.)
3182 static store_palette_entry *
3183 make_standard_palette(png_store* ps, int npalette, int do_tRNS)
3185 static png_uint_32 palette_seed[2] = { 0x87654321, 9 };
3188 png_byte values[256][4];
3190 /* Always put in black and white plus the six primary and secondary colors.
3194 values[i][1] = (png_byte)((i&1) ? 255U : 0U);
3195 values[i][2] = (png_byte)((i&2) ? 255U : 0U);
3196 values[i][3] = (png_byte)((i&4) ? 255U : 0U);
3199 /* Then add 62 grays (one quarter of the remaining 256 slots). */
3202 png_byte random_bytes[4];
3205 need[0] = 0; /*got black*/
3206 memset(need+1, 1, (sizeof need)-2); /*need these*/
3207 need[255] = 0; /*but not white*/
3215 make_four_random_bytes(palette_seed, random_bytes);
3219 b = random_bytes[--j];
3229 /* Finally add 192 colors at random - don't worry about matches to things we
3230 * already have, chance is less than 1/65536. Don't worry about grays,
3231 * chance is the same, so we get a duplicate or extra gray less than 1 time
3235 make_four_random_bytes(palette_seed, values[i]);
3237 /* Fill in the alpha values in the first byte. Just use all possible values
3238 * (0..255) in an apparently random order:
3241 store_palette_entry *palette;
3242 png_byte selector[4];
3244 make_four_random_bytes(palette_seed, selector);
3247 for (i=0; i<256; ++i)
3248 values[i][0] = (png_byte)(i ^ selector[0]);
3251 for (i=0; i<256; ++i)
3252 values[i][0] = 255; /* no transparency/tRNS chunk */
3254 /* 'values' contains 256 ARGB values, but we only need 'npalette'.
3255 * 'npalette' will always be a power of 2: 2, 4, 16 or 256. In the low
3256 * bit depth cases select colors at random, else it is difficult to have
3257 * a set of low bit depth palette test with any chance of a reasonable
3258 * range of colors. Do this by randomly permuting values into the low
3259 * 'npalette' entries using an XOR mask generated here. This also
3260 * permutes the npalette == 256 case in a potentially useful way (there is
3261 * no relationship between palette index and the color value therein!)
3263 palette = store_write_palette(ps, npalette);
3265 for (i=0; i<npalette; ++i)
3267 palette[i].alpha = values[i ^ selector[1]][0];
3268 palette[i].red = values[i ^ selector[1]][1];
3269 palette[i].green = values[i ^ selector[1]][2];
3270 palette[i].blue = values[i ^ selector[1]][3];
3277 /* Initialize a standard palette on a write stream. The 'do_tRNS' argument
3278 * indicates whether or not to also set the tRNS chunk.
3280 /* TODO: the png_structp here can probably be 'const' in the future */
3282 init_standard_palette(png_store *ps, png_structp pp, png_infop pi, int npalette,
3285 store_palette_entry *ppal = make_standard_palette(ps, npalette, do_tRNS);
3289 png_color palette[256];
3291 /* Set all entries to detect overread errors. */
3292 for (i=0; i<npalette; ++i)
3294 palette[i].red = ppal[i].red;
3295 palette[i].green = ppal[i].green;
3296 palette[i].blue = ppal[i].blue;
3299 /* Just in case fill in the rest with detectable values: */
3301 palette[i].red = palette[i].green = palette[i].blue = 42;
3303 png_set_PLTE(pp, pi, palette, npalette);
3311 /* Set all the entries, but skip trailing opaque entries */
3312 for (i=j=0; i<npalette; ++i)
3313 if ((tRNS[i] = ppal[i].alpha) < 255)
3316 /* Fill in the remainder with a detectable value: */
3320 # ifdef PNG_WRITE_tRNS_SUPPORTED
3322 png_set_tRNS(pp, pi, tRNS, j, 0/*color*/);
3327 #ifdef PNG_WRITE_tRNS_SUPPORTED
3329 set_random_tRNS(png_structp pp, png_infop pi, const png_byte colour_type,
3330 const int bit_depth)
3332 /* To make this useful the tRNS color needs to match at least one pixel.
3333 * Random values are fine for gray, including the 16-bit case where we know
3334 * that the test image contains all the gray values. For RGB we need more
3335 * method as only 65536 different RGB values are generated.
3338 const png_uint_16 mask = (png_uint_16)((1U << bit_depth)-1);
3340 R8(tRNS); /* makes unset fields random */
3342 if (colour_type & 2/*RGB*/)
3348 tRNS.blue = tRNS.red ^ tRNS.green;
3354 else /* bit_depth == 16 */
3357 tRNS.green = (png_uint_16)(tRNS.red * 257);
3358 tRNS.blue = (png_uint_16)(tRNS.green * 17);
3368 png_set_tRNS(pp, pi, NULL, 0, &tRNS);
3372 /* The number of passes is related to the interlace type. There was no libpng
3373 * API to determine this prior to 1.5, so we need an inquiry function:
3376 npasses_from_interlace_type(png_const_structp pp, int interlace_type)
3378 switch (interlace_type)
3381 png_error(pp, "invalid interlace type");
3383 case PNG_INTERLACE_NONE:
3386 case PNG_INTERLACE_ADAM7:
3387 return PNG_INTERLACE_ADAM7_PASSES;
3392 bit_size(png_const_structp pp, png_byte colour_type, png_byte bit_depth)
3394 switch (colour_type)
3396 default: png_error(pp, "invalid color type");
3398 case 0: return bit_depth;
3400 case 2: return 3*bit_depth;
3402 case 3: return bit_depth;
3404 case 4: return 2*bit_depth;
3406 case 6: return 4*bit_depth;
3410 #define TRANSFORM_WIDTH 128U
3411 #define TRANSFORM_ROWMAX (TRANSFORM_WIDTH*8U)
3412 #define SIZE_ROWMAX (16*8U) /* 16 pixels, max 8 bytes each - 128 bytes */
3413 #define STANDARD_ROWMAX TRANSFORM_ROWMAX /* The larger of the two */
3414 #define SIZE_HEIGHTMAX 16 /* Maximum range of size images */
3417 transform_rowsize(png_const_structp pp, png_byte colour_type,
3420 return (TRANSFORM_WIDTH * bit_size(pp, colour_type, bit_depth)) / 8;
3423 /* transform_width(pp, colour_type, bit_depth) current returns the same number
3424 * every time, so just use a macro:
3426 #define transform_width(pp, colour_type, bit_depth) TRANSFORM_WIDTH
3429 transform_height(png_const_structp pp, png_byte colour_type, png_byte bit_depth)
3431 switch (bit_size(pp, colour_type, bit_depth))
3436 return 1; /* Total of 128 pixels */
3439 return 2; /* Total of 256 pixels/bytes */
3442 return 512; /* Total of 65536 pixels */
3446 return 512; /* 65536 pixels */
3450 return 2048;/* 4 x 65536 pixels. */
3451 # define TRANSFORM_HEIGHTMAX 2048
3454 return 0; /* Error, will be caught later */
3458 #ifdef PNG_READ_SUPPORTED
3459 /* The following can only be defined here, now we have the definitions
3460 * of the transform image sizes.
3463 standard_width(png_const_structp pp, png_uint_32 id)
3465 png_uint_32 width = WIDTH_FROM_ID(id);
3469 width = transform_width(pp, COL_FROM_ID(id), DEPTH_FROM_ID(id));
3475 standard_height(png_const_structp pp, png_uint_32 id)
3477 png_uint_32 height = HEIGHT_FROM_ID(id);
3480 height = transform_height(pp, COL_FROM_ID(id), DEPTH_FROM_ID(id));
3486 standard_rowsize(png_const_structp pp, png_uint_32 id)
3488 png_uint_32 width = standard_width(pp, id);
3490 /* This won't overflow: */
3491 width *= bit_size(pp, COL_FROM_ID(id), DEPTH_FROM_ID(id));
3492 return (width + 7) / 8;
3494 #endif /* PNG_READ_SUPPORTED */
3497 transform_row(png_const_structp pp, png_byte buffer[TRANSFORM_ROWMAX],
3498 png_byte colour_type, png_byte bit_depth, png_uint_32 y)
3500 png_uint_32 v = y << 7;
3503 switch (bit_size(pp, colour_type, bit_depth))
3506 while (i<128/8) buffer[i] = (png_byte)(v & 0xff), v += 17, ++i;
3510 while (i<128/4) buffer[i] = (png_byte)(v & 0xff), v += 33, ++i;
3514 while (i<128/2) buffer[i] = (png_byte)(v & 0xff), v += 65, ++i;
3518 /* 256 bytes total, 128 bytes in each row set as follows: */
3519 while (i<128) buffer[i] = (png_byte)(v & 0xff), ++v, ++i;
3523 /* Generate all 65536 pixel values in order, which includes the 8 bit
3524 * GA case as well as the 16 bit G case.
3528 buffer[2*i] = (png_byte)((v>>8) & 0xff);
3529 buffer[2*i+1] = (png_byte)(v & 0xff);
3537 /* 65535 pixels, but rotate the values. */
3540 /* Three bytes per pixel, r, g, b, make b by r^g */
3541 buffer[3*i+0] = (png_byte)((v >> 8) & 0xff);
3542 buffer[3*i+1] = (png_byte)(v & 0xff);
3543 buffer[3*i+2] = (png_byte)(((v >> 8) ^ v) & 0xff);
3551 /* 65535 pixels, r, g, b, a; just replicate */
3554 buffer[4*i+0] = (png_byte)((v >> 8) & 0xff);
3555 buffer[4*i+1] = (png_byte)(v & 0xff);
3556 buffer[4*i+2] = (png_byte)((v >> 8) & 0xff);
3557 buffer[4*i+3] = (png_byte)(v & 0xff);
3565 /* y is maximum 2047, giving 4x65536 pixels, make 'r' increase by 1 at
3566 * each pixel, g increase by 257 (0x101) and 'b' by 0x1111:
3570 png_uint_32 t = v++;
3571 buffer[6*i+0] = (png_byte)((t >> 8) & 0xff);
3572 buffer[6*i+1] = (png_byte)(t & 0xff);
3574 buffer[6*i+2] = (png_byte)((t >> 8) & 0xff);
3575 buffer[6*i+3] = (png_byte)(t & 0xff);
3577 buffer[6*i+4] = (png_byte)((t >> 8) & 0xff);
3578 buffer[6*i+5] = (png_byte)(t & 0xff);
3585 /* As above in the 32 bit case. */
3588 png_uint_32 t = v++;
3589 buffer[8*i+0] = (png_byte)((t >> 8) & 0xff);
3590 buffer[8*i+1] = (png_byte)(t & 0xff);
3591 buffer[8*i+4] = (png_byte)((t >> 8) & 0xff);
3592 buffer[8*i+5] = (png_byte)(t & 0xff);
3594 buffer[8*i+2] = (png_byte)((t >> 8) & 0xff);
3595 buffer[8*i+3] = (png_byte)(t & 0xff);
3596 buffer[8*i+6] = (png_byte)((t >> 8) & 0xff);
3597 buffer[8*i+7] = (png_byte)(t & 0xff);
3606 png_error(pp, "internal error");
3609 /* This is just to do the right cast - could be changed to a function to check
3610 * 'bd' but there isn't much point.
3612 #define DEPTH(bd) ((png_byte)(1U << (bd)))
3614 /* This is just a helper for compiling on minimal systems with no write
3615 * interlacing support. If there is no write interlacing we can't generate test
3616 * cases with interlace:
3618 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
3619 # define INTERLACE_LAST PNG_INTERLACE_LAST
3620 # define check_interlace_type(type) ((void)(type))
3621 # define set_write_interlace_handling(pp,type) png_set_interlace_handling(pp)
3622 # define do_own_interlace 0
3623 #elif PNG_LIBPNG_VER < 10700
3624 # define set_write_interlace_handling(pp,type) (1)
3626 check_interlace_type(int const interlace_type)
3628 /* Prior to 1.7.0 libpng does not support the write of an interlaced image
3629 * unless PNG_WRITE_INTERLACING_SUPPORTED, even with do_interlace so the
3630 * code here does the pixel interlace itself, so:
3632 if (interlace_type != PNG_INTERLACE_NONE)
3634 /* This is an internal error - --interlace tests should be skipped, not
3637 fprintf(stderr, "pngvalid: no interlace support\n");
3641 # define INTERLACE_LAST (PNG_INTERLACE_NONE+1)
3642 # define do_own_interlace 0
3643 #else /* libpng 1.7+ */
3644 # define set_write_interlace_handling(pp,type)\
3645 npasses_from_interlace_type(pp,type)
3646 # define check_interlace_type(type) ((void)(type))
3647 # define INTERLACE_LAST PNG_INTERLACE_LAST
3648 # define do_own_interlace 1
3649 #endif /* WRITE_INTERLACING tests */
3651 #define CAN_WRITE_INTERLACE\
3652 PNG_LIBPNG_VER >= 10700 || defined PNG_WRITE_INTERLACING_SUPPORTED
3654 /* Do the same thing for read interlacing; this controls whether read tests do
3655 * their own de-interlace or use libpng.
3657 #ifdef PNG_READ_INTERLACING_SUPPORTED
3658 # define do_read_interlace 0
3659 #else /* no libpng read interlace support */
3660 # define do_read_interlace 1
3662 /* The following two routines use the PNG interlace support macros from
3663 * png.h to interlace or deinterlace rows.
3666 interlace_row(png_bytep buffer, png_const_bytep imageRow,
3667 unsigned int pixel_size, png_uint_32 w, int pass, int littleendian)
3669 png_uint_32 xin, xout, xstep;
3671 /* Note that this can, trivially, be optimized to a memcpy on pass 7, the
3672 * code is presented this way to make it easier to understand. In practice
3673 * consult the code in the libpng source to see other ways of doing this.
3675 * It is OK for buffer and imageRow to be identical, because 'xin' moves
3676 * faster than 'xout' and we copy up.
3678 xin = PNG_PASS_START_COL(pass);
3679 xstep = 1U<<PNG_PASS_COL_SHIFT(pass);
3681 for (xout=0; xin<w; xin+=xstep)
3683 pixel_copy(buffer, xout, imageRow, xin, pixel_size, littleendian);
3688 #ifdef PNG_READ_SUPPORTED
3690 deinterlace_row(png_bytep buffer, png_const_bytep row,
3691 unsigned int pixel_size, png_uint_32 w, int pass, int littleendian)
3693 /* The inverse of the above, 'row' is part of row 'y' of the output image,
3694 * in 'buffer'. The image is 'w' wide and this is pass 'pass', distribute
3695 * the pixels of row into buffer and return the number written (to allow
3696 * this to be checked).
3698 png_uint_32 xin, xout, xstep;
3700 xout = PNG_PASS_START_COL(pass);
3701 xstep = 1U<<PNG_PASS_COL_SHIFT(pass);
3703 for (xin=0; xout<w; xout+=xstep)
3705 pixel_copy(buffer, xout, row, xin, pixel_size, littleendian);
3709 #endif /* PNG_READ_SUPPORTED */
3711 /* Make a standardized image given an image colour type, bit depth and
3712 * interlace type. The standard images have a very restricted range of
3713 * rows and heights and are used for testing transforms rather than image
3714 * layout details. See make_size_images below for a way to make images
3715 * that test odd sizes along with the libpng interlace handling.
3717 #ifdef PNG_WRITE_FILTER_SUPPORTED
3719 choose_random_filter(png_structp pp, int start)
3721 /* Choose filters randomly except that on the very first row ensure that
3722 * there is at least one previous row filter.
3724 int filters = PNG_ALL_FILTERS & random_mod(256U);
3726 /* There may be no filters; skip the setting. */
3729 if (start && filters < PNG_FILTER_UP)
3730 filters |= PNG_FILTER_UP;
3732 png_set_filter(pp, 0/*method*/, filters);
3735 #else /* !WRITE_FILTER */
3736 # define choose_random_filter(pp, start) ((void)0)
3737 #endif /* !WRITE_FILTER */
3740 make_transform_image(png_store* const ps, png_byte const colour_type,
3741 png_byte const bit_depth, unsigned int palette_number,
3742 int interlace_type, png_const_charp name)
3746 check_interlace_type(interlace_type);
3751 png_structp pp = set_store_for_write(ps, &pi, name);
3754 /* In the event of a problem return control to the Catch statement below
3755 * to do the clean up - it is not possible to 'return' directly from a Try
3761 w = transform_width(pp, colour_type, bit_depth);
3762 h = transform_height(pp, colour_type, bit_depth);
3764 png_set_IHDR(pp, pi, w, h, bit_depth, colour_type, interlace_type,
3765 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
3767 #ifdef PNG_TEXT_SUPPORTED
3768 # if defined(PNG_READ_zTXt_SUPPORTED) && defined(PNG_WRITE_zTXt_SUPPORTED)
3769 # define TEXT_COMPRESSION PNG_TEXT_COMPRESSION_zTXt
3771 # define TEXT_COMPRESSION PNG_TEXT_COMPRESSION_NONE
3774 static char key[] = "image name"; /* must be writeable */
3777 char copy[FILE_NAME_SIZE];
3779 /* Use a compressed text string to test the correct interaction of text
3780 * compression and IDAT compression.
3782 text.compression = TEXT_COMPRESSION;
3784 /* Yuck: the text must be writable! */
3785 pos = safecat(copy, sizeof copy, 0, ps->wname);
3787 text.text_length = pos;
3788 text.itxt_length = 0;
3792 png_set_text(pp, pi, &text, 1);
3796 if (colour_type == 3) /* palette */
3797 init_standard_palette(ps, pp, pi, 1U << bit_depth, 1/*do tRNS*/);
3799 # ifdef PNG_WRITE_tRNS_SUPPORTED
3800 else if (palette_number)
3801 set_random_tRNS(pp, pi, colour_type, bit_depth);
3804 png_write_info(pp, pi);
3806 if (png_get_rowbytes(pp, pi) !=
3807 transform_rowsize(pp, colour_type, bit_depth))
3808 png_error(pp, "transform row size incorrect");
3812 /* Somewhat confusingly this must be called *after* png_write_info
3813 * because if it is called before, the information in *pp has not been
3814 * updated to reflect the interlaced image.
3816 int npasses = set_write_interlace_handling(pp, interlace_type);
3819 if (npasses != npasses_from_interlace_type(pp, interlace_type))
3820 png_error(pp, "write: png_set_interlace_handling failed");
3822 for (pass=0; pass<npasses; ++pass)
3826 /* do_own_interlace is a pre-defined boolean (a #define) which is
3827 * set if we have to work out the interlaced rows here.
3831 png_byte buffer[TRANSFORM_ROWMAX];
3833 transform_row(pp, buffer, colour_type, bit_depth, y);
3835 # if do_own_interlace
3836 /* If do_own_interlace *and* the image is interlaced we need a
3837 * reduced interlace row; this may be reduced to empty.
3839 if (interlace_type == PNG_INTERLACE_ADAM7)
3841 /* The row must not be written if it doesn't exist, notice
3842 * that there are two conditions here, either the row isn't
3843 * ever in the pass or the row would be but isn't wide
3844 * enough to contribute any pixels. In fact the wPass test
3845 * can be used to skip the whole y loop in this case.
3847 if (PNG_ROW_IN_INTERLACE_PASS(y, pass) &&
3848 PNG_PASS_COLS(w, pass) > 0)
3849 interlace_row(buffer, buffer,
3850 bit_size(pp, colour_type, bit_depth), w, pass,
3851 0/*data always bigendian*/);
3855 # endif /* do_own_interlace */
3857 choose_random_filter(pp, pass == 0 && y == 0);
3858 png_write_row(pp, buffer);
3863 #ifdef PNG_TEXT_SUPPORTED
3865 static char key[] = "end marker";
3866 static char comment[] = "end";
3869 /* Use a compressed text string to test the correct interaction of text
3870 * compression and IDAT compression.
3872 text.compression = TEXT_COMPRESSION;
3874 text.text = comment;
3875 text.text_length = (sizeof comment)-1;
3876 text.itxt_length = 0;
3880 png_set_text(pp, pi, &text, 1);
3884 png_write_end(pp, pi);
3886 /* And store this under the appropriate id, then clean up. */
3887 store_storefile(ps, FILEID(colour_type, bit_depth, palette_number,
3888 interlace_type, 0, 0, 0));
3890 store_write_reset(ps);
3895 /* Use the png_store returned by the exception. This may help the compiler
3896 * because 'ps' is not used in this branch of the setjmp. Note that fault
3897 * and ps will always be the same value.
3899 store_write_reset(fault);
3904 make_transform_images(png_modifier *pm)
3906 png_byte colour_type = 0;
3907 png_byte bit_depth = 0;
3908 unsigned int palette_number = 0;
3910 /* This is in case of errors. */
3911 safecat(pm->this.test, sizeof pm->this.test, 0, "make standard images");
3913 /* Use next_format to enumerate all the combinations we test, including
3914 * generating multiple low bit depth palette images. Non-A images (palette
3915 * and direct) are created with and without tRNS chunks.
3917 while (next_format(&colour_type, &bit_depth, &palette_number, 1, 1))
3921 for (interlace_type = PNG_INTERLACE_NONE;
3922 interlace_type < INTERLACE_LAST; ++interlace_type)
3924 char name[FILE_NAME_SIZE];
3926 standard_name(name, sizeof name, 0, colour_type, bit_depth,
3927 palette_number, interlace_type, 0, 0, do_own_interlace);
3928 make_transform_image(&pm->this, colour_type, bit_depth, palette_number,
3929 interlace_type, name);
3934 /* Build a single row for the 'size' test images; this fills in only the
3935 * first bit_width bits of the sample row.
3938 size_row(png_byte buffer[SIZE_ROWMAX], png_uint_32 bit_width, png_uint_32 y)
3940 /* height is in the range 1 to 16, so: */
3941 y = ((y & 1) << 7) + ((y & 2) << 6) + ((y & 4) << 5) + ((y & 8) << 4);
3942 /* the following ensures bits are set in small images: */
3945 while (bit_width >= 8)
3946 *buffer++ = (png_byte)y++, bit_width -= 8;
3948 /* There may be up to 7 remaining bits, these go in the most significant
3953 png_uint_32 mask = (1U<<(8-bit_width))-1;
3954 *buffer = (png_byte)((*buffer & mask) | (y & ~mask));
3959 make_size_image(png_store* const ps, png_byte const colour_type,
3960 png_byte const bit_depth, int const interlace_type,
3961 png_uint_32 const w, png_uint_32 const h,
3962 int const do_interlace)
3966 check_interlace_type(interlace_type);
3972 unsigned int pixel_size;
3974 /* Make a name and get an appropriate id for the store: */
3975 char name[FILE_NAME_SIZE];
3976 const png_uint_32 id = FILEID(colour_type, bit_depth, 0/*palette*/,
3977 interlace_type, w, h, do_interlace);
3979 standard_name_from_id(name, sizeof name, 0, id);
3980 pp = set_store_for_write(ps, &pi, name);
3982 /* In the event of a problem return control to the Catch statement below
3983 * to do the clean up - it is not possible to 'return' directly from a Try
3989 png_set_IHDR(pp, pi, w, h, bit_depth, colour_type, interlace_type,
3990 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
3992 #ifdef PNG_TEXT_SUPPORTED
3994 static char key[] = "image name"; /* must be writeable */
3997 char copy[FILE_NAME_SIZE];
3999 /* Use a compressed text string to test the correct interaction of text
4000 * compression and IDAT compression.
4002 text.compression = TEXT_COMPRESSION;
4004 /* Yuck: the text must be writable! */
4005 pos = safecat(copy, sizeof copy, 0, ps->wname);
4007 text.text_length = pos;
4008 text.itxt_length = 0;
4012 png_set_text(pp, pi, &text, 1);
4016 if (colour_type == 3) /* palette */
4017 init_standard_palette(ps, pp, pi, 1U << bit_depth, 0/*do tRNS*/);
4019 png_write_info(pp, pi);
4021 /* Calculate the bit size, divide by 8 to get the byte size - this won't
4022 * overflow because we know the w values are all small enough even for
4023 * a system where 'unsigned int' is only 16 bits.
4025 pixel_size = bit_size(pp, colour_type, bit_depth);
4026 if (png_get_rowbytes(pp, pi) != ((w * pixel_size) + 7) / 8)
4027 png_error(pp, "size row size incorrect");
4031 int npasses = npasses_from_interlace_type(pp, interlace_type);
4034 png_byte image[16][SIZE_ROWMAX];
4036 /* To help consistent error detection make the parts of this buffer
4037 * that aren't set below all '1':
4039 memset(image, 0xff, sizeof image);
4041 if (!do_interlace &&
4042 npasses != set_write_interlace_handling(pp, interlace_type))
4043 png_error(pp, "write: png_set_interlace_handling failed");
4045 /* Prepare the whole image first to avoid making it 7 times: */
4047 size_row(image[y], w * pixel_size, y);
4049 for (pass=0; pass<npasses; ++pass)
4051 /* The following two are for checking the macros: */
4052 const png_uint_32 wPass = PNG_PASS_COLS(w, pass);
4054 /* If do_interlace is set we don't call png_write_row for every
4055 * row because some of them are empty. In fact, for a 1x1 image,
4056 * most of them are empty!
4060 png_const_bytep row = image[y];
4061 png_byte tempRow[SIZE_ROWMAX];
4063 /* If do_interlace *and* the image is interlaced we
4064 * need a reduced interlace row; this may be reduced
4067 if (do_interlace && interlace_type == PNG_INTERLACE_ADAM7)
4069 /* The row must not be written if it doesn't exist, notice
4070 * that there are two conditions here, either the row isn't
4071 * ever in the pass or the row would be but isn't wide
4072 * enough to contribute any pixels. In fact the wPass test
4073 * can be used to skip the whole y loop in this case.
4075 if (PNG_ROW_IN_INTERLACE_PASS(y, pass) && wPass > 0)
4077 /* Set to all 1's for error detection (libpng tends to
4078 * set unset things to 0).
4080 memset(tempRow, 0xff, sizeof tempRow);
4081 interlace_row(tempRow, row, pixel_size, w, pass,
4082 0/*data always bigendian*/);
4089 # ifdef PNG_WRITE_FILTER_SUPPORTED
4090 /* Only get to here if the row has some pixels in it, set the
4091 * filters to 'all' for the very first row and thereafter to a
4092 * single filter. It isn't well documented, but png_set_filter
4093 * does accept a filter number (per the spec) as well as a bit
4096 * The code now uses filters at random, except that on the first
4097 * row of an image it ensures that a previous row filter is in
4098 * the set so that libpng allocates the row buffer.
4101 int filters = 8 << random_mod(PNG_FILTER_VALUE_LAST);
4103 if (pass == 0 && y == 0 &&
4104 (filters < PNG_FILTER_UP || w == 1U))
4105 filters |= PNG_FILTER_UP;
4107 png_set_filter(pp, 0/*method*/, filters);
4111 png_write_row(pp, row);
4116 #ifdef PNG_TEXT_SUPPORTED
4118 static char key[] = "end marker";
4119 static char comment[] = "end";
4122 /* Use a compressed text string to test the correct interaction of text
4123 * compression and IDAT compression.
4125 text.compression = TEXT_COMPRESSION;
4127 text.text = comment;
4128 text.text_length = (sizeof comment)-1;
4129 text.itxt_length = 0;
4133 png_set_text(pp, pi, &text, 1);
4137 png_write_end(pp, pi);
4139 /* And store this under the appropriate id, then clean up. */
4140 store_storefile(ps, id);
4142 store_write_reset(ps);
4147 /* Use the png_store returned by the exception. This may help the compiler
4148 * because 'ps' is not used in this branch of the setjmp. Note that fault
4149 * and ps will always be the same value.
4151 store_write_reset(fault);
4156 make_size(png_store* const ps, png_byte const colour_type, int bdlo,
4159 for (; bdlo <= bdhi; ++bdlo)
4163 for (width = 1; width <= 16; ++width)
4167 for (height = 1; height <= 16; ++height)
4169 /* The four combinations of DIY interlace and interlace or not -
4170 * no interlace + DIY should be identical to no interlace with
4173 make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_NONE,
4175 make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_NONE,
4177 # ifdef PNG_WRITE_INTERLACING_SUPPORTED
4178 make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_ADAM7,
4181 # if CAN_WRITE_INTERLACE
4182 /* 1.7.0 removes the hack that prevented app write of an interlaced
4183 * image if WRITE_INTERLACE was not supported
4185 make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_ADAM7,
4194 make_size_images(png_store *ps)
4196 /* This is in case of errors. */
4197 safecat(ps->test, sizeof ps->test, 0, "make size images");
4199 /* Arguments are colour_type, low bit depth, high bit depth
4201 make_size(ps, 0, 0, WRITE_BDHI);
4202 make_size(ps, 2, 3, WRITE_BDHI);
4203 make_size(ps, 3, 0, 3 /*palette: max 8 bits*/);
4204 make_size(ps, 4, 3, WRITE_BDHI);
4205 make_size(ps, 6, 3, WRITE_BDHI);
4208 #ifdef PNG_READ_SUPPORTED
4209 /* Return a row based on image id and 'y' for checking: */
4211 standard_row(png_const_structp pp, png_byte std[STANDARD_ROWMAX],
4212 png_uint_32 id, png_uint_32 y)
4214 if (WIDTH_FROM_ID(id) == 0)
4215 transform_row(pp, std, COL_FROM_ID(id), DEPTH_FROM_ID(id), y);
4217 size_row(std, WIDTH_FROM_ID(id) * bit_size(pp, COL_FROM_ID(id),
4218 DEPTH_FROM_ID(id)), y);
4220 #endif /* PNG_READ_SUPPORTED */
4222 /* Tests - individual test cases */
4223 /* Like 'make_standard' but errors are deliberately introduced into the calls
4224 * to ensure that they get detected - it should not be possible to write an
4225 * invalid image with libpng!
4227 /* TODO: the 'set' functions can probably all be made to take a
4228 * png_const_structp rather than a modifiable one.
4230 #ifdef PNG_WARNINGS_SUPPORTED
4232 sBIT0_error_fn(png_structp pp, png_infop pi)
4234 /* 0 is invalid... */
4236 bad.red = bad.green = bad.blue = bad.gray = bad.alpha = 0;
4237 png_set_sBIT(pp, pi, &bad);
4241 sBIT_error_fn(png_structp pp, png_infop pi)
4246 if (png_get_color_type(pp, pi) == PNG_COLOR_TYPE_PALETTE)
4250 bit_depth = png_get_bit_depth(pp, pi);
4252 /* Now we know the bit depth we can easily generate an invalid sBIT entry */
4253 bad.red = bad.green = bad.blue = bad.gray = bad.alpha =
4254 (png_byte)(bit_depth+1);
4255 png_set_sBIT(pp, pi, &bad);
4260 void (*fn)(png_structp, png_infop);
4262 unsigned int warning :1; /* the error is a warning... */
4265 /* no warnings makes these errors undetectable prior to 1.7.0 */
4266 { sBIT0_error_fn, "sBIT(0): failed to detect error",
4267 PNG_LIBPNG_VER < 10700 },
4269 { sBIT_error_fn, "sBIT(too big): failed to detect error",
4270 PNG_LIBPNG_VER < 10700 },
4274 make_error(png_store* const ps, png_byte const colour_type,
4275 png_byte bit_depth, int interlace_type, int test, png_const_charp name)
4279 check_interlace_type(interlace_type);
4284 const png_structp pp = set_store_for_write(ps, &pi, name);
4291 w = transform_width(pp, colour_type, bit_depth);
4293 h = transform_height(pp, colour_type, bit_depth);
4295 png_set_IHDR(pp, pi, w, h, bit_depth, colour_type, interlace_type,
4296 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
4298 if (colour_type == 3) /* palette */
4299 init_standard_palette(ps, pp, pi, 1U << bit_depth, 0/*do tRNS*/);
4301 /* Time for a few errors; these are in various optional chunks, the
4302 * standard tests test the standard chunks pretty well.
4304 # define exception__prev exception_prev_1
4305 # define exception__env exception_env_1
4308 gnu_volatile(exception__prev)
4310 /* Expect this to throw: */
4311 ps->expect_error = !error_test[test].warning;
4312 ps->expect_warning = error_test[test].warning;
4313 ps->saw_warning = 0;
4314 error_test[test].fn(pp, pi);
4316 /* Normally the error is only detected here: */
4317 png_write_info(pp, pi);
4319 /* And handle the case where it was only a warning: */
4320 if (ps->expect_warning && ps->saw_warning)
4323 /* If we get here there is a problem, we have success - no error or
4324 * no warning - when we shouldn't have success. Log an error.
4326 store_log(ps, pp, error_test[test].msg, 1 /*error*/);
4330 { /* expected exit */
4332 #undef exception__prev
4333 #undef exception__env
4335 /* And clear these flags */
4336 ps->expect_warning = 0;
4338 if (ps->expect_error)
4339 ps->expect_error = 0;
4343 /* Now write the whole image, just to make sure that the detected, or
4344 * undetected, errro has not created problems inside libpng. This
4345 * doesn't work if there was a png_error in png_write_info because that
4346 * can abort before PLTE was written.
4348 if (png_get_rowbytes(pp, pi) !=
4349 transform_rowsize(pp, colour_type, bit_depth))
4350 png_error(pp, "row size incorrect");
4354 int npasses = set_write_interlace_handling(pp, interlace_type);
4357 if (npasses != npasses_from_interlace_type(pp, interlace_type))
4358 png_error(pp, "write: png_set_interlace_handling failed");
4360 for (pass=0; pass<npasses; ++pass)
4366 png_byte buffer[TRANSFORM_ROWMAX];
4368 transform_row(pp, buffer, colour_type, bit_depth, y);
4370 # if do_own_interlace
4371 /* If do_own_interlace *and* the image is interlaced we
4372 * need a reduced interlace row; this may be reduced to
4375 if (interlace_type == PNG_INTERLACE_ADAM7)
4377 /* The row must not be written if it doesn't exist,
4378 * notice that there are two conditions here, either the
4379 * row isn't ever in the pass or the row would be but
4380 * isn't wide enough to contribute any pixels. In fact
4381 * the wPass test can be used to skip the whole y loop
4384 if (PNG_ROW_IN_INTERLACE_PASS(y, pass) &&
4385 PNG_PASS_COLS(w, pass) > 0)
4386 interlace_row(buffer, buffer,
4387 bit_size(pp, colour_type, bit_depth), w, pass,
4388 0/*data always bigendian*/);
4392 # endif /* do_own_interlace */
4394 png_write_row(pp, buffer);
4397 } /* image writing */
4399 png_write_end(pp, pi);
4402 /* The following deletes the file that was just written. */
4403 store_write_reset(ps);
4408 store_write_reset(fault);
4413 make_errors(png_modifier* const pm, png_byte const colour_type,
4414 int bdlo, int const bdhi)
4416 for (; bdlo <= bdhi; ++bdlo)
4420 for (interlace_type = PNG_INTERLACE_NONE;
4421 interlace_type < INTERLACE_LAST; ++interlace_type)
4424 char name[FILE_NAME_SIZE];
4426 standard_name(name, sizeof name, 0, colour_type, 1<<bdlo, 0,
4427 interlace_type, 0, 0, do_own_interlace);
4429 for (test=0; test<ARRAY_SIZE(error_test); ++test)
4431 make_error(&pm->this, colour_type, DEPTH(bdlo), interlace_type,
4440 return 1; /* keep going */
4442 #endif /* PNG_WARNINGS_SUPPORTED */
4445 perform_error_test(png_modifier *pm)
4447 #ifdef PNG_WARNINGS_SUPPORTED /* else there are no cases that work! */
4448 /* Need to do this here because we just write in this test. */
4449 safecat(pm->this.test, sizeof pm->this.test, 0, "error test");
4451 if (!make_errors(pm, 0, 0, WRITE_BDHI))
4454 if (!make_errors(pm, 2, 3, WRITE_BDHI))
4457 if (!make_errors(pm, 3, 0, 3))
4460 if (!make_errors(pm, 4, 3, WRITE_BDHI))
4463 if (!make_errors(pm, 6, 3, WRITE_BDHI))
4470 /* This is just to validate the internal PNG formatting code - if this fails
4471 * then the warning messages the library outputs will probably be garbage.
4474 perform_formatting_test(png_store *ps)
4476 #ifdef PNG_TIME_RFC1123_SUPPORTED
4477 /* The handle into the formatting code is the RFC1123 support; this test does
4478 * nothing if that is compiled out.
4484 png_const_charp correct = "29 Aug 2079 13:53:60 +0000";
4485 png_const_charp result;
4486 # if PNG_LIBPNG_VER >= 10600
4487 char timestring[29];
4492 pp = set_store_for_write(ps, NULL, "libpng formatting test");
4498 /* Arbitrary settings: */
4504 pt.second = 60; /* a leap second */
4506 # if PNG_LIBPNG_VER < 10600
4507 result = png_convert_to_rfc1123(pp, &pt);
4509 if (png_convert_to_rfc1123_buffer(timestring, &pt))
4510 result = timestring;
4517 png_error(pp, "png_convert_to_rfc1123 failed");
4519 if (strcmp(result, correct) != 0)
4524 pos = safecat(msg, sizeof msg, pos, "png_convert_to_rfc1123(");
4525 pos = safecat(msg, sizeof msg, pos, correct);
4526 pos = safecat(msg, sizeof msg, pos, ") returned: '");
4527 pos = safecat(msg, sizeof msg, pos, result);
4528 pos = safecat(msg, sizeof msg, pos, "'");
4533 store_write_reset(ps);
4538 store_write_reset(fault);
4545 #ifdef PNG_READ_SUPPORTED
4546 /* Because we want to use the same code in both the progressive reader and the
4547 * sequential reader it is necessary to deal with the fact that the progressive
4548 * reader callbacks only have one parameter (png_get_progressive_ptr()), so this
4549 * must contain all the test parameters and all the local variables directly
4550 * accessible to the sequential reader implementation.
4552 * The technique adopted is to reinvent part of what Dijkstra termed a
4553 * 'display'; an array of pointers to the stack frames of enclosing functions so
4554 * that a nested function definition can access the local (C auto) variables of
4555 * the functions that contain its definition. In fact C provides the first
4556 * pointer (the local variables - the stack frame pointer) and the last (the
4557 * global variables - the BCPL global vector typically implemented as global
4558 * addresses), this code requires one more pointer to make the display - the
4559 * local variables (and function call parameters) of the function that actually
4560 * invokes either the progressive or sequential reader.
4562 * Perhaps confusingly this technique is confounded with classes - the
4563 * 'standard_display' defined here is sub-classed as the 'gamma_display' below.
4564 * A gamma_display is a standard_display, taking advantage of the ANSI-C
4565 * requirement that the pointer to the first member of a structure must be the
4566 * same as the pointer to the structure. This allows us to reuse standard_
4567 * functions in the gamma test code; something that could not be done with
4570 typedef struct standard_display
4572 png_store* ps; /* Test parameters (passed to the function) */
4573 png_byte colour_type;
4575 png_byte red_sBIT; /* Input data sBIT values. */
4576 png_byte green_sBIT;
4578 png_byte alpha_sBIT;
4579 png_byte interlace_type;
4580 png_byte filler; /* Output has a filler */
4581 png_uint_32 id; /* Calculated file ID */
4582 png_uint_32 w; /* Width of image */
4583 png_uint_32 h; /* Height of image */
4584 int npasses; /* Number of interlaced passes */
4585 png_uint_32 pixel_size; /* Width of one pixel in bits */
4586 png_uint_32 bit_width; /* Width of output row in bits */
4587 size_t cbRow; /* Bytes in a row of the output image */
4588 int do_interlace; /* Do interlacing internally */
4589 int littleendian; /* App (row) data is little endian */
4590 int is_transparent; /* Transparency information was present. */
4591 int has_tRNS; /* color type GRAY or RGB with a tRNS chunk. */
4592 int speed; /* Doing a speed test */
4593 int use_update_info;/* Call update_info, not start_image */
4599 } transparent; /* The transparent color, if set. */
4600 int npalette; /* Number of entries in the palette. */
4606 standard_display_init(standard_display *dp, png_store* ps, png_uint_32 id,
4607 int do_interlace, int use_update_info)
4609 memset(dp, 0, sizeof *dp);
4612 dp->colour_type = COL_FROM_ID(id);
4613 dp->bit_depth = DEPTH_FROM_ID(id);
4614 if (dp->bit_depth < 1 || dp->bit_depth > 16)
4615 internal_error(ps, "internal: bad bit depth");
4616 if (dp->colour_type == 3)
4617 dp->red_sBIT = dp->blue_sBIT = dp->green_sBIT = dp->alpha_sBIT = 8;
4619 dp->red_sBIT = dp->blue_sBIT = dp->green_sBIT = dp->alpha_sBIT =
4621 dp->interlace_type = INTERLACE_FROM_ID(id);
4622 check_interlace_type(dp->interlace_type);
4624 /* All the rest are filled in after the read_info: */
4631 dp->do_interlace = do_interlace;
4632 dp->littleendian = 0;
4633 dp->is_transparent = 0;
4634 dp->speed = ps->speed;
4635 dp->use_update_info = use_update_info;
4637 /* Preset the transparent color to black: */
4638 memset(&dp->transparent, 0, sizeof dp->transparent);
4639 /* Preset the palette to full intensity/opaque througout: */
4640 memset(dp->palette, 0xff, sizeof dp->palette);
4643 /* Initialize the palette fields - this must be done later because the palette
4644 * comes from the particular png_store_file that is selected.
4647 standard_palette_init(standard_display *dp)
4649 store_palette_entry *palette = store_current_palette(dp->ps, &dp->npalette);
4651 /* The remaining entries remain white/opaque. */
4652 if (dp->npalette > 0)
4654 int i = dp->npalette;
4655 memcpy(dp->palette, palette, i * sizeof *palette);
4657 /* Check for a non-opaque palette entry: */
4659 if (palette[i].alpha < 255)
4663 /* GCC can't handle the more obviously optimizable version. */
4665 dp->is_transparent = 1;
4667 dp->is_transparent = 0;
4669 dp->is_transparent = (i >= 0);
4674 /* Utility to read the palette from the PNG file and convert it into
4675 * store_palette format. This returns 1 if there is any transparency in the
4676 * palette (it does not check for a transparent colour in the non-palette case.)
4679 read_palette(store_palette palette, int *npalette, png_const_structp pp,
4683 png_bytep trans_alpha;
4689 if (png_get_PLTE(pp, pi, &pal, npalette) & PNG_INFO_PLTE)
4693 if (i <= 0 || i > 256)
4694 png_error(pp, "validate: invalid PLTE count");
4698 palette[i].red = pal[i].red;
4699 palette[i].green = pal[i].green;
4700 palette[i].blue = pal[i].blue;
4703 /* Mark the remainder of the entries with a flag value (other than
4704 * white/opaque which is the flag value stored above.)
4706 memset(palette + *npalette, 126, (256-*npalette) * sizeof *palette);
4709 else /* !png_get_PLTE */
4711 if (*npalette != (-1))
4712 png_error(pp, "validate: invalid PLTE result");
4713 /* But there is no palette, so record this: */
4715 memset(palette, 113, sizeof (store_palette));
4719 num = 2; /* force error below */
4720 if ((png_get_tRNS(pp, pi, &trans_alpha, &num, 0) & PNG_INFO_tRNS) != 0 &&
4721 (trans_alpha != NULL || num != 1/*returns 1 for a transparent color*/) &&
4722 /* Oops, if a palette tRNS gets expanded png_read_update_info (at least so
4723 * far as 1.5.4) does not remove the trans_alpha pointer, only num_trans,
4724 * so in the above call we get a success, we get a pointer (who knows what
4725 * to) and we get num_trans == 0:
4727 !(trans_alpha != NULL && num == 0)) /* TODO: fix this in libpng. */
4731 /* Any of these are crash-worthy - given the implementation of
4732 * png_get_tRNS up to 1.5 an app won't crash if it just checks the
4733 * result above and fails to check that the variables it passed have
4734 * actually been filled in! Note that if the app were to pass the
4735 * last, png_color_16p, variable too it couldn't rely on this.
4737 if (trans_alpha == NULL || num <= 0 || num > 256 || num > *npalette)
4738 png_error(pp, "validate: unexpected png_get_tRNS (palette) result");
4740 for (i=0; i<num; ++i)
4741 palette[i].alpha = trans_alpha[i];
4743 for (num=*npalette; i<num; ++i)
4744 palette[i].alpha = 255;
4747 palette[i].alpha = 33; /* flag value */
4749 return 1; /* transparency */
4754 /* No palette transparency - just set the alpha channel to opaque. */
4757 for (i=0, num=*npalette; i<num; ++i)
4758 palette[i].alpha = 255;
4761 palette[i].alpha = 55; /* flag value */
4763 return 0; /* no transparency */
4767 /* Utility to validate the palette if it should not have changed (the
4768 * non-transform case).
4771 standard_palette_validate(standard_display *dp, png_const_structp pp,
4775 store_palette palette;
4777 if (read_palette(palette, &npalette, pp, pi) != dp->is_transparent)
4778 png_error(pp, "validate: palette transparency changed");
4780 if (npalette != dp->npalette)
4785 pos = safecat(msg, sizeof msg, pos, "validate: palette size changed: ");
4786 pos = safecatn(msg, sizeof msg, pos, dp->npalette);
4787 pos = safecat(msg, sizeof msg, pos, " -> ");
4788 pos = safecatn(msg, sizeof msg, pos, npalette);
4793 int i = npalette; /* npalette is aliased */
4796 if (palette[i].red != dp->palette[i].red ||
4797 palette[i].green != dp->palette[i].green ||
4798 palette[i].blue != dp->palette[i].blue ||
4799 palette[i].alpha != dp->palette[i].alpha)
4800 png_error(pp, "validate: PLTE or tRNS chunk changed");
4804 /* By passing a 'standard_display' the progressive callbacks can be used
4805 * directly by the sequential code, the functions suffixed "_imp" are the
4806 * implementations, the functions without the suffix are the callbacks.
4808 * The code for the info callback is split into two because this callback calls
4809 * png_read_update_info or png_start_read_image and what gets called depends on
4810 * whether the info needs updating (we want to test both calls in pngvalid.)
4813 standard_info_part1(standard_display *dp, png_structp pp, png_infop pi)
4815 if (png_get_bit_depth(pp, pi) != dp->bit_depth)
4816 png_error(pp, "validate: bit depth changed");
4818 if (png_get_color_type(pp, pi) != dp->colour_type)
4819 png_error(pp, "validate: color type changed");
4821 if (png_get_filter_type(pp, pi) != PNG_FILTER_TYPE_BASE)
4822 png_error(pp, "validate: filter type changed");
4824 if (png_get_interlace_type(pp, pi) != dp->interlace_type)
4825 png_error(pp, "validate: interlacing changed");
4827 if (png_get_compression_type(pp, pi) != PNG_COMPRESSION_TYPE_BASE)
4828 png_error(pp, "validate: compression type changed");
4830 dp->w = png_get_image_width(pp, pi);
4832 if (dp->w != standard_width(pp, dp->id))
4833 png_error(pp, "validate: image width changed");
4835 dp->h = png_get_image_height(pp, pi);
4837 if (dp->h != standard_height(pp, dp->id))
4838 png_error(pp, "validate: image height changed");
4840 /* Record (but don't check at present) the input sBIT according to the colour
4844 png_color_8p sBIT = 0;
4846 if (png_get_sBIT(pp, pi, &sBIT) & PNG_INFO_sBIT)
4848 int sBIT_invalid = 0;
4851 png_error(pp, "validate: unexpected png_get_sBIT result");
4853 if (dp->colour_type & PNG_COLOR_MASK_COLOR)
4855 if (sBIT->red == 0 || sBIT->red > dp->bit_depth)
4858 dp->red_sBIT = sBIT->red;
4860 if (sBIT->green == 0 || sBIT->green > dp->bit_depth)
4863 dp->green_sBIT = sBIT->green;
4865 if (sBIT->blue == 0 || sBIT->blue > dp->bit_depth)
4868 dp->blue_sBIT = sBIT->blue;
4873 if (sBIT->gray == 0 || sBIT->gray > dp->bit_depth)
4876 dp->blue_sBIT = dp->green_sBIT = dp->red_sBIT = sBIT->gray;
4879 /* All 8 bits in tRNS for a palette image are significant - see the
4882 if (dp->colour_type & PNG_COLOR_MASK_ALPHA)
4884 if (sBIT->alpha == 0 || sBIT->alpha > dp->bit_depth)
4887 dp->alpha_sBIT = sBIT->alpha;
4891 png_error(pp, "validate: sBIT value out of range");
4895 /* Important: this is validating the value *before* any transforms have been
4896 * put in place. It doesn't matter for the standard tests, where there are
4897 * no transforms, but it does for other tests where rowbytes may change after
4898 * png_read_update_info.
4900 if (png_get_rowbytes(pp, pi) != standard_rowsize(pp, dp->id))
4901 png_error(pp, "validate: row size changed");
4903 /* Validate the colour type 3 palette (this can be present on other color
4906 standard_palette_validate(dp, pp, pi);
4908 /* In any case always check for a tranparent color (notice that the
4909 * colour type 3 case must not give a successful return on the get_tRNS call
4910 * with these arguments!)
4913 png_color_16p trans_color = 0;
4915 if (png_get_tRNS(pp, pi, 0, 0, &trans_color) & PNG_INFO_tRNS)
4917 if (trans_color == 0)
4918 png_error(pp, "validate: unexpected png_get_tRNS (color) result");
4920 switch (dp->colour_type)
4923 dp->transparent.red = dp->transparent.green = dp->transparent.blue =
4929 dp->transparent.red = trans_color->red;
4930 dp->transparent.green = trans_color->green;
4931 dp->transparent.blue = trans_color->blue;
4936 /* Not expected because it should result in the array case
4939 png_error(pp, "validate: unexpected png_get_tRNS result");
4943 png_error(pp, "validate: invalid tRNS chunk with alpha image");
4948 /* Read the number of passes - expected to match the value used when
4949 * creating the image (interlaced or not). This has the side effect of
4950 * turning on interlace handling (if do_interlace is not set.)
4952 dp->npasses = npasses_from_interlace_type(pp, dp->interlace_type);
4953 if (!dp->do_interlace)
4955 # ifdef PNG_READ_INTERLACING_SUPPORTED
4956 if (dp->npasses != png_set_interlace_handling(pp))
4957 png_error(pp, "validate: file changed interlace type");
4958 # else /* !READ_INTERLACING */
4959 /* This should never happen: the relevant tests (!do_interlace) should
4962 if (dp->npasses > 1)
4963 png_error(pp, "validate: no libpng interlace support");
4964 # endif /* !READ_INTERLACING */
4967 /* Caller calls png_read_update_info or png_start_read_image now, then calls
4972 /* This must be called *after* the png_read_update_info call to get the correct
4973 * 'rowbytes' value, otherwise png_get_rowbytes will refer to the untransformed
4977 standard_info_part2(standard_display *dp, png_const_structp pp,
4978 png_const_infop pi, int nImages)
4980 /* Record cbRow now that it can be found. */
4982 png_byte ct = png_get_color_type(pp, pi);
4983 png_byte bd = png_get_bit_depth(pp, pi);
4985 if (bd >= 8 && (ct == PNG_COLOR_TYPE_RGB || ct == PNG_COLOR_TYPE_GRAY) &&
4987 ct |= 4; /* handle filler as faked alpha channel */
4989 dp->pixel_size = bit_size(pp, ct, bd);
4991 dp->bit_width = png_get_image_width(pp, pi) * dp->pixel_size;
4992 dp->cbRow = png_get_rowbytes(pp, pi);
4994 /* Validate the rowbytes here again. */
4995 if (dp->cbRow != (dp->bit_width+7)/8)
4996 png_error(pp, "bad png_get_rowbytes calculation");
4998 /* Then ensure there is enough space for the output image(s). */
4999 store_ensure_image(dp->ps, pp, nImages, dp->cbRow, dp->h);
5003 standard_info_imp(standard_display *dp, png_structp pp, png_infop pi,
5006 /* Note that the validation routine has the side effect of turning on
5007 * interlace handling in the subsequent code.
5009 standard_info_part1(dp, pp, pi);
5011 /* And the info callback has to call this (or png_read_update_info - see
5012 * below in the png_modifier code for that variant.
5014 if (dp->use_update_info)
5016 /* For debugging the effect of multiple calls: */
5017 int i = dp->use_update_info;
5019 png_read_update_info(pp, pi);
5023 png_start_read_image(pp);
5025 /* Validate the height, width and rowbytes plus ensure that sufficient buffer
5026 * exists for decoding the image.
5028 standard_info_part2(dp, pp, pi, nImages);
5031 static void PNGCBAPI
5032 standard_info(png_structp pp, png_infop pi)
5034 standard_display *dp = voidcast(standard_display*,
5035 png_get_progressive_ptr(pp));
5037 /* Call with nImages==1 because the progressive reader can only produce one
5040 standard_info_imp(dp, pp, pi, 1 /*only one image*/);
5043 static void PNGCBAPI
5044 progressive_row(png_structp ppIn, png_bytep new_row, png_uint_32 y, int pass)
5046 png_const_structp pp = ppIn;
5047 const standard_display *dp = voidcast(standard_display*,
5048 png_get_progressive_ptr(pp));
5050 /* When handling interlacing some rows will be absent in each pass, the
5051 * callback still gets called, but with a NULL pointer. This is checked
5052 * in the 'else' clause below. We need our own 'cbRow', but we can't call
5053 * png_get_rowbytes because we got no info structure.
5055 if (new_row != NULL)
5059 /* In the case where the reader doesn't do the interlace it gives
5060 * us the y in the sub-image:
5062 if (dp->do_interlace && dp->interlace_type == PNG_INTERLACE_ADAM7)
5064 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
5065 /* Use this opportunity to validate the png 'current' APIs: */
5066 if (y != png_get_current_row_number(pp))
5067 png_error(pp, "png_get_current_row_number is broken");
5069 if (pass != png_get_current_pass_number(pp))
5070 png_error(pp, "png_get_current_pass_number is broken");
5071 #endif /* USER_TRANSFORM_INFO */
5073 y = PNG_ROW_FROM_PASS_ROW(y, pass);
5076 /* Validate this just in case. */
5078 png_error(pp, "invalid y to progressive row callback");
5080 row = store_image_row(dp->ps, pp, 0, y);
5082 /* Combine the new row into the old: */
5083 #ifdef PNG_READ_INTERLACING_SUPPORTED
5084 if (dp->do_interlace)
5085 #endif /* READ_INTERLACING */
5087 if (dp->interlace_type == PNG_INTERLACE_ADAM7)
5088 deinterlace_row(row, new_row, dp->pixel_size, dp->w, pass,
5091 row_copy(row, new_row, dp->pixel_size * dp->w, dp->littleendian);
5093 #ifdef PNG_READ_INTERLACING_SUPPORTED
5095 png_progressive_combine_row(pp, row, new_row);
5096 #endif /* PNG_READ_INTERLACING_SUPPORTED */
5099 else if (dp->interlace_type == PNG_INTERLACE_ADAM7 &&
5100 PNG_ROW_IN_INTERLACE_PASS(y, pass) &&
5101 PNG_PASS_COLS(dp->w, pass) > 0)
5102 png_error(pp, "missing row in progressive de-interlacing");
5106 sequential_row(standard_display *dp, png_structp pp, png_infop pi,
5107 const int iImage, const int iDisplay)
5109 const int npasses = dp->npasses;
5110 const int do_interlace = dp->do_interlace &&
5111 dp->interlace_type == PNG_INTERLACE_ADAM7;
5112 const png_uint_32 height = standard_height(pp, dp->id);
5113 const png_uint_32 width = standard_width(pp, dp->id);
5114 const png_store* ps = dp->ps;
5117 for (pass=0; pass<npasses; ++pass)
5120 png_uint_32 wPass = PNG_PASS_COLS(width, pass);
5122 for (y=0; y<height; ++y)
5126 /* wPass may be zero or this row may not be in this pass.
5127 * png_read_row must not be called in either case.
5129 if (wPass > 0 && PNG_ROW_IN_INTERLACE_PASS(y, pass))
5131 /* Read the row into a pair of temporary buffers, then do the
5132 * merge here into the output rows.
5134 png_byte row[STANDARD_ROWMAX], display[STANDARD_ROWMAX];
5136 /* The following aids (to some extent) error detection - we can
5137 * see where png_read_row wrote. Use opposite values in row and
5138 * display to make this easier. Don't use 0xff (which is used in
5139 * the image write code to fill unused bits) or 0 (which is a
5140 * likely value to overwrite unused bits with).
5142 memset(row, 0xc5, sizeof row);
5143 memset(display, 0x5c, sizeof display);
5145 png_read_row(pp, row, display);
5148 deinterlace_row(store_image_row(ps, pp, iImage, y), row,
5149 dp->pixel_size, dp->w, pass, dp->littleendian);
5152 deinterlace_row(store_image_row(ps, pp, iDisplay, y), display,
5153 dp->pixel_size, dp->w, pass, dp->littleendian);
5158 iImage >= 0 ? store_image_row(ps, pp, iImage, y) : NULL,
5159 iDisplay >= 0 ? store_image_row(ps, pp, iDisplay, y) : NULL);
5163 /* And finish the read operation (only really necessary if the caller wants
5164 * to find additional data in png_info from chunks after the last IDAT.)
5166 png_read_end(pp, pi);
5169 #ifdef PNG_TEXT_SUPPORTED
5171 standard_check_text(png_const_structp pp, png_const_textp tp,
5172 png_const_charp keyword, png_const_charp text)
5175 size_t pos = safecat(msg, sizeof msg, 0, "text: ");
5178 pos = safecat(msg, sizeof msg, pos, keyword);
5179 pos = safecat(msg, sizeof msg, pos, ": ");
5182 if (tp->compression != TEXT_COMPRESSION)
5186 sprintf(buf, "compression [%d->%d], ", TEXT_COMPRESSION,
5188 pos = safecat(msg, sizeof msg, pos, buf);
5191 if (tp->key == NULL || strcmp(tp->key, keyword) != 0)
5193 pos = safecat(msg, sizeof msg, pos, "keyword \"");
5194 if (tp->key != NULL)
5196 pos = safecat(msg, sizeof msg, pos, tp->key);
5197 pos = safecat(msg, sizeof msg, pos, "\", ");
5201 pos = safecat(msg, sizeof msg, pos, "null, ");
5204 if (tp->text == NULL)
5205 pos = safecat(msg, sizeof msg, pos, "text lost, ");
5209 if (tp->text_length != strlen(text))
5212 sprintf(buf, "text length changed[%lu->%lu], ",
5213 (unsigned long)strlen(text), (unsigned long)tp->text_length);
5214 pos = safecat(msg, sizeof msg, pos, buf);
5217 if (strcmp(tp->text, text) != 0)
5219 pos = safecat(msg, sizeof msg, pos, "text becomes \"");
5220 pos = safecat(msg, sizeof msg, pos, tp->text);
5221 pos = safecat(msg, sizeof msg, pos, "\" (was \"");
5222 pos = safecat(msg, sizeof msg, pos, text);
5223 pos = safecat(msg, sizeof msg, pos, "\"), ");
5227 if (tp->itxt_length != 0)
5228 pos = safecat(msg, sizeof msg, pos, "iTXt length set, ");
5230 if (tp->lang != NULL)
5232 pos = safecat(msg, sizeof msg, pos, "iTXt language \"");
5233 pos = safecat(msg, sizeof msg, pos, tp->lang);
5234 pos = safecat(msg, sizeof msg, pos, "\", ");
5237 if (tp->lang_key != NULL)
5239 pos = safecat(msg, sizeof msg, pos, "iTXt keyword \"");
5240 pos = safecat(msg, sizeof msg, pos, tp->lang_key);
5241 pos = safecat(msg, sizeof msg, pos, "\", ");
5246 msg[pos-2] = '\0'; /* Remove the ", " at the end */
5252 standard_text_validate(standard_display *dp, png_const_structp pp,
5253 png_infop pi, int check_end)
5255 png_textp tp = NULL;
5256 png_uint_32 num_text = png_get_text(pp, pi, &tp, NULL);
5258 if (num_text == 2 && tp != NULL)
5260 standard_check_text(pp, tp, "image name", dp->ps->current->name);
5262 /* This exists because prior to 1.5.18 the progressive reader left the
5263 * png_struct z_stream unreset at the end of the image, so subsequent
5264 * attempts to use it simply returns Z_STREAM_END.
5267 standard_check_text(pp, tp+1, "end marker", "end");
5274 sprintf(msg, "expected two text items, got %lu",
5275 (unsigned long)num_text);
5280 # define standard_text_validate(dp,pp,pi,check_end) ((void)0)
5284 standard_row_validate(standard_display *dp, png_const_structp pp,
5285 int iImage, int iDisplay, png_uint_32 y)
5288 png_byte std[STANDARD_ROWMAX];
5290 /* The row must be pre-initialized to the magic number here for the size
5293 memset(std, 178, sizeof std);
5294 standard_row(pp, std, dp->id, y);
5296 /* At the end both the 'row' and 'display' arrays should end up identical.
5297 * In earlier passes 'row' will be partially filled in, with only the pixels
5298 * that have been read so far, but 'display' will have those pixels
5299 * replicated to fill the unread pixels while reading an interlaced image.
5302 (where = pixel_cmp(std, store_image_row(dp->ps, pp, iImage, y),
5303 dp->bit_width)) != 0)
5306 sprintf(msg, "PNG image row[%lu][%d] changed from %.2x to %.2x",
5307 (unsigned long)y, where-1, std[where-1],
5308 store_image_row(dp->ps, pp, iImage, y)[where-1]);
5312 if (iDisplay >= 0 &&
5313 (where = pixel_cmp(std, store_image_row(dp->ps, pp, iDisplay, y),
5314 dp->bit_width)) != 0)
5317 sprintf(msg, "display row[%lu][%d] changed from %.2x to %.2x",
5318 (unsigned long)y, where-1, std[where-1],
5319 store_image_row(dp->ps, pp, iDisplay, y)[where-1]);
5325 standard_image_validate(standard_display *dp, png_const_structp pp, int iImage,
5331 store_image_check(dp->ps, pp, iImage);
5334 store_image_check(dp->ps, pp, iDisplay);
5336 for (y=0; y<dp->h; ++y)
5337 standard_row_validate(dp, pp, iImage, iDisplay, y);
5339 /* This avoids false positives if the validation code is never called! */
5340 dp->ps->validated = 1;
5343 static void PNGCBAPI
5344 standard_end(png_structp ppIn, png_infop pi)
5346 png_const_structp pp = ppIn;
5347 standard_display *dp = voidcast(standard_display*,
5348 png_get_progressive_ptr(pp));
5352 /* Validate the image - progressive reading only produces one variant for
5353 * interlaced images.
5355 standard_text_validate(dp, pp, pi,
5356 PNG_LIBPNG_VER >= 10518/*check_end: see comments above*/);
5357 standard_image_validate(dp, pp, 0, -1);
5360 /* A single test run checking the standard image to ensure it is not damaged. */
5362 standard_test(png_store* const psIn, png_uint_32 const id,
5363 int do_interlace, int use_update_info)
5366 context(psIn, fault);
5368 /* Set up the display (stack frame) variables from the arguments to the
5369 * function and initialize the locals that are filled in later.
5371 standard_display_init(&d, psIn, id, do_interlace, use_update_info);
5373 /* Everything is protected by a Try/Catch. The functions called also
5374 * typically have local Try/Catch blocks.
5381 /* Get a png_struct for reading the image. This will throw an error if it
5382 * fails, so we don't need to check the result.
5384 pp = set_store_for_read(d.ps, &pi, d.id,
5385 d.do_interlace ? (d.ps->progressive ?
5386 "pngvalid progressive deinterlacer" :
5387 "pngvalid sequential deinterlacer") : (d.ps->progressive ?
5388 "progressive reader" : "sequential reader"));
5390 /* Initialize the palette correctly from the png_store_file. */
5391 standard_palette_init(&d);
5393 /* Introduce the correct read function. */
5394 if (d.ps->progressive)
5396 png_set_progressive_read_fn(pp, &d, standard_info, progressive_row,
5399 /* Now feed data into the reader until we reach the end: */
5400 store_progressive_read(d.ps, pp, pi);
5404 /* Note that this takes the store, not the display. */
5405 png_set_read_fn(pp, d.ps, store_read);
5407 /* Check the header values: */
5408 png_read_info(pp, pi);
5410 /* The code tests both versions of the images that the sequential
5411 * reader can produce.
5413 standard_info_imp(&d, pp, pi, 2 /*images*/);
5415 /* Need the total bytes in the image below; we can't get to this point
5416 * unless the PNG file values have been checked against the expected
5420 sequential_row(&d, pp, pi, 0, 1);
5422 /* After the last pass loop over the rows again to check that the
5427 standard_text_validate(&d, pp, pi, 1/*check_end*/);
5428 standard_image_validate(&d, pp, 0, 1);
5431 d.ps->validated = 1;
5435 /* Check for validation. */
5436 if (!d.ps->validated)
5437 png_error(pp, "image read failed silently");
5439 /* Successful completion. */
5443 d.ps = fault; /* make sure this hasn't been clobbered. */
5445 /* In either case clean up the store. */
5446 store_read_reset(d.ps);
5450 test_standard(png_modifier* const pm, png_byte const colour_type,
5451 int bdlo, int const bdhi)
5453 for (; bdlo <= bdhi; ++bdlo)
5457 for (interlace_type = PNG_INTERLACE_NONE;
5458 interlace_type < INTERLACE_LAST; ++interlace_type)
5460 standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
5461 interlace_type, 0, 0, 0), do_read_interlace, pm->use_update_info);
5468 return 1; /* keep going */
5472 perform_standard_test(png_modifier *pm)
5474 /* Test each colour type over the valid range of bit depths (expressed as
5475 * log2(bit_depth) in turn, stop as soon as any error is detected.
5477 if (!test_standard(pm, 0, 0, READ_BDHI))
5480 if (!test_standard(pm, 2, 3, READ_BDHI))
5483 if (!test_standard(pm, 3, 0, 3))
5486 if (!test_standard(pm, 4, 3, READ_BDHI))
5489 if (!test_standard(pm, 6, 3, READ_BDHI))
5494 /********************************** SIZE TESTS ********************************/
5496 test_size(png_modifier* const pm, png_byte const colour_type,
5497 int bdlo, int const bdhi)
5499 /* Run the tests on each combination.
5501 * NOTE: on my 32 bit x86 each of the following blocks takes
5502 * a total of 3.5 seconds if done across every combo of bit depth
5503 * width and height. This is a waste of time in practice, hence the
5504 * hinc and winc stuff:
5506 static const png_byte hinc[] = {1, 3, 11, 1, 5};
5507 static const png_byte winc[] = {1, 9, 5, 7, 1};
5508 const int save_bdlo = bdlo;
5510 for (; bdlo <= bdhi; ++bdlo)
5514 for (h=1; h<=16; h+=hinc[bdlo]) for (w=1; w<=16; w+=winc[bdlo])
5516 /* First test all the 'size' images against the sequential
5517 * reader using libpng to deinterlace (where required.) This
5518 * validates the write side of libpng. There are four possibilities
5521 standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
5522 PNG_INTERLACE_NONE, w, h, 0), 0/*do_interlace*/,
5523 pm->use_update_info);
5528 standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
5529 PNG_INTERLACE_NONE, w, h, 1), 0/*do_interlace*/,
5530 pm->use_update_info);
5535 /* Now validate the interlaced read side - do_interlace true,
5536 * in the progressive case this does actually make a difference
5537 * to the code used in the non-interlaced case too.
5539 standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
5540 PNG_INTERLACE_NONE, w, h, 0), 1/*do_interlace*/,
5541 pm->use_update_info);
5546 # if CAN_WRITE_INTERLACE
5547 /* Validate the pngvalid code itself: */
5548 standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
5549 PNG_INTERLACE_ADAM7, w, h, 1), 1/*do_interlace*/,
5550 pm->use_update_info);
5558 /* Now do the tests of libpng interlace handling, after we have made sure
5559 * that the pngvalid version works:
5561 for (bdlo = save_bdlo; bdlo <= bdhi; ++bdlo)
5565 for (h=1; h<=16; h+=hinc[bdlo]) for (w=1; w<=16; w+=winc[bdlo])
5567 # ifdef PNG_READ_INTERLACING_SUPPORTED
5568 /* Test with pngvalid generated interlaced images first; we have
5569 * already verify these are ok (unless pngvalid has self-consistent
5570 * read/write errors, which is unlikely), so this detects errors in the
5573 # if CAN_WRITE_INTERLACE
5574 standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
5575 PNG_INTERLACE_ADAM7, w, h, 1), 0/*do_interlace*/,
5576 pm->use_update_info);
5581 # endif /* READ_INTERLACING */
5583 # ifdef PNG_WRITE_INTERLACING_SUPPORTED
5584 /* Test the libpng write side against the pngvalid read side: */
5585 standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
5586 PNG_INTERLACE_ADAM7, w, h, 0), 1/*do_interlace*/,
5587 pm->use_update_info);
5593 # ifdef PNG_READ_INTERLACING_SUPPORTED
5594 # ifdef PNG_WRITE_INTERLACING_SUPPORTED
5595 /* Test both together: */
5596 standard_test(&pm->this, FILEID(colour_type, DEPTH(bdlo), 0/*palette*/,
5597 PNG_INTERLACE_ADAM7, w, h, 0), 0/*do_interlace*/,
5598 pm->use_update_info);
5603 # endif /* READ_INTERLACING */
5607 return 1; /* keep going */
5611 perform_size_test(png_modifier *pm)
5613 /* Test each colour type over the valid range of bit depths (expressed as
5614 * log2(bit_depth) in turn, stop as soon as any error is detected.
5616 if (!test_size(pm, 0, 0, READ_BDHI))
5619 if (!test_size(pm, 2, 3, READ_BDHI))
5622 /* For the moment don't do the palette test - it's a waste of time when
5623 * compared to the grayscale test.
5626 if (!test_size(pm, 3, 0, 3))
5630 if (!test_size(pm, 4, 3, READ_BDHI))
5633 if (!test_size(pm, 6, 3, READ_BDHI))
5638 /******************************* TRANSFORM TESTS ******************************/
5639 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
5640 /* A set of tests to validate libpng image transforms. The possibilities here
5641 * are legion because the transforms can be combined in a combinatorial
5642 * fashion. To deal with this some measure of restraint is required, otherwise
5643 * the tests would take forever.
5645 typedef struct image_pixel
5647 /* A local (pngvalid) representation of a PNG pixel, in all its
5650 unsigned int red, green, blue, alpha; /* For non-palette images. */
5651 unsigned int palette_index; /* For a palette image. */
5652 png_byte colour_type; /* As in the spec. */
5653 png_byte bit_depth; /* Defines bit size in row */
5654 png_byte sample_depth; /* Scale of samples */
5655 unsigned int have_tRNS :1; /* tRNS chunk may need processing */
5656 unsigned int swap_rgb :1; /* RGB swapped to BGR */
5657 unsigned int alpha_first :1; /* Alpha at start, not end */
5658 unsigned int alpha_inverted :1; /* Alpha channel inverted */
5659 unsigned int mono_inverted :1; /* Gray channel inverted */
5660 unsigned int swap16 :1; /* Byte swap 16-bit components */
5661 unsigned int littleendian :1; /* High bits on right */
5662 unsigned int sig_bits :1; /* Pixel shifted (sig bits only) */
5664 /* For checking the code calculates double precision floating point values
5665 * along with an error value, accumulated from the transforms. Because an
5666 * sBIT setting allows larger error bounds (indeed, by the spec, apparently
5667 * up to just less than +/-1 in the scaled value) the *lowest* sBIT for each
5668 * channel is stored. This sBIT value is folded in to the stored error value
5669 * at the end of the application of the transforms to the pixel.
5671 * If sig_bits is set above the red, green, blue and alpha values have been
5672 * scaled so they only contain the significant bits of the component values.
5674 double redf, greenf, bluef, alphaf;
5675 double rede, greene, bluee, alphae;
5676 png_byte red_sBIT, green_sBIT, blue_sBIT, alpha_sBIT;
5679 /* Shared utility function, see below. */
5681 image_pixel_setf(image_pixel *this, unsigned int rMax, unsigned int gMax,
5682 unsigned int bMax, unsigned int aMax)
5684 this->redf = this->red / (double)rMax;
5685 this->greenf = this->green / (double)gMax;
5686 this->bluef = this->blue / (double)bMax;
5687 this->alphaf = this->alpha / (double)aMax;
5689 if (this->red < rMax)
5690 this->rede = this->redf * DBL_EPSILON;
5693 if (this->green < gMax)
5694 this->greene = this->greenf * DBL_EPSILON;
5697 if (this->blue < bMax)
5698 this->bluee = this->bluef * DBL_EPSILON;
5701 if (this->alpha < aMax)
5702 this->alphae = this->alphaf * DBL_EPSILON;
5707 /* Initialize the structure for the next pixel - call this before doing any
5708 * transforms and call it for each pixel since all the fields may need to be
5712 image_pixel_init(image_pixel *this, png_const_bytep row, png_byte colour_type,
5713 png_byte bit_depth, png_uint_32 x, store_palette palette,
5714 const image_pixel *format /*from pngvalid transform of input*/)
5716 const png_byte sample_depth = (png_byte)(colour_type ==
5717 PNG_COLOR_TYPE_PALETTE ? 8 : bit_depth);
5718 const unsigned int max = (1U<<sample_depth)-1;
5719 const int swap16 = (format != 0 && format->swap16);
5720 const int littleendian = (format != 0 && format->littleendian);
5721 const int sig_bits = (format != 0 && format->sig_bits);
5723 /* Initially just set everything to the same number and the alpha to opaque.
5724 * Note that this currently assumes a simple palette where entry x has colour
5727 this->palette_index = this->red = this->green = this->blue =
5728 sample(row, colour_type, bit_depth, x, 0, swap16, littleendian);
5730 this->red_sBIT = this->green_sBIT = this->blue_sBIT = this->alpha_sBIT =
5733 /* Then override as appropriate: */
5734 if (colour_type == 3) /* palette */
5736 /* This permits the caller to default to the sample value. */
5739 const unsigned int i = this->palette_index;
5741 this->red = palette[i].red;
5742 this->green = palette[i].green;
5743 this->blue = palette[i].blue;
5744 this->alpha = palette[i].alpha;
5748 else /* not palette */
5752 if ((colour_type & 4) != 0 && format != 0 && format->alpha_first)
5754 this->alpha = this->red;
5755 /* This handles the gray case for 'AG' pixels */
5756 this->palette_index = this->red = this->green = this->blue =
5757 sample(row, colour_type, bit_depth, x, 1, swap16, littleendian);
5761 if (colour_type & 2)
5763 /* Green is second for both BGR and RGB: */
5764 this->green = sample(row, colour_type, bit_depth, x, ++i, swap16,
5767 if (format != 0 && format->swap_rgb) /* BGR */
5768 this->red = sample(row, colour_type, bit_depth, x, ++i, swap16,
5771 this->blue = sample(row, colour_type, bit_depth, x, ++i, swap16,
5775 else /* grayscale */ if (format != 0 && format->mono_inverted)
5776 this->red = this->green = this->blue = this->red ^ max;
5778 if ((colour_type & 4) != 0) /* alpha */
5780 if (format == 0 || !format->alpha_first)
5781 this->alpha = sample(row, colour_type, bit_depth, x, ++i, swap16,
5784 if (format != 0 && format->alpha_inverted)
5789 /* Calculate the scaled values, these are simply the values divided by
5790 * 'max' and the error is initialized to the double precision epsilon value
5791 * from the header file.
5793 image_pixel_setf(this,
5794 sig_bits ? (1U << format->red_sBIT)-1 : max,
5795 sig_bits ? (1U << format->green_sBIT)-1 : max,
5796 sig_bits ? (1U << format->blue_sBIT)-1 : max,
5797 sig_bits ? (1U << format->alpha_sBIT)-1 : max);
5799 /* Store the input information for use in the transforms - these will
5800 * modify the information.
5802 this->colour_type = colour_type;
5803 this->bit_depth = bit_depth;
5804 this->sample_depth = sample_depth;
5805 this->have_tRNS = 0;
5807 this->alpha_first = 0;
5808 this->alpha_inverted = 0;
5809 this->mono_inverted = 0;
5811 this->littleendian = 0;
5815 #if defined PNG_READ_EXPAND_SUPPORTED || defined PNG_READ_GRAY_TO_RGB_SUPPORTED\
5816 || defined PNG_READ_EXPAND_SUPPORTED || defined PNG_READ_EXPAND_16_SUPPORTED\
5817 || defined PNG_READ_BACKGROUND_SUPPORTED
5818 /* Convert a palette image to an rgb image. This necessarily converts the tRNS
5819 * chunk at the same time, because the tRNS will be in palette form. The way
5820 * palette validation works means that the original palette is never updated,
5821 * instead the image_pixel value from the row contains the RGB of the
5822 * corresponding palette entry and *this* is updated. Consequently this routine
5823 * only needs to change the colour type information.
5826 image_pixel_convert_PLTE(image_pixel *this)
5828 if (this->colour_type == PNG_COLOR_TYPE_PALETTE)
5830 if (this->have_tRNS)
5832 this->colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
5833 this->have_tRNS = 0;
5836 this->colour_type = PNG_COLOR_TYPE_RGB;
5838 /* The bit depth of the row changes at this point too (notice that this is
5839 * the row format, not the sample depth, which is separate.)
5841 this->bit_depth = 8;
5845 /* Add an alpha channel; this will import the tRNS information because tRNS is
5846 * not valid in an alpha image. The bit depth will invariably be set to at
5847 * least 8 prior to 1.7.0. Palette images will be converted to alpha (using
5848 * the above API). With png_set_background the alpha channel is never expanded
5849 * but this routine is used by pngvalid to simplify code; 'for_background'
5853 image_pixel_add_alpha(image_pixel *this, const standard_display *display,
5856 if (this->colour_type == PNG_COLOR_TYPE_PALETTE)
5857 image_pixel_convert_PLTE(this);
5859 if ((this->colour_type & PNG_COLOR_MASK_ALPHA) == 0)
5861 if (this->colour_type == PNG_COLOR_TYPE_GRAY)
5863 # if PNG_LIBPNG_VER < 10700
5864 if (!for_background && this->bit_depth < 8)
5865 this->bit_depth = this->sample_depth = 8;
5868 if (this->have_tRNS)
5870 /* After 1.7 the expansion of bit depth only happens if there is a
5871 * tRNS chunk to expand at this point.
5873 # if PNG_LIBPNG_VER >= 10700
5874 if (!for_background && this->bit_depth < 8)
5875 this->bit_depth = this->sample_depth = 8;
5878 this->have_tRNS = 0;
5880 /* Check the input, original, channel value here against the
5881 * original tRNS gray chunk valie.
5883 if (this->red == display->transparent.red)
5891 this->colour_type = PNG_COLOR_TYPE_GRAY_ALPHA;
5894 else if (this->colour_type == PNG_COLOR_TYPE_RGB)
5896 if (this->have_tRNS)
5898 this->have_tRNS = 0;
5900 /* Again, check the exact input values, not the current transformed
5903 if (this->red == display->transparent.red &&
5904 this->green == display->transparent.green &&
5905 this->blue == display->transparent.blue)
5913 this->colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
5916 /* The error in the alpha is zero and the sBIT value comes from the
5917 * original sBIT data (actually it will always be the original bit depth).
5920 this->alpha_sBIT = display->alpha_sBIT;
5923 #endif /* transforms that need image_pixel_add_alpha */
5925 struct transform_display;
5926 typedef struct image_transform
5928 /* The name of this transform: a string. */
5931 /* Each transform can be disabled from the command line: */
5934 /* The global list of transforms; read only. */
5935 struct image_transform *const list;
5937 /* The global count of the number of times this transform has been set on an
5940 unsigned int global_use;
5942 /* The local count of the number of times this transform has been set. */
5943 unsigned int local_use;
5945 /* The next transform in the list, each transform must call its own next
5946 * transform after it has processed the pixel successfully.
5948 const struct image_transform *next;
5950 /* A single transform for the image, expressed as a series of function
5951 * callbacks and some space for values.
5953 * First a callback to add any required modifications to the png_modifier;
5954 * this gets called just before the modifier is set up for read.
5956 void (*ini)(const struct image_transform *this,
5957 struct transform_display *that);
5959 /* And a callback to set the transform on the current png_read_struct:
5961 void (*set)(const struct image_transform *this,
5962 struct transform_display *that, png_structp pp, png_infop pi);
5964 /* Then a transform that takes an input pixel in one PNG format or another
5965 * and modifies it by a pngvalid implementation of the transform (thus
5966 * duplicating the libpng intent without, we hope, duplicating the bugs
5967 * in the libpng implementation!) The png_structp is solely to allow error
5968 * reporting via png_error and png_warning.
5970 void (*mod)(const struct image_transform *this, image_pixel *that,
5971 png_const_structp pp, const struct transform_display *display);
5973 /* Add this transform to the list and return true if the transform is
5974 * meaningful for this colour type and bit depth - if false then the
5975 * transform should have no effect on the image so there's not a lot of
5978 int (*add)(struct image_transform *this,
5979 const struct image_transform **that, png_byte colour_type,
5980 png_byte bit_depth);
5983 typedef struct transform_display
5985 standard_display this;
5989 const image_transform* transform_list;
5990 unsigned int max_gamma_8;
5992 /* Local variables */
5993 png_byte output_colour_type;
5994 png_byte output_bit_depth;
5997 /* Modifications (not necessarily used.) */
5998 gama_modification gama_mod;
5999 chrm_modification chrm_mod;
6000 srgb_modification srgb_mod;
6001 } transform_display;
6003 /* Set sRGB, cHRM and gAMA transforms as required by the current encoding. */
6005 transform_set_encoding(transform_display *this)
6007 /* Set up the png_modifier '_current' fields then use these to determine how
6008 * to add appropriate chunks.
6010 png_modifier *pm = this->pm;
6012 modifier_set_encoding(pm);
6014 if (modifier_color_encoding_is_set(pm))
6016 if (modifier_color_encoding_is_sRGB(pm))
6017 srgb_modification_init(&this->srgb_mod, pm, PNG_sRGB_INTENT_ABSOLUTE);
6021 /* Set gAMA and cHRM separately. */
6022 gama_modification_init(&this->gama_mod, pm, pm->current_gamma);
6024 if (pm->current_encoding != 0)
6025 chrm_modification_init(&this->chrm_mod, pm, pm->current_encoding);
6030 /* Three functions to end the list: */
6032 image_transform_ini_end(const image_transform *this,
6033 transform_display *that)
6040 image_transform_set_end(const image_transform *this,
6041 transform_display *that, png_structp pp, png_infop pi)
6049 /* At the end of the list recalculate the output image pixel value from the
6050 * double precision values set up by the preceding 'mod' calls:
6053 sample_scale(double sample_value, unsigned int scale)
6055 sample_value = floor(sample_value * scale + .5);
6057 /* Return NaN as 0: */
6058 if (!(sample_value > 0))
6060 else if (sample_value > scale)
6061 sample_value = scale;
6063 return (unsigned int)sample_value;
6067 image_transform_mod_end(const image_transform *this, image_pixel *that,
6068 png_const_structp pp, const transform_display *display)
6070 const unsigned int scale = (1U<<that->sample_depth)-1;
6071 const int sig_bits = that->sig_bits;
6077 /* At the end recalculate the digitized red green and blue values according
6078 * to the current sample_depth of the pixel.
6080 * The sample value is simply scaled to the maximum, checking for over
6081 * and underflow (which can both happen for some image transforms,
6082 * including simple size scaling, though libpng doesn't do that at present.
6084 that->red = sample_scale(that->redf, scale);
6086 /* This is a bit bogus; really the above calculation should use the red_sBIT
6087 * value, not sample_depth, but because libpng does png_set_shift by just
6088 * shifting the bits we get errors if we don't do it the same way.
6090 if (sig_bits && that->red_sBIT < that->sample_depth)
6091 that->red >>= that->sample_depth - that->red_sBIT;
6093 /* The error value is increased, at the end, according to the lowest sBIT
6094 * value seen. Common sense tells us that the intermediate integer
6095 * representations are no more accurate than +/- 0.5 in the integral values,
6096 * the sBIT allows the implementation to be worse than this. In addition the
6097 * PNG specification actually permits any error within the range (-1..+1),
6098 * but that is ignored here. Instead the final digitized value is compared,
6099 * below to the digitized value of the error limits - this has the net effect
6100 * of allowing (almost) +/-1 in the output value. It's difficult to see how
6101 * any algorithm that digitizes intermediate results can be more accurate.
6103 that->rede += 1./(2*((1U<<that->red_sBIT)-1));
6105 if (that->colour_type & PNG_COLOR_MASK_COLOR)
6107 that->green = sample_scale(that->greenf, scale);
6108 if (sig_bits && that->green_sBIT < that->sample_depth)
6109 that->green >>= that->sample_depth - that->green_sBIT;
6111 that->blue = sample_scale(that->bluef, scale);
6112 if (sig_bits && that->blue_sBIT < that->sample_depth)
6113 that->blue >>= that->sample_depth - that->blue_sBIT;
6115 that->greene += 1./(2*((1U<<that->green_sBIT)-1));
6116 that->bluee += 1./(2*((1U<<that->blue_sBIT)-1));
6120 that->blue = that->green = that->red;
6121 that->bluef = that->greenf = that->redf;
6122 that->bluee = that->greene = that->rede;
6125 if ((that->colour_type & PNG_COLOR_MASK_ALPHA) ||
6126 that->colour_type == PNG_COLOR_TYPE_PALETTE)
6128 that->alpha = sample_scale(that->alphaf, scale);
6129 that->alphae += 1./(2*((1U<<that->alpha_sBIT)-1));
6133 that->alpha = scale; /* opaque */
6134 that->alphaf = 1; /* Override this. */
6135 that->alphae = 0; /* It's exact ;-) */
6138 if (sig_bits && that->alpha_sBIT < that->sample_depth)
6139 that->alpha >>= that->sample_depth - that->alpha_sBIT;
6142 /* Static 'end' structure: */
6143 static image_transform image_transform_end =
6151 image_transform_ini_end,
6152 image_transform_set_end,
6153 image_transform_mod_end,
6154 0 /* never called, I want it to crash if it is! */
6157 /* Reader callbacks and implementations, where they differ from the standard
6161 transform_display_init(transform_display *dp, png_modifier *pm, png_uint_32 id,
6162 const image_transform *transform_list)
6164 memset(dp, 0, sizeof *dp);
6166 /* Standard fields */
6167 standard_display_init(&dp->this, &pm->this, id, do_read_interlace,
6168 pm->use_update_info);
6170 /* Parameter fields */
6172 dp->transform_list = transform_list;
6173 dp->max_gamma_8 = 16;
6175 /* Local variable fields */
6176 dp->output_colour_type = 255; /* invalid */
6177 dp->output_bit_depth = 255; /* invalid */
6178 dp->unpacked = 0; /* not unpacked */
6182 transform_info_imp(transform_display *dp, png_structp pp, png_infop pi)
6184 /* Reuse the standard stuff as appropriate. */
6185 standard_info_part1(&dp->this, pp, pi);
6187 /* Now set the list of transforms. */
6188 dp->transform_list->set(dp->transform_list, dp, pp, pi);
6190 /* Update the info structure for these transforms: */
6192 int i = dp->this.use_update_info;
6193 /* Always do one call, even if use_update_info is 0. */
6195 png_read_update_info(pp, pi);
6199 /* And get the output information into the standard_display */
6200 standard_info_part2(&dp->this, pp, pi, 1/*images*/);
6202 /* Plus the extra stuff we need for the transform tests: */
6203 dp->output_colour_type = png_get_color_type(pp, pi);
6204 dp->output_bit_depth = png_get_bit_depth(pp, pi);
6206 /* If png_set_filler is in action then fake the output color type to include
6207 * an alpha channel where appropriate.
6209 if (dp->output_bit_depth >= 8 &&
6210 (dp->output_colour_type == PNG_COLOR_TYPE_RGB ||
6211 dp->output_colour_type == PNG_COLOR_TYPE_GRAY) && dp->this.filler)
6212 dp->output_colour_type |= 4;
6214 /* Validate the combination of colour type and bit depth that we are getting
6215 * out of libpng; the semantics of something not in the PNG spec are, at
6218 switch (dp->output_colour_type)
6220 case PNG_COLOR_TYPE_PALETTE:
6221 if (dp->output_bit_depth > 8) goto error;
6223 case PNG_COLOR_TYPE_GRAY:
6224 if (dp->output_bit_depth == 1 || dp->output_bit_depth == 2 ||
6225 dp->output_bit_depth == 4)
6229 if (dp->output_bit_depth == 8 || dp->output_bit_depth == 16)
6237 pos = safecat(message, sizeof message, 0,
6238 "invalid final bit depth: colour type(");
6239 pos = safecatn(message, sizeof message, pos, dp->output_colour_type);
6240 pos = safecat(message, sizeof message, pos, ") with bit depth: ");
6241 pos = safecatn(message, sizeof message, pos, dp->output_bit_depth);
6243 png_error(pp, message);
6247 /* Use a test pixel to check that the output agrees with what we expect -
6248 * this avoids running the whole test if the output is unexpected. This also
6249 * checks for internal errors.
6252 image_pixel test_pixel;
6254 memset(&test_pixel, 0, sizeof test_pixel);
6255 test_pixel.colour_type = dp->this.colour_type; /* input */
6256 test_pixel.bit_depth = dp->this.bit_depth;
6257 if (test_pixel.colour_type == PNG_COLOR_TYPE_PALETTE)
6258 test_pixel.sample_depth = 8;
6260 test_pixel.sample_depth = test_pixel.bit_depth;
6261 /* Don't need sBIT here, but it must be set to non-zero to avoid
6262 * arithmetic overflows.
6264 test_pixel.have_tRNS = dp->this.is_transparent != 0;
6265 test_pixel.red_sBIT = test_pixel.green_sBIT = test_pixel.blue_sBIT =
6266 test_pixel.alpha_sBIT = test_pixel.sample_depth;
6268 dp->transform_list->mod(dp->transform_list, &test_pixel, pp, dp);
6270 if (test_pixel.colour_type != dp->output_colour_type)
6273 size_t pos = safecat(message, sizeof message, 0, "colour type ");
6275 pos = safecatn(message, sizeof message, pos, dp->output_colour_type);
6276 pos = safecat(message, sizeof message, pos, " expected ");
6277 pos = safecatn(message, sizeof message, pos, test_pixel.colour_type);
6279 png_error(pp, message);
6282 if (test_pixel.bit_depth != dp->output_bit_depth)
6285 size_t pos = safecat(message, sizeof message, 0, "bit depth ");
6287 pos = safecatn(message, sizeof message, pos, dp->output_bit_depth);
6288 pos = safecat(message, sizeof message, pos, " expected ");
6289 pos = safecatn(message, sizeof message, pos, test_pixel.bit_depth);
6291 png_error(pp, message);
6294 /* If both bit depth and colour type are correct check the sample depth.
6296 if (test_pixel.colour_type == PNG_COLOR_TYPE_PALETTE &&
6297 test_pixel.sample_depth != 8) /* oops - internal error! */
6298 png_error(pp, "pngvalid: internal: palette sample depth not 8");
6299 else if (dp->unpacked && test_pixel.bit_depth != 8)
6300 png_error(pp, "pngvalid: internal: bad unpacked pixel depth");
6301 else if (!dp->unpacked && test_pixel.colour_type != PNG_COLOR_TYPE_PALETTE
6302 && test_pixel.bit_depth != test_pixel.sample_depth)
6305 size_t pos = safecat(message, sizeof message, 0,
6306 "internal: sample depth ");
6308 /* Because unless something has set 'unpacked' or the image is palette
6309 * mapped we expect the transform to keep sample depth and bit depth
6312 pos = safecatn(message, sizeof message, pos, test_pixel.sample_depth);
6313 pos = safecat(message, sizeof message, pos, " expected ");
6314 pos = safecatn(message, sizeof message, pos, test_pixel.bit_depth);
6316 png_error(pp, message);
6318 else if (test_pixel.bit_depth != dp->output_bit_depth)
6320 /* This could be a libpng error too; libpng has not produced what we
6321 * expect for the output bit depth.
6324 size_t pos = safecat(message, sizeof message, 0,
6325 "internal: bit depth ");
6327 pos = safecatn(message, sizeof message, pos, dp->output_bit_depth);
6328 pos = safecat(message, sizeof message, pos, " expected ");
6329 pos = safecatn(message, sizeof message, pos, test_pixel.bit_depth);
6331 png_error(pp, message);
6336 static void PNGCBAPI
6337 transform_info(png_structp pp, png_infop pi)
6339 transform_info_imp(voidcast(transform_display*, png_get_progressive_ptr(pp)),
6344 transform_range_check(png_const_structp pp, unsigned int r, unsigned int g,
6345 unsigned int b, unsigned int a, unsigned int in_digitized, double in,
6346 unsigned int out, png_byte sample_depth, double err, double limit,
6347 const char *name, double digitization_error)
6349 /* Compare the scaled, digitzed, values of our local calculation (in+-err)
6350 * with the digitized values libpng produced; 'sample_depth' is the actual
6351 * digitization depth of the libpng output colors (the bit depth except for
6352 * palette images where it is always 8.) The check on 'err' is to detect
6353 * internal errors in pngvalid itself.
6355 unsigned int max = (1U<<sample_depth)-1;
6356 double in_min = ceil((in-err)*max - digitization_error);
6357 double in_max = floor((in+err)*max + digitization_error);
6358 if (debugonly(err > limit ||) !(out >= in_min && out <= in_max))
6363 pos = safecat(message, sizeof message, 0, name);
6364 pos = safecat(message, sizeof message, pos, " output value error: rgba(");
6365 pos = safecatn(message, sizeof message, pos, r);
6366 pos = safecat(message, sizeof message, pos, ",");
6367 pos = safecatn(message, sizeof message, pos, g);
6368 pos = safecat(message, sizeof message, pos, ",");
6369 pos = safecatn(message, sizeof message, pos, b);
6370 pos = safecat(message, sizeof message, pos, ",");
6371 pos = safecatn(message, sizeof message, pos, a);
6372 pos = safecat(message, sizeof message, pos, "): ");
6373 pos = safecatn(message, sizeof message, pos, out);
6374 pos = safecat(message, sizeof message, pos, " expected: ");
6375 pos = safecatn(message, sizeof message, pos, in_digitized);
6376 pos = safecat(message, sizeof message, pos, " (");
6377 pos = safecatd(message, sizeof message, pos, (in-err)*max, 3);
6378 pos = safecat(message, sizeof message, pos, "..");
6379 pos = safecatd(message, sizeof message, pos, (in+err)*max, 3);
6380 pos = safecat(message, sizeof message, pos, ")");
6382 png_error(pp, message);
6389 transform_image_validate(transform_display *dp, png_const_structp pp,
6392 /* Constants for the loop below: */
6393 const png_store* const ps = dp->this.ps;
6394 const png_byte in_ct = dp->this.colour_type;
6395 const png_byte in_bd = dp->this.bit_depth;
6396 const png_uint_32 w = dp->this.w;
6397 const png_uint_32 h = dp->this.h;
6398 const png_byte out_ct = dp->output_colour_type;
6399 const png_byte out_bd = dp->output_bit_depth;
6400 const png_byte sample_depth = (png_byte)(out_ct ==
6401 PNG_COLOR_TYPE_PALETTE ? 8 : out_bd);
6402 const png_byte red_sBIT = dp->this.red_sBIT;
6403 const png_byte green_sBIT = dp->this.green_sBIT;
6404 const png_byte blue_sBIT = dp->this.blue_sBIT;
6405 const png_byte alpha_sBIT = dp->this.alpha_sBIT;
6406 const int have_tRNS = dp->this.is_transparent;
6407 double digitization_error;
6409 store_palette out_palette;
6414 /* Check for row overwrite errors */
6415 store_image_check(dp->this.ps, pp, 0);
6417 /* Read the palette corresponding to the output if the output colour type
6418 * indicates a palette, othewise set out_palette to garbage.
6420 if (out_ct == PNG_COLOR_TYPE_PALETTE)
6422 /* Validate that the palette count itself has not changed - this is not
6425 int npalette = (-1);
6427 (void)read_palette(out_palette, &npalette, pp, pi);
6428 if (npalette != dp->this.npalette)
6429 png_error(pp, "unexpected change in palette size");
6431 digitization_error = .5;
6435 png_byte in_sample_depth;
6437 memset(out_palette, 0x5e, sizeof out_palette);
6439 /* use-input-precision means assume that if the input has 8 bit (or less)
6440 * samples and the output has 16 bit samples the calculations will be done
6441 * with 8 bit precision, not 16.
6443 if (in_ct == PNG_COLOR_TYPE_PALETTE || in_bd < 16)
6444 in_sample_depth = 8;
6446 in_sample_depth = in_bd;
6448 if (sample_depth != 16 || in_sample_depth > 8 ||
6449 !dp->pm->calculations_use_input_precision)
6450 digitization_error = .5;
6452 /* Else calculations are at 8 bit precision, and the output actually
6453 * consists of scaled 8-bit values, so scale .5 in 8 bits to the 16 bits:
6456 digitization_error = .5 * 257;
6461 png_const_bytep const pRow = store_image_row(ps, pp, 0, y);
6464 /* The original, standard, row pre-transforms. */
6465 png_byte std[STANDARD_ROWMAX];
6467 transform_row(pp, std, in_ct, in_bd, y);
6469 /* Go through each original pixel transforming it and comparing with what
6470 * libpng did to the same pixel.
6474 image_pixel in_pixel, out_pixel;
6475 unsigned int r, g, b, a;
6477 /* Find out what we think the pixel should be: */
6478 image_pixel_init(&in_pixel, std, in_ct, in_bd, x, dp->this.palette,
6481 in_pixel.red_sBIT = red_sBIT;
6482 in_pixel.green_sBIT = green_sBIT;
6483 in_pixel.blue_sBIT = blue_sBIT;
6484 in_pixel.alpha_sBIT = alpha_sBIT;
6485 in_pixel.have_tRNS = have_tRNS != 0;
6487 /* For error detection, below. */
6493 /* This applies the transforms to the input data, including output
6494 * format operations which must be used when reading the output
6495 * pixel that libpng produces.
6497 dp->transform_list->mod(dp->transform_list, &in_pixel, pp, dp);
6499 /* Read the output pixel and compare it to what we got, we don't
6500 * use the error field here, so no need to update sBIT. in_pixel
6501 * says whether we expect libpng to change the output format.
6503 image_pixel_init(&out_pixel, pRow, out_ct, out_bd, x, out_palette,
6506 /* We don't expect changes to the index here even if the bit depth is
6509 if (in_ct == PNG_COLOR_TYPE_PALETTE &&
6510 out_ct == PNG_COLOR_TYPE_PALETTE)
6512 if (in_pixel.palette_index != out_pixel.palette_index)
6513 png_error(pp, "unexpected transformed palette index");
6516 /* Check the colours for palette images too - in fact the palette could
6517 * be separately verified itself in most cases.
6519 if (in_pixel.red != out_pixel.red)
6520 transform_range_check(pp, r, g, b, a, in_pixel.red, in_pixel.redf,
6521 out_pixel.red, sample_depth, in_pixel.rede,
6522 dp->pm->limit + 1./(2*((1U<<in_pixel.red_sBIT)-1)), "red/gray",
6523 digitization_error);
6525 if ((out_ct & PNG_COLOR_MASK_COLOR) != 0 &&
6526 in_pixel.green != out_pixel.green)
6527 transform_range_check(pp, r, g, b, a, in_pixel.green,
6528 in_pixel.greenf, out_pixel.green, sample_depth, in_pixel.greene,
6529 dp->pm->limit + 1./(2*((1U<<in_pixel.green_sBIT)-1)), "green",
6530 digitization_error);
6532 if ((out_ct & PNG_COLOR_MASK_COLOR) != 0 &&
6533 in_pixel.blue != out_pixel.blue)
6534 transform_range_check(pp, r, g, b, a, in_pixel.blue, in_pixel.bluef,
6535 out_pixel.blue, sample_depth, in_pixel.bluee,
6536 dp->pm->limit + 1./(2*((1U<<in_pixel.blue_sBIT)-1)), "blue",
6537 digitization_error);
6539 if ((out_ct & PNG_COLOR_MASK_ALPHA) != 0 &&
6540 in_pixel.alpha != out_pixel.alpha)
6541 transform_range_check(pp, r, g, b, a, in_pixel.alpha,
6542 in_pixel.alphaf, out_pixel.alpha, sample_depth, in_pixel.alphae,
6543 dp->pm->limit + 1./(2*((1U<<in_pixel.alpha_sBIT)-1)), "alpha",
6544 digitization_error);
6545 } /* pixel (x) loop */
6546 } /* row (y) loop */
6548 /* Record that something was actually checked to avoid a false positive. */
6549 dp->this.ps->validated = 1;
6552 static void PNGCBAPI
6553 transform_end(png_structp ppIn, png_infop pi)
6555 png_const_structp pp = ppIn;
6556 transform_display *dp = voidcast(transform_display*,
6557 png_get_progressive_ptr(pp));
6559 if (!dp->this.speed)
6560 transform_image_validate(dp, pp, pi);
6562 dp->this.ps->validated = 1;
6565 /* A single test run. */
6567 transform_test(png_modifier *pmIn, const png_uint_32 idIn,
6568 const image_transform* transform_listIn, const char * const name)
6570 transform_display d;
6571 context(&pmIn->this, fault);
6573 transform_display_init(&d, pmIn, idIn, transform_listIn);
6580 char full_name[256];
6582 /* Make sure the encoding fields are correct and enter the required
6585 transform_set_encoding(&d);
6587 /* Add any modifications required by the transform list. */
6588 d.transform_list->ini(d.transform_list, &d);
6590 /* Add the color space information, if any, to the name. */
6591 pos = safecat(full_name, sizeof full_name, pos, name);
6592 pos = safecat_current_encoding(full_name, sizeof full_name, pos, d.pm);
6594 /* Get a png_struct for reading the image. */
6595 pp = set_modifier_for_read(d.pm, &pi, d.this.id, full_name);
6596 standard_palette_init(&d.this);
6599 /* Logging (debugging only) */
6603 (void)store_message(&d.pm->this, pp, buffer, sizeof buffer, 0,
6606 fprintf(stderr, "%s\n", buffer);
6610 /* Introduce the correct read function. */
6611 if (d.pm->this.progressive)
6613 /* Share the row function with the standard implementation. */
6614 png_set_progressive_read_fn(pp, &d, transform_info, progressive_row,
6617 /* Now feed data into the reader until we reach the end: */
6618 modifier_progressive_read(d.pm, pp, pi);
6622 /* modifier_read expects a png_modifier* */
6623 png_set_read_fn(pp, d.pm, modifier_read);
6625 /* Check the header values: */
6626 png_read_info(pp, pi);
6628 /* Process the 'info' requirements. Only one image is generated */
6629 transform_info_imp(&d, pp, pi);
6631 sequential_row(&d.this, pp, pi, -1, 0);
6634 transform_image_validate(&d, pp, pi);
6636 d.this.ps->validated = 1;
6639 modifier_reset(d.pm);
6644 modifier_reset(voidcast(png_modifier*,(void*)fault));
6648 /* The transforms: */
6649 #define ITSTRUCT(name) image_transform_##name
6650 #define ITDATA(name) image_transform_data_##name
6651 #define image_transform_ini image_transform_default_ini
6653 static image_transform ITSTRUCT(name) =\
6661 image_transform_ini,\
6662 image_transform_png_set_##name##_set,\
6663 image_transform_png_set_##name##_mod,\
6664 image_transform_png_set_##name##_add\
6666 #define PT ITSTRUCT(end) /* stores the previous transform */
6669 extern void image_transform_default_ini(const image_transform *this,
6670 transform_display *that); /* silence GCC warnings */
6672 void /* private, but almost always needed */
6673 image_transform_default_ini(const image_transform *this,
6674 transform_display *that)
6676 this->next->ini(this->next, that);
6679 #ifdef PNG_READ_BACKGROUND_SUPPORTED
6681 image_transform_default_add(image_transform *this,
6682 const image_transform **that, png_byte colour_type, png_byte bit_depth)
6694 #ifdef PNG_READ_EXPAND_SUPPORTED
6695 /* png_set_palette_to_rgb */
6697 image_transform_png_set_palette_to_rgb_set(const image_transform *this,
6698 transform_display *that, png_structp pp, png_infop pi)
6700 png_set_palette_to_rgb(pp);
6701 this->next->set(this->next, that, pp, pi);
6705 image_transform_png_set_palette_to_rgb_mod(const image_transform *this,
6706 image_pixel *that, png_const_structp pp,
6707 const transform_display *display)
6709 if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
6710 image_pixel_convert_PLTE(that);
6712 this->next->mod(this->next, that, pp, display);
6716 image_transform_png_set_palette_to_rgb_add(image_transform *this,
6717 const image_transform **that, png_byte colour_type, png_byte bit_depth)
6724 return colour_type == PNG_COLOR_TYPE_PALETTE;
6729 #define PT ITSTRUCT(palette_to_rgb)
6730 #endif /* PNG_READ_EXPAND_SUPPORTED */
6732 #ifdef PNG_READ_EXPAND_SUPPORTED
6733 /* png_set_tRNS_to_alpha */
6735 image_transform_png_set_tRNS_to_alpha_set(const image_transform *this,
6736 transform_display *that, png_structp pp, png_infop pi)
6738 png_set_tRNS_to_alpha(pp);
6740 /* If there was a tRNS chunk that would get expanded and add an alpha
6741 * channel is_transparent must be updated:
6743 if (that->this.has_tRNS)
6744 that->this.is_transparent = 1;
6746 this->next->set(this->next, that, pp, pi);
6750 image_transform_png_set_tRNS_to_alpha_mod(const image_transform *this,
6751 image_pixel *that, png_const_structp pp,
6752 const transform_display *display)
6754 #if PNG_LIBPNG_VER < 10700
6755 /* LIBPNG BUG: this always forces palette images to RGB. */
6756 if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
6757 image_pixel_convert_PLTE(that);
6760 /* This effectively does an 'expand' only if there is some transparency to
6761 * convert to an alpha channel.
6763 if (that->have_tRNS)
6764 # if PNG_LIBPNG_VER >= 10700
6765 if (that->colour_type != PNG_COLOR_TYPE_PALETTE &&
6766 (that->colour_type & PNG_COLOR_MASK_ALPHA) == 0)
6768 image_pixel_add_alpha(that, &display->this, 0/*!for background*/);
6770 #if PNG_LIBPNG_VER < 10700
6771 /* LIBPNG BUG: otherwise libpng still expands to 8 bits! */
6774 if (that->bit_depth < 8)
6776 if (that->sample_depth < 8)
6777 that->sample_depth = 8;
6781 this->next->mod(this->next, that, pp, display);
6785 image_transform_png_set_tRNS_to_alpha_add(image_transform *this,
6786 const image_transform **that, png_byte colour_type, png_byte bit_depth)
6793 /* We don't know yet whether there will be a tRNS chunk, but we know that
6794 * this transformation should do nothing if there already is an alpha
6795 * channel. In addition, after the bug fix in 1.7.0, there is no longer
6796 * any action on a palette image.
6799 # if PNG_LIBPNG_VER >= 10700
6800 colour_type != PNG_COLOR_TYPE_PALETTE &&
6802 (colour_type & PNG_COLOR_MASK_ALPHA) == 0;
6807 #define PT ITSTRUCT(tRNS_to_alpha)
6808 #endif /* PNG_READ_EXPAND_SUPPORTED */
6810 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
6811 /* png_set_gray_to_rgb */
6813 image_transform_png_set_gray_to_rgb_set(const image_transform *this,
6814 transform_display *that, png_structp pp, png_infop pi)
6816 png_set_gray_to_rgb(pp);
6817 /* NOTE: this doesn't result in tRNS expansion. */
6818 this->next->set(this->next, that, pp, pi);
6822 image_transform_png_set_gray_to_rgb_mod(const image_transform *this,
6823 image_pixel *that, png_const_structp pp,
6824 const transform_display *display)
6826 /* NOTE: we can actually pend the tRNS processing at this point because we
6827 * can correctly recognize the original pixel value even though we have
6828 * mapped the one gray channel to the three RGB ones, but in fact libpng
6829 * doesn't do this, so we don't either.
6831 if ((that->colour_type & PNG_COLOR_MASK_COLOR) == 0 && that->have_tRNS)
6832 image_pixel_add_alpha(that, &display->this, 0/*!for background*/);
6834 /* Simply expand the bit depth and alter the colour type as required. */
6835 if (that->colour_type == PNG_COLOR_TYPE_GRAY)
6837 /* RGB images have a bit depth at least equal to '8' */
6838 if (that->bit_depth < 8)
6839 that->sample_depth = that->bit_depth = 8;
6841 /* And just changing the colour type works here because the green and blue
6842 * channels are being maintained in lock-step with the red/gray:
6844 that->colour_type = PNG_COLOR_TYPE_RGB;
6847 else if (that->colour_type == PNG_COLOR_TYPE_GRAY_ALPHA)
6848 that->colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
6850 this->next->mod(this->next, that, pp, display);
6854 image_transform_png_set_gray_to_rgb_add(image_transform *this,
6855 const image_transform **that, png_byte colour_type, png_byte bit_depth)
6862 return (colour_type & PNG_COLOR_MASK_COLOR) == 0;
6867 #define PT ITSTRUCT(gray_to_rgb)
6868 #endif /* PNG_READ_GRAY_TO_RGB_SUPPORTED */
6870 #ifdef PNG_READ_EXPAND_SUPPORTED
6871 /* png_set_expand */
6873 image_transform_png_set_expand_set(const image_transform *this,
6874 transform_display *that, png_structp pp, png_infop pi)
6878 if (that->this.has_tRNS)
6879 that->this.is_transparent = 1;
6881 this->next->set(this->next, that, pp, pi);
6885 image_transform_png_set_expand_mod(const image_transform *this,
6886 image_pixel *that, png_const_structp pp,
6887 const transform_display *display)
6889 /* The general expand case depends on what the colour type is: */
6890 if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
6891 image_pixel_convert_PLTE(that);
6892 else if (that->bit_depth < 8) /* grayscale */
6893 that->sample_depth = that->bit_depth = 8;
6895 if (that->have_tRNS)
6896 image_pixel_add_alpha(that, &display->this, 0/*!for background*/);
6898 this->next->mod(this->next, that, pp, display);
6902 image_transform_png_set_expand_add(image_transform *this,
6903 const image_transform **that, png_byte colour_type, png_byte bit_depth)
6910 /* 'expand' should do nothing for RGBA or GA input - no tRNS and the bit
6911 * depth is at least 8 already.
6913 return (colour_type & PNG_COLOR_MASK_ALPHA) == 0;
6918 #define PT ITSTRUCT(expand)
6919 #endif /* PNG_READ_EXPAND_SUPPORTED */
6921 #ifdef PNG_READ_EXPAND_SUPPORTED
6922 /* png_set_expand_gray_1_2_4_to_8
6923 * Pre 1.7.0 LIBPNG BUG: this just does an 'expand'
6926 image_transform_png_set_expand_gray_1_2_4_to_8_set(
6927 const image_transform *this, transform_display *that, png_structp pp,
6930 png_set_expand_gray_1_2_4_to_8(pp);
6931 /* NOTE: don't expect this to expand tRNS */
6932 this->next->set(this->next, that, pp, pi);
6936 image_transform_png_set_expand_gray_1_2_4_to_8_mod(
6937 const image_transform *this, image_pixel *that, png_const_structp pp,
6938 const transform_display *display)
6940 #if PNG_LIBPNG_VER < 10700
6941 image_transform_png_set_expand_mod(this, that, pp, display);
6943 /* Only expand grayscale of bit depth less than 8: */
6944 if (that->colour_type == PNG_COLOR_TYPE_GRAY &&
6945 that->bit_depth < 8)
6946 that->sample_depth = that->bit_depth = 8;
6948 this->next->mod(this->next, that, pp, display);
6949 #endif /* 1.7 or later */
6953 image_transform_png_set_expand_gray_1_2_4_to_8_add(image_transform *this,
6954 const image_transform **that, png_byte colour_type, png_byte bit_depth)
6956 #if PNG_LIBPNG_VER < 10700
6957 return image_transform_png_set_expand_add(this, that, colour_type,
6965 /* This should do nothing unless the color type is gray and the bit depth is
6968 return colour_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8;
6969 #endif /* 1.7 or later */
6972 IT(expand_gray_1_2_4_to_8);
6974 #define PT ITSTRUCT(expand_gray_1_2_4_to_8)
6975 #endif /* PNG_READ_EXPAND_SUPPORTED */
6977 #ifdef PNG_READ_EXPAND_16_SUPPORTED
6978 /* png_set_expand_16 */
6980 image_transform_png_set_expand_16_set(const image_transform *this,
6981 transform_display *that, png_structp pp, png_infop pi)
6983 png_set_expand_16(pp);
6985 /* NOTE: prior to 1.7 libpng does SET_EXPAND as well, so tRNS is expanded. */
6986 # if PNG_LIBPNG_VER < 10700
6987 if (that->this.has_tRNS)
6988 that->this.is_transparent = 1;
6991 this->next->set(this->next, that, pp, pi);
6995 image_transform_png_set_expand_16_mod(const image_transform *this,
6996 image_pixel *that, png_const_structp pp,
6997 const transform_display *display)
6999 /* Expect expand_16 to expand everything to 16 bits as a result of also
7000 * causing 'expand' to happen.
7002 if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
7003 image_pixel_convert_PLTE(that);
7005 if (that->have_tRNS)
7006 image_pixel_add_alpha(that, &display->this, 0/*!for background*/);
7008 if (that->bit_depth < 16)
7009 that->sample_depth = that->bit_depth = 16;
7011 this->next->mod(this->next, that, pp, display);
7015 image_transform_png_set_expand_16_add(image_transform *this,
7016 const image_transform **that, png_byte colour_type, png_byte bit_depth)
7023 /* expand_16 does something unless the bit depth is already 16. */
7024 return bit_depth < 16;
7029 #define PT ITSTRUCT(expand_16)
7030 #endif /* PNG_READ_EXPAND_16_SUPPORTED */
7032 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED /* API added in 1.5.4 */
7033 /* png_set_scale_16 */
7035 image_transform_png_set_scale_16_set(const image_transform *this,
7036 transform_display *that, png_structp pp, png_infop pi)
7038 png_set_scale_16(pp);
7039 # if PNG_LIBPNG_VER < 10700
7040 /* libpng will limit the gamma table size: */
7041 that->max_gamma_8 = PNG_MAX_GAMMA_8;
7043 this->next->set(this->next, that, pp, pi);
7047 image_transform_png_set_scale_16_mod(const image_transform *this,
7048 image_pixel *that, png_const_structp pp,
7049 const transform_display *display)
7051 if (that->bit_depth == 16)
7053 that->sample_depth = that->bit_depth = 8;
7054 if (that->red_sBIT > 8) that->red_sBIT = 8;
7055 if (that->green_sBIT > 8) that->green_sBIT = 8;
7056 if (that->blue_sBIT > 8) that->blue_sBIT = 8;
7057 if (that->alpha_sBIT > 8) that->alpha_sBIT = 8;
7060 this->next->mod(this->next, that, pp, display);
7064 image_transform_png_set_scale_16_add(image_transform *this,
7065 const image_transform **that, png_byte colour_type, png_byte bit_depth)
7072 return bit_depth > 8;
7077 #define PT ITSTRUCT(scale_16)
7078 #endif /* PNG_READ_SCALE_16_TO_8_SUPPORTED (1.5.4 on) */
7080 #ifdef PNG_READ_16_TO_8_SUPPORTED /* the default before 1.5.4 */
7081 /* png_set_strip_16 */
7083 image_transform_png_set_strip_16_set(const image_transform *this,
7084 transform_display *that, png_structp pp, png_infop pi)
7086 png_set_strip_16(pp);
7087 # if PNG_LIBPNG_VER < 10700
7088 /* libpng will limit the gamma table size: */
7089 that->max_gamma_8 = PNG_MAX_GAMMA_8;
7091 this->next->set(this->next, that, pp, pi);
7095 image_transform_png_set_strip_16_mod(const image_transform *this,
7096 image_pixel *that, png_const_structp pp,
7097 const transform_display *display)
7099 if (that->bit_depth == 16)
7101 that->sample_depth = that->bit_depth = 8;
7102 if (that->red_sBIT > 8) that->red_sBIT = 8;
7103 if (that->green_sBIT > 8) that->green_sBIT = 8;
7104 if (that->blue_sBIT > 8) that->blue_sBIT = 8;
7105 if (that->alpha_sBIT > 8) that->alpha_sBIT = 8;
7107 /* Prior to 1.5.4 png_set_strip_16 would use an 'accurate' method if this
7108 * configuration option is set. From 1.5.4 the flag is never set and the
7109 * 'scale' API (above) must be used.
7111 # ifdef PNG_READ_ACCURATE_SCALE_SUPPORTED
7112 # if PNG_LIBPNG_VER >= 10504
7113 # error PNG_READ_ACCURATE_SCALE should not be set
7116 /* The strip 16 algorithm drops the low 8 bits rather than calculating
7117 * 1/257, so we need to adjust the permitted errors appropriately:
7118 * Notice that this is only relevant prior to the addition of the
7119 * png_set_scale_16 API in 1.5.4 (but 1.5.4+ always defines the above!)
7122 const double d = (255-128.5)/65535;
7131 this->next->mod(this->next, that, pp, display);
7135 image_transform_png_set_strip_16_add(image_transform *this,
7136 const image_transform **that, png_byte colour_type, png_byte bit_depth)
7143 return bit_depth > 8;
7148 #define PT ITSTRUCT(strip_16)
7149 #endif /* PNG_READ_16_TO_8_SUPPORTED */
7151 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
7152 /* png_set_strip_alpha */
7154 image_transform_png_set_strip_alpha_set(const image_transform *this,
7155 transform_display *that, png_structp pp, png_infop pi)
7157 png_set_strip_alpha(pp);
7158 this->next->set(this->next, that, pp, pi);
7162 image_transform_png_set_strip_alpha_mod(const image_transform *this,
7163 image_pixel *that, png_const_structp pp,
7164 const transform_display *display)
7166 if (that->colour_type == PNG_COLOR_TYPE_GRAY_ALPHA)
7167 that->colour_type = PNG_COLOR_TYPE_GRAY;
7168 else if (that->colour_type == PNG_COLOR_TYPE_RGB_ALPHA)
7169 that->colour_type = PNG_COLOR_TYPE_RGB;
7171 that->have_tRNS = 0;
7174 this->next->mod(this->next, that, pp, display);
7178 image_transform_png_set_strip_alpha_add(image_transform *this,
7179 const image_transform **that, png_byte colour_type, png_byte bit_depth)
7186 return (colour_type & PNG_COLOR_MASK_ALPHA) != 0;
7191 #define PT ITSTRUCT(strip_alpha)
7192 #endif /* PNG_READ_STRIP_ALPHA_SUPPORTED */
7194 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
7195 /* png_set_rgb_to_gray(png_structp, int err_action, double red, double green)
7196 * png_set_rgb_to_gray_fixed(png_structp, int err_action, png_fixed_point red,
7197 * png_fixed_point green)
7198 * png_get_rgb_to_gray_status
7200 * The 'default' test here uses values known to be used inside libpng prior to
7207 * These values are being retained for compatibility, along with the somewhat
7208 * broken truncation calculation in the fast-and-inaccurate code path. Older
7209 * versions of libpng will fail the accuracy tests below because they use the
7210 * truncation algorithm everywhere.
7212 #define data ITDATA(rgb_to_gray)
7215 double gamma; /* File gamma to use in processing */
7217 /* The following are the parameters for png_set_rgb_to_gray: */
7218 # ifdef PNG_FLOATING_POINT_SUPPORTED
7220 double green_to_set;
7222 png_fixed_point red_to_set;
7223 png_fixed_point green_to_set;
7226 /* The actual coefficients: */
7227 double red_coefficient;
7228 double green_coefficient;
7229 double blue_coefficient;
7231 /* Set if the coeefficients have been overridden. */
7232 int coefficients_overridden;
7235 #undef image_transform_ini
7236 #define image_transform_ini image_transform_png_set_rgb_to_gray_ini
7238 image_transform_png_set_rgb_to_gray_ini(const image_transform *this,
7239 transform_display *that)
7241 png_modifier *pm = that->pm;
7242 const color_encoding *e = pm->current_encoding;
7246 /* Since we check the encoding this flag must be set: */
7247 pm->test_uses_encoding = 1;
7249 /* If 'e' is not NULL chromaticity information is present and either a cHRM
7250 * or an sRGB chunk will be inserted.
7254 /* Coefficients come from the encoding, but may need to be normalized to a
7255 * white point Y of 1.0
7257 const double whiteY = e->red.Y + e->green.Y + e->blue.Y;
7259 data.red_coefficient = e->red.Y;
7260 data.green_coefficient = e->green.Y;
7261 data.blue_coefficient = e->blue.Y;
7265 data.red_coefficient /= whiteY;
7266 data.green_coefficient /= whiteY;
7267 data.blue_coefficient /= whiteY;
7273 /* The default (built in) coeffcients, as above: */
7274 # if PNG_LIBPNG_VER < 10700
7275 data.red_coefficient = 6968 / 32768.;
7276 data.green_coefficient = 23434 / 32768.;
7277 data.blue_coefficient = 2366 / 32768.;
7279 data.red_coefficient = .2126;
7280 data.green_coefficient = .7152;
7281 data.blue_coefficient = .0722;
7285 data.gamma = pm->current_gamma;
7287 /* If not set then the calculations assume linear encoding (implicitly): */
7288 if (data.gamma == 0)
7291 /* The arguments to png_set_rgb_to_gray can override the coefficients implied
7292 * by the color space encoding. If doing exhaustive checks do the override
7293 * in each case, otherwise do it randomly.
7295 if (pm->test_exhaustive)
7297 /* First time in coefficients_overridden is 0, the following sets it to 1,
7298 * so repeat if it is set. If a test fails this may mean we subsequently
7299 * skip a non-override test, ignore that.
7301 data.coefficients_overridden = !data.coefficients_overridden;
7302 pm->repeat = data.coefficients_overridden != 0;
7306 data.coefficients_overridden = random_choice();
7308 if (data.coefficients_overridden)
7310 /* These values override the color encoding defaults, simply use random
7317 data.green_coefficient = total = (ru & 0xffff) / 65535.;
7319 data.red_coefficient = (1 - total) * (ru & 0xffff) / 65535.;
7320 total += data.red_coefficient;
7321 data.blue_coefficient = 1 - total;
7323 # ifdef PNG_FLOATING_POINT_SUPPORTED
7324 data.red_to_set = data.red_coefficient;
7325 data.green_to_set = data.green_coefficient;
7327 data.red_to_set = fix(data.red_coefficient);
7328 data.green_to_set = fix(data.green_coefficient);
7331 /* The following just changes the error messages: */
7332 pm->encoding_ignored = 1;
7337 data.red_to_set = -1;
7338 data.green_to_set = -1;
7341 /* Adjust the error limit in the png_modifier because of the larger errors
7342 * produced in the digitization during the gamma handling.
7344 if (data.gamma != 1) /* Use gamma tables */
7346 if (that->this.bit_depth == 16 || pm->assume_16_bit_calculations)
7348 /* The computations have the form:
7350 * r * rc + g * gc + b * bc
7352 * Each component of which is +/-1/65535 from the gamma_to_1 table
7353 * lookup, resulting in a base error of +/-6. The gamma_from_1
7354 * conversion adds another +/-2 in the 16-bit case and
7355 * +/-(1<<(15-PNG_MAX_GAMMA_8)) in the 8-bit case.
7357 # if PNG_LIBPNG_VER < 10700
7358 if (that->this.bit_depth < 16)
7359 that->max_gamma_8 = PNG_MAX_GAMMA_8;
7361 that->pm->limit += pow(
7362 (that->this.bit_depth == 16 || that->max_gamma_8 > 14 ?
7364 6. + (1<<(15-that->max_gamma_8))
7365 )/65535, data.gamma);
7370 /* Rounding to 8 bits in the linear space causes massive errors which
7371 * will trigger the error check in transform_range_check. Fix that
7372 * here by taking the gamma encoding into account.
7374 * When DIGITIZE is set because a pre-1.7 version of libpng is being
7375 * tested allow a bigger slack.
7377 * NOTE: this number only affects the internal limit check in pngvalid,
7378 * it has no effect on the limits applied to the libpng values.
7380 that->pm->limit += pow(
7392 /* With no gamma correction a large error comes from the truncation of the
7393 * calculation in the 8 bit case, allow for that here.
7395 if (that->this.bit_depth != 16 && !pm->assume_16_bit_calculations)
7396 that->pm->limit += 4E-3;
7401 image_transform_png_set_rgb_to_gray_set(const image_transform *this,
7402 transform_display *that, png_structp pp, png_infop pi)
7404 const int error_action = 1; /* no error, no defines in png.h */
7406 # ifdef PNG_FLOATING_POINT_SUPPORTED
7407 png_set_rgb_to_gray(pp, error_action, data.red_to_set, data.green_to_set);
7409 png_set_rgb_to_gray_fixed(pp, error_action, data.red_to_set,
7413 # ifdef PNG_READ_cHRM_SUPPORTED
7414 if (that->pm->current_encoding != 0)
7416 /* We have an encoding so a cHRM chunk may have been set; if so then
7417 * check that the libpng APIs give the correct (X,Y,Z) values within
7418 * some margin of error for the round trip through the chromaticity
7421 # ifdef PNG_FLOATING_POINT_SUPPORTED
7422 # define API_function png_get_cHRM_XYZ
7423 # define API_form "FP"
7424 # define API_type double
7425 # define API_cvt(x) (x)
7427 # define API_function png_get_cHRM_XYZ_fixed
7428 # define API_form "fixed"
7429 # define API_type png_fixed_point
7430 # define API_cvt(x) ((double)(x)/PNG_FP_1)
7433 API_type rX, gX, bX;
7434 API_type rY, gY, bY;
7435 API_type rZ, gZ, bZ;
7437 if ((API_function(pp, pi, &rX, &rY, &rZ, &gX, &gY, &gZ, &bX, &bY, &bZ)
7438 & PNG_INFO_cHRM) != 0)
7442 color_encoding e, o;
7444 /* Expect libpng to return a normalized result, but the original
7445 * color space encoding may not be normalized.
7447 modifier_current_encoding(that->pm, &o);
7448 normalize_color_encoding(&o);
7450 /* Sanity check the pngvalid code - the coefficients should match
7451 * the normalized Y values of the encoding unless they were
7454 if (data.red_to_set == -1 && data.green_to_set == -1 &&
7455 (fabs(o.red.Y - data.red_coefficient) > DBL_EPSILON ||
7456 fabs(o.green.Y - data.green_coefficient) > DBL_EPSILON ||
7457 fabs(o.blue.Y - data.blue_coefficient) > DBL_EPSILON))
7458 png_error(pp, "internal pngvalid cHRM coefficient error");
7460 /* Generate a colour space encoding. */
7461 e.gamma = o.gamma; /* not used */
7462 e.red.X = API_cvt(rX);
7463 e.red.Y = API_cvt(rY);
7464 e.red.Z = API_cvt(rZ);
7465 e.green.X = API_cvt(gX);
7466 e.green.Y = API_cvt(gY);
7467 e.green.Z = API_cvt(gZ);
7468 e.blue.X = API_cvt(bX);
7469 e.blue.Y = API_cvt(bY);
7470 e.blue.Z = API_cvt(bZ);
7472 /* This should match the original one from the png_modifier, within
7473 * the range permitted by the libpng fixed point representation.
7476 el = "-"; /* Set to element name with error */
7478 # define CHECK(col,x)\
7480 double err = fabs(o.col.x - e.col.x);\
7484 el = #col "(" #x ")";\
7498 /* Here in both fixed and floating cases to check the values read
7499 * from the cHRm chunk. PNG uses fixed point in the cHRM chunk, so
7500 * we can't expect better than +/-.5E-5 on the result, allow 1E-5.
7507 pos = safecat(buffer, sizeof buffer, pos, API_form);
7508 pos = safecat(buffer, sizeof buffer, pos, " cHRM ");
7509 pos = safecat(buffer, sizeof buffer, pos, el);
7510 pos = safecat(buffer, sizeof buffer, pos, " error: ");
7511 pos = safecatd(buffer, sizeof buffer, pos, maxe, 7);
7512 pos = safecat(buffer, sizeof buffer, pos, " ");
7513 /* Print the color space without the gamma value: */
7514 pos = safecat_color_encoding(buffer, sizeof buffer, pos, &o, 0);
7515 pos = safecat(buffer, sizeof buffer, pos, " -> ");
7516 pos = safecat_color_encoding(buffer, sizeof buffer, pos, &e, 0);
7518 png_error(pp, buffer);
7522 # endif /* READ_cHRM */
7524 this->next->set(this->next, that, pp, pi);
7528 image_transform_png_set_rgb_to_gray_mod(const image_transform *this,
7529 image_pixel *that, png_const_structp pp,
7530 const transform_display *display)
7532 if ((that->colour_type & PNG_COLOR_MASK_COLOR) != 0)
7536 # if PNG_LIBPNG_VER < 10700
7537 if (that->colour_type == PNG_COLOR_TYPE_PALETTE)
7538 image_pixel_convert_PLTE(that);
7541 /* Image now has RGB channels... */
7544 png_modifier *pm = display->pm;
7545 const unsigned int sample_depth = that->sample_depth;
7546 const unsigned int calc_depth = (pm->assume_16_bit_calculations ? 16 :
7548 const unsigned int gamma_depth =
7549 (sample_depth == 16 ?
7550 display->max_gamma_8 :
7551 (pm->assume_16_bit_calculations ?
7552 display->max_gamma_8 :
7556 double rlo, rhi, glo, ghi, blo, bhi, graylo, grayhi;
7558 /* Do this using interval arithmetic, otherwise it is too difficult to
7559 * handle the errors correctly.
7561 * To handle the gamma correction work out the upper and lower bounds
7562 * of the digitized value. Assume rounding here - normally the values
7563 * will be identical after this operation if there is only one
7564 * transform, feel free to delete the png_error checks on this below in
7565 * the future (this is just me trying to ensure it works!)
7567 * Interval arithmetic is exact, but to implement it it must be
7568 * possible to control the floating point implementation rounding mode.
7569 * This cannot be done in ANSI-C, so instead I reduce the 'lo' values
7570 * by DBL_EPSILON and increase the 'hi' values by the same.
7572 # define DD(v,d,r) (digitize(v*(1-DBL_EPSILON), d, r) * (1-DBL_EPSILON))
7573 # define DU(v,d,r) (digitize(v*(1+DBL_EPSILON), d, r) * (1+DBL_EPSILON))
7575 r = rlo = rhi = that->redf;
7577 rlo = DD(rlo, calc_depth, 1/*round*/);
7579 rhi = DU(rhi, calc_depth, 1/*round*/);
7581 g = glo = ghi = that->greenf;
7582 glo -= that->greene;
7583 glo = DD(glo, calc_depth, 1/*round*/);
7584 ghi += that->greene;
7585 ghi = DU(ghi, calc_depth, 1/*round*/);
7587 b = blo = bhi = that->bluef;
7589 blo = DD(blo, calc_depth, 1/*round*/);
7591 bhi = DU(bhi, calc_depth, 1/*round*/);
7593 isgray = r==g && g==b;
7595 if (data.gamma != 1)
7597 const double power = 1/data.gamma;
7598 const double abse = .5/(sample_depth == 16 ? 65535 : 255);
7600 /* If a gamma calculation is done it is done using lookup tables of
7601 * precision gamma_depth, so the already digitized value above may
7602 * need to be further digitized here.
7604 if (gamma_depth != calc_depth)
7606 rlo = DD(rlo, gamma_depth, 0/*truncate*/);
7607 rhi = DU(rhi, gamma_depth, 0/*truncate*/);
7608 glo = DD(glo, gamma_depth, 0/*truncate*/);
7609 ghi = DU(ghi, gamma_depth, 0/*truncate*/);
7610 blo = DD(blo, gamma_depth, 0/*truncate*/);
7611 bhi = DU(bhi, gamma_depth, 0/*truncate*/);
7614 /* 'abse' is the error in the gamma table calculation itself. */
7616 rlo = DD(pow(rlo, power)-abse, calc_depth, 1);
7617 rhi = DU(pow(rhi, power)+abse, calc_depth, 1);
7620 glo = DD(pow(glo, power)-abse, calc_depth, 1);
7621 ghi = DU(pow(ghi, power)+abse, calc_depth, 1);
7624 blo = DD(pow(blo, power)-abse, calc_depth, 1);
7625 bhi = DU(pow(bhi, power)+abse, calc_depth, 1);
7628 /* Now calculate the actual gray values. Although the error in the
7629 * coefficients depends on whether they were specified on the command
7630 * line (in which case truncation to 15 bits happened) or not (rounding
7631 * was used) the maxium error in an individual coefficient is always
7632 * 2/32768, because even in the rounding case the requirement that
7633 * coefficients add up to 32768 can cause a larger rounding error.
7635 * The only time when rounding doesn't occur in 1.5.5 and later is when
7636 * the non-gamma code path is used for less than 16 bit data.
7638 gray = r * data.red_coefficient + g * data.green_coefficient +
7639 b * data.blue_coefficient;
7642 const int do_round = data.gamma != 1 || calc_depth == 16;
7643 const double ce = 2. / 32768;
7645 graylo = DD(rlo * (data.red_coefficient-ce) +
7646 glo * (data.green_coefficient-ce) +
7647 blo * (data.blue_coefficient-ce), calc_depth, do_round);
7648 if (graylo > gray) /* always accept the right answer */
7651 grayhi = DU(rhi * (data.red_coefficient+ce) +
7652 ghi * (data.green_coefficient+ce) +
7653 bhi * (data.blue_coefficient+ce), calc_depth, do_round);
7658 /* And invert the gamma. */
7659 if (data.gamma != 1)
7661 const double power = data.gamma;
7663 /* And this happens yet again, shifting the values once more. */
7664 if (gamma_depth != sample_depth)
7666 rlo = DD(rlo, gamma_depth, 0/*truncate*/);
7667 rhi = DU(rhi, gamma_depth, 0/*truncate*/);
7668 glo = DD(glo, gamma_depth, 0/*truncate*/);
7669 ghi = DU(ghi, gamma_depth, 0/*truncate*/);
7670 blo = DD(blo, gamma_depth, 0/*truncate*/);
7671 bhi = DU(bhi, gamma_depth, 0/*truncate*/);
7674 gray = pow(gray, power);
7675 graylo = DD(pow(graylo, power), sample_depth, 1);
7676 grayhi = DU(pow(grayhi, power), sample_depth, 1);
7682 /* Now the error can be calculated.
7684 * If r==g==b because there is no overall gamma correction libpng
7685 * currently preserves the original value.
7688 err = (that->rede + that->greene + that->bluee)/3;
7692 err = fabs(grayhi-gray);
7694 if (fabs(gray - graylo) > err)
7695 err = fabs(graylo-gray);
7698 /* Check that this worked: */
7699 if (err > pm->limit)
7704 pos = safecat(buffer, sizeof buffer, pos, "rgb_to_gray error ");
7705 pos = safecatd(buffer, sizeof buffer, pos, err, 6);
7706 pos = safecat(buffer, sizeof buffer, pos, " exceeds limit ");
7707 pos = safecatd(buffer, sizeof buffer, pos, pm->limit, 6);
7708 png_warning(pp, buffer);
7711 #endif /* !RELEASE_BUILD */
7714 # else /* !DIGITIZE */
7716 double r = that->redf;
7717 double re = that->rede;
7718 double g = that->greenf;
7719 double ge = that->greene;
7720 double b = that->bluef;
7721 double be = that->bluee;
7723 # if PNG_LIBPNG_VER < 10700
7724 /* The true gray case involves no math in earlier versions (not
7725 * true, there was some if gamma correction was happening too.)
7727 if (r == g && r == b)
7731 if (err < ge) err = ge;
7732 if (err < be) err = be;
7736 # endif /* before 1.7 */
7737 if (data.gamma == 1)
7739 /* There is no need to do the conversions to and from linear space,
7740 * so the calculation should be a lot more accurate. There is a
7741 * built in error in the coefficients because they only have 15 bits
7742 * and are adjusted to make sure they add up to 32768. This
7743 * involves a integer calculation with truncation of the form:
7745 * ((int)(coefficient * 100000) * 32768)/100000
7747 * This is done to the red and green coefficients (the ones
7748 * provided to the API) then blue is calculated from them so the
7749 * result adds up to 32768. In the worst case this can result in
7750 * a -1 error in red and green and a +2 error in blue. Consequently
7751 * the worst case in the calculation below is 2/32768 error.
7753 * TODO: consider fixing this in libpng by rounding the calculation
7754 * limiting the error to 1/32768.
7756 * Handling this by adding 2/32768 here avoids needing to increase
7757 * the global error limits to take this into account.)
7759 gray = r * data.red_coefficient + g * data.green_coefficient +
7760 b * data.blue_coefficient;
7761 err = re * data.red_coefficient + ge * data.green_coefficient +
7762 be * data.blue_coefficient + 2./32768 + gray * 5 * DBL_EPSILON;
7767 /* The calculation happens in linear space, and this produces much
7768 * wider errors in the encoded space. These are handled here by
7769 * factoring the errors in to the calculation. There are two table
7770 * lookups in the calculation and each introduces a quantization
7771 * error defined by the table size.
7773 png_modifier *pm = display->pm;
7774 double in_qe = (that->sample_depth > 8 ? .5/65535 : .5/255);
7775 double out_qe = (that->sample_depth > 8 ? .5/65535 :
7776 (pm->assume_16_bit_calculations ? .5/(1<<display->max_gamma_8) :
7778 double rhi, ghi, bhi, grayhi;
7779 double g1 = 1/data.gamma;
7781 rhi = r + re + in_qe; if (rhi > 1) rhi = 1;
7782 r -= re + in_qe; if (r < 0) r = 0;
7783 ghi = g + ge + in_qe; if (ghi > 1) ghi = 1;
7784 g -= ge + in_qe; if (g < 0) g = 0;
7785 bhi = b + be + in_qe; if (bhi > 1) bhi = 1;
7786 b -= be + in_qe; if (b < 0) b = 0;
7788 r = pow(r, g1)*(1-DBL_EPSILON); rhi = pow(rhi, g1)*(1+DBL_EPSILON);
7789 g = pow(g, g1)*(1-DBL_EPSILON); ghi = pow(ghi, g1)*(1+DBL_EPSILON);
7790 b = pow(b, g1)*(1-DBL_EPSILON); bhi = pow(bhi, g1)*(1+DBL_EPSILON);
7792 /* Work out the lower and upper bounds for the gray value in the
7793 * encoded space, then work out an average and error. Remove the
7794 * previously added input quantization error at this point.
7796 gray = r * data.red_coefficient + g * data.green_coefficient +
7797 b * data.blue_coefficient - 2./32768 - out_qe;
7802 gray *= (1 - 6 * DBL_EPSILON);
7803 gray = pow(gray, data.gamma) * (1-DBL_EPSILON);
7806 grayhi = rhi * data.red_coefficient + ghi * data.green_coefficient +
7807 bhi * data.blue_coefficient + 2./32768 + out_qe;
7808 grayhi *= (1 + 6 * DBL_EPSILON);
7812 grayhi = pow(grayhi, data.gamma) * (1+DBL_EPSILON);
7814 err = (grayhi - gray) / 2;
7815 gray = (grayhi + gray) / 2;
7818 err = gray * DBL_EPSILON;
7824 /* Validate that the error is within limits (this has caused
7825 * problems before, it's much easier to detect them here.)
7827 if (err > pm->limit)
7832 pos = safecat(buffer, sizeof buffer, pos, "rgb_to_gray error ");
7833 pos = safecatd(buffer, sizeof buffer, pos, err, 6);
7834 pos = safecat(buffer, sizeof buffer, pos, " exceeds limit ");
7835 pos = safecatd(buffer, sizeof buffer, pos, pm->limit, 6);
7836 png_warning(pp, buffer);
7839 #endif /* !RELEASE_BUILD */
7842 # endif /* !DIGITIZE */
7844 that->bluef = that->greenf = that->redf = gray;
7845 that->bluee = that->greene = that->rede = err;
7847 /* The sBIT is the minium of the three colour channel sBITs. */
7848 if (that->red_sBIT > that->green_sBIT)
7849 that->red_sBIT = that->green_sBIT;
7850 if (that->red_sBIT > that->blue_sBIT)
7851 that->red_sBIT = that->blue_sBIT;
7852 that->blue_sBIT = that->green_sBIT = that->red_sBIT;
7854 /* And remove the colour bit in the type: */
7855 if (that->colour_type == PNG_COLOR_TYPE_RGB)
7856 that->colour_type = PNG_COLOR_TYPE_GRAY;
7857 else if (that->colour_type == PNG_COLOR_TYPE_RGB_ALPHA)
7858 that->colour_type = PNG_COLOR_TYPE_GRAY_ALPHA;
7861 this->next->mod(this->next, that, pp, display);
7865 image_transform_png_set_rgb_to_gray_add(image_transform *this,
7866 const image_transform **that, png_byte colour_type, png_byte bit_depth)
7873 return (colour_type & PNG_COLOR_MASK_COLOR) != 0;
7879 #define PT ITSTRUCT(rgb_to_gray)
7880 #undef image_transform_ini
7881 #define image_transform_ini image_transform_default_ini
7882 #endif /* PNG_READ_RGB_TO_GRAY_SUPPORTED */
7884 #ifdef PNG_READ_BACKGROUND_SUPPORTED
7885 /* png_set_background(png_structp, png_const_color_16p background_color,
7886 * int background_gamma_code, int need_expand, double background_gamma)
7887 * png_set_background_fixed(png_structp, png_const_color_16p background_color,
7888 * int background_gamma_code, int need_expand,
7889 * png_fixed_point background_gamma)
7891 * This ignores the gamma (at present.)
7893 #define data ITDATA(background)
7894 static image_pixel data;
7897 image_transform_png_set_background_set(const image_transform *this,
7898 transform_display *that, png_structp pp, png_infop pi)
7900 png_byte colour_type, bit_depth;
7901 png_byte random_bytes[8]; /* 8 bytes - 64 bits - the biggest pixel */
7905 /* We need a background colour, because we don't know exactly what transforms
7906 * have been set we have to supply the colour in the original file format and
7907 * so we need to know what that is! The background colour is stored in the
7908 * transform_display.
7912 /* Read the random value, for colour type 3 the background colour is actually
7913 * expressed as a 24bit rgb, not an index.
7915 colour_type = that->this.colour_type;
7916 if (colour_type == 3)
7918 colour_type = PNG_COLOR_TYPE_RGB;
7920 expand = 0; /* passing in an RGB not a pixel index */
7925 if (that->this.has_tRNS)
7926 that->this.is_transparent = 1;
7928 bit_depth = that->this.bit_depth;
7932 image_pixel_init(&data, random_bytes, colour_type,
7933 bit_depth, 0/*x*/, 0/*unused: palette*/, NULL/*format*/);
7935 /* Extract the background colour from this image_pixel, but make sure the
7936 * unused fields of 'back' are garbage.
7940 if (colour_type & PNG_COLOR_MASK_COLOR)
7942 back.red = (png_uint_16)data.red;
7943 back.green = (png_uint_16)data.green;
7944 back.blue = (png_uint_16)data.blue;
7948 back.gray = (png_uint_16)data.red;
7950 # ifdef PNG_FLOATING_POINT_SUPPORTED
7951 png_set_background(pp, &back, PNG_BACKGROUND_GAMMA_FILE, expand, 0);
7953 png_set_background_fixed(pp, &back, PNG_BACKGROUND_GAMMA_FILE, expand, 0);
7956 this->next->set(this->next, that, pp, pi);
7960 image_transform_png_set_background_mod(const image_transform *this,
7961 image_pixel *that, png_const_structp pp,
7962 const transform_display *display)
7964 /* Check for tRNS first: */
7965 if (that->have_tRNS && that->colour_type != PNG_COLOR_TYPE_PALETTE)
7966 image_pixel_add_alpha(that, &display->this, 1/*for background*/);
7968 /* This is only necessary if the alpha value is less than 1. */
7969 if (that->alphaf < 1)
7971 /* Now we do the background calculation without any gamma correction. */
7972 if (that->alphaf <= 0)
7974 that->redf = data.redf;
7975 that->greenf = data.greenf;
7976 that->bluef = data.bluef;
7978 that->rede = data.rede;
7979 that->greene = data.greene;
7980 that->bluee = data.bluee;
7982 that->red_sBIT= data.red_sBIT;
7983 that->green_sBIT= data.green_sBIT;
7984 that->blue_sBIT= data.blue_sBIT;
7987 else /* 0 < alpha < 1 */
7989 double alf = 1 - that->alphaf;
7991 that->redf = that->redf * that->alphaf + data.redf * alf;
7992 that->rede = that->rede * that->alphaf + data.rede * alf +
7994 that->greenf = that->greenf * that->alphaf + data.greenf * alf;
7995 that->greene = that->greene * that->alphaf + data.greene * alf +
7997 that->bluef = that->bluef * that->alphaf + data.bluef * alf;
7998 that->bluee = that->bluee * that->alphaf + data.bluee * alf +
8002 /* Remove the alpha type and set the alpha (not in that order.) */
8007 if (that->colour_type == PNG_COLOR_TYPE_RGB_ALPHA)
8008 that->colour_type = PNG_COLOR_TYPE_RGB;
8009 else if (that->colour_type == PNG_COLOR_TYPE_GRAY_ALPHA)
8010 that->colour_type = PNG_COLOR_TYPE_GRAY;
8011 /* PNG_COLOR_TYPE_PALETTE is not changed */
8013 this->next->mod(this->next, that, pp, display);
8016 #define image_transform_png_set_background_add image_transform_default_add
8021 #define PT ITSTRUCT(background)
8022 #endif /* PNG_READ_BACKGROUND_SUPPORTED */
8024 /* png_set_quantize(png_structp, png_colorp palette, int num_palette,
8025 * int maximum_colors, png_const_uint_16p histogram, int full_quantize)
8027 * Very difficult to validate this!
8031 /* The data layout transforms are handled by swapping our own channel data,
8032 * necessarily these need to happen at the end of the transform list because the
8033 * semantic of the channels changes after these are executed. Some of these,
8034 * like set_shift and set_packing, can't be done at present because they change
8035 * the layout of the data at the sub-sample level so sample() won't get the
8038 /* png_set_invert_alpha */
8039 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
8040 /* Invert the alpha channel
8042 * png_set_invert_alpha(png_structrp png_ptr)
8045 image_transform_png_set_invert_alpha_set(const image_transform *this,
8046 transform_display *that, png_structp pp, png_infop pi)
8048 png_set_invert_alpha(pp);
8049 this->next->set(this->next, that, pp, pi);
8053 image_transform_png_set_invert_alpha_mod(const image_transform *this,
8054 image_pixel *that, png_const_structp pp,
8055 const transform_display *display)
8057 if (that->colour_type & 4)
8058 that->alpha_inverted = 1;
8060 this->next->mod(this->next, that, pp, display);
8064 image_transform_png_set_invert_alpha_add(image_transform *this,
8065 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8072 /* Only has an effect on pixels with alpha: */
8073 return (colour_type & 4) != 0;
8078 #define PT ITSTRUCT(invert_alpha)
8080 #endif /* PNG_READ_INVERT_ALPHA_SUPPORTED */
8083 #ifdef PNG_READ_BGR_SUPPORTED
8084 /* Swap R,G,B channels to order B,G,R.
8086 * png_set_bgr(png_structrp png_ptr)
8088 * This only has an effect on RGB and RGBA pixels.
8091 image_transform_png_set_bgr_set(const image_transform *this,
8092 transform_display *that, png_structp pp, png_infop pi)
8095 this->next->set(this->next, that, pp, pi);
8099 image_transform_png_set_bgr_mod(const image_transform *this,
8100 image_pixel *that, png_const_structp pp,
8101 const transform_display *display)
8103 if (that->colour_type == PNG_COLOR_TYPE_RGB ||
8104 that->colour_type == PNG_COLOR_TYPE_RGBA)
8107 this->next->mod(this->next, that, pp, display);
8111 image_transform_png_set_bgr_add(image_transform *this,
8112 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8119 return colour_type == PNG_COLOR_TYPE_RGB ||
8120 colour_type == PNG_COLOR_TYPE_RGBA;
8125 #define PT ITSTRUCT(bgr)
8127 #endif /* PNG_READ_BGR_SUPPORTED */
8129 /* png_set_swap_alpha */
8130 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
8131 /* Put the alpha channel first.
8133 * png_set_swap_alpha(png_structrp png_ptr)
8135 * This only has an effect on GA and RGBA pixels.
8138 image_transform_png_set_swap_alpha_set(const image_transform *this,
8139 transform_display *that, png_structp pp, png_infop pi)
8141 png_set_swap_alpha(pp);
8142 this->next->set(this->next, that, pp, pi);
8146 image_transform_png_set_swap_alpha_mod(const image_transform *this,
8147 image_pixel *that, png_const_structp pp,
8148 const transform_display *display)
8150 if (that->colour_type == PNG_COLOR_TYPE_GA ||
8151 that->colour_type == PNG_COLOR_TYPE_RGBA)
8152 that->alpha_first = 1;
8154 this->next->mod(this->next, that, pp, display);
8158 image_transform_png_set_swap_alpha_add(image_transform *this,
8159 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8166 return colour_type == PNG_COLOR_TYPE_GA ||
8167 colour_type == PNG_COLOR_TYPE_RGBA;
8172 #define PT ITSTRUCT(swap_alpha)
8174 #endif /* PNG_READ_SWAP_ALPHA_SUPPORTED */
8177 #ifdef PNG_READ_SWAP_SUPPORTED
8178 /* Byte swap 16-bit components.
8180 * png_set_swap(png_structrp png_ptr)
8183 image_transform_png_set_swap_set(const image_transform *this,
8184 transform_display *that, png_structp pp, png_infop pi)
8187 this->next->set(this->next, that, pp, pi);
8191 image_transform_png_set_swap_mod(const image_transform *this,
8192 image_pixel *that, png_const_structp pp,
8193 const transform_display *display)
8195 if (that->bit_depth == 16)
8198 this->next->mod(this->next, that, pp, display);
8202 image_transform_png_set_swap_add(image_transform *this,
8203 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8210 return bit_depth == 16;
8215 #define PT ITSTRUCT(swap)
8217 #endif /* PNG_READ_SWAP_SUPPORTED */
8219 #ifdef PNG_READ_FILLER_SUPPORTED
8220 /* Add a filler byte to 8-bit Gray or 24-bit RGB images.
8222 * png_set_filler, (png_structp png_ptr, png_uint_32 filler, int flags));
8229 #define data ITDATA(filler)
8237 image_transform_png_set_filler_set(const image_transform *this,
8238 transform_display *that, png_structp pp, png_infop pi)
8240 /* Need a random choice for 'before' and 'after' as well as for the
8241 * filler. The 'filler' value has all 32 bits set, but only bit_depth
8242 * will be used. At this point we don't know bit_depth.
8245 data.flags = random_choice();
8247 png_set_filler(pp, data.filler, data.flags);
8249 /* The standard display handling stuff also needs to know that
8250 * there is a filler, so set that here.
8252 that->this.filler = 1;
8254 this->next->set(this->next, that, pp, pi);
8258 image_transform_png_set_filler_mod(const image_transform *this,
8259 image_pixel *that, png_const_structp pp,
8260 const transform_display *display)
8262 if (that->bit_depth >= 8 &&
8263 (that->colour_type == PNG_COLOR_TYPE_RGB ||
8264 that->colour_type == PNG_COLOR_TYPE_GRAY))
8266 const unsigned int max = (1U << that->bit_depth)-1;
8267 that->alpha = data.filler & max;
8268 that->alphaf = ((double)that->alpha) / max;
8271 /* The filler has been stored in the alpha channel, we must record
8272 * that this has been done for the checking later on, the color
8273 * type is faked to have an alpha channel, but libpng won't report
8274 * this; the app has to know the extra channel is there and this
8275 * was recording in standard_display::filler above.
8277 that->colour_type |= 4; /* alpha added */
8278 that->alpha_first = data.flags == PNG_FILLER_BEFORE;
8281 this->next->mod(this->next, that, pp, display);
8285 image_transform_png_set_filler_add(image_transform *this,
8286 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8291 return bit_depth >= 8 && (colour_type == PNG_COLOR_TYPE_RGB ||
8292 colour_type == PNG_COLOR_TYPE_GRAY);
8298 #define PT ITSTRUCT(filler)
8300 /* png_set_add_alpha, (png_structp png_ptr, png_uint_32 filler, int flags)); */
8301 /* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */
8302 #define data ITDATA(add_alpha)
8310 image_transform_png_set_add_alpha_set(const image_transform *this,
8311 transform_display *that, png_structp pp, png_infop pi)
8313 /* Need a random choice for 'before' and 'after' as well as for the
8314 * filler. The 'filler' value has all 32 bits set, but only bit_depth
8315 * will be used. At this point we don't know bit_depth.
8318 data.flags = random_choice();
8320 png_set_add_alpha(pp, data.filler, data.flags);
8321 this->next->set(this->next, that, pp, pi);
8325 image_transform_png_set_add_alpha_mod(const image_transform *this,
8326 image_pixel *that, png_const_structp pp,
8327 const transform_display *display)
8329 if (that->bit_depth >= 8 &&
8330 (that->colour_type == PNG_COLOR_TYPE_RGB ||
8331 that->colour_type == PNG_COLOR_TYPE_GRAY))
8333 const unsigned int max = (1U << that->bit_depth)-1;
8334 that->alpha = data.filler & max;
8335 that->alphaf = ((double)that->alpha) / max;
8338 that->colour_type |= 4; /* alpha added */
8339 that->alpha_first = data.flags == PNG_FILLER_BEFORE;
8342 this->next->mod(this->next, that, pp, display);
8346 image_transform_png_set_add_alpha_add(image_transform *this,
8347 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8352 return bit_depth >= 8 && (colour_type == PNG_COLOR_TYPE_RGB ||
8353 colour_type == PNG_COLOR_TYPE_GRAY);
8359 #define PT ITSTRUCT(add_alpha)
8361 #endif /* PNG_READ_FILLER_SUPPORTED */
8363 /* png_set_packing */
8364 #ifdef PNG_READ_PACK_SUPPORTED
8365 /* Use 1 byte per pixel in 1, 2, or 4-bit depth files.
8367 * png_set_packing(png_structrp png_ptr)
8369 * This should only affect grayscale and palette images with less than 8 bits
8373 image_transform_png_set_packing_set(const image_transform *this,
8374 transform_display *that, png_structp pp, png_infop pi)
8376 png_set_packing(pp);
8378 this->next->set(this->next, that, pp, pi);
8382 image_transform_png_set_packing_mod(const image_transform *this,
8383 image_pixel *that, png_const_structp pp,
8384 const transform_display *display)
8386 /* The general expand case depends on what the colour type is,
8387 * low bit-depth pixel values are unpacked into bytes without
8388 * scaling, so sample_depth is not changed.
8390 if (that->bit_depth < 8) /* grayscale or palette */
8391 that->bit_depth = 8;
8393 this->next->mod(this->next, that, pp, display);
8397 image_transform_png_set_packing_add(image_transform *this,
8398 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8405 /* Nothing should happen unless the bit depth is less than 8: */
8406 return bit_depth < 8;
8411 #define PT ITSTRUCT(packing)
8413 #endif /* PNG_READ_PACK_SUPPORTED */
8415 /* png_set_packswap */
8416 #ifdef PNG_READ_PACKSWAP_SUPPORTED
8417 /* Swap pixels packed into bytes; reverses the order on screen so that
8418 * the high order bits correspond to the rightmost pixels.
8420 * png_set_packswap(png_structrp png_ptr)
8423 image_transform_png_set_packswap_set(const image_transform *this,
8424 transform_display *that, png_structp pp, png_infop pi)
8426 png_set_packswap(pp);
8427 that->this.littleendian = 1;
8428 this->next->set(this->next, that, pp, pi);
8432 image_transform_png_set_packswap_mod(const image_transform *this,
8433 image_pixel *that, png_const_structp pp,
8434 const transform_display *display)
8436 if (that->bit_depth < 8)
8437 that->littleendian = 1;
8439 this->next->mod(this->next, that, pp, display);
8443 image_transform_png_set_packswap_add(image_transform *this,
8444 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8451 return bit_depth < 8;
8456 #define PT ITSTRUCT(packswap)
8458 #endif /* PNG_READ_PACKSWAP_SUPPORTED */
8461 /* png_set_invert_mono */
8462 #ifdef PNG_READ_INVERT_MONO_SUPPORTED
8463 /* Invert the gray channel
8465 * png_set_invert_mono(png_structrp png_ptr)
8468 image_transform_png_set_invert_mono_set(const image_transform *this,
8469 transform_display *that, png_structp pp, png_infop pi)
8471 png_set_invert_mono(pp);
8472 this->next->set(this->next, that, pp, pi);
8476 image_transform_png_set_invert_mono_mod(const image_transform *this,
8477 image_pixel *that, png_const_structp pp,
8478 const transform_display *display)
8480 if (that->colour_type & 4)
8481 that->mono_inverted = 1;
8483 this->next->mod(this->next, that, pp, display);
8487 image_transform_png_set_invert_mono_add(image_transform *this,
8488 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8495 /* Only has an effect on pixels with no colour: */
8496 return (colour_type & 2) == 0;
8501 #define PT ITSTRUCT(invert_mono)
8503 #endif /* PNG_READ_INVERT_MONO_SUPPORTED */
8505 #ifdef PNG_READ_SHIFT_SUPPORTED
8506 /* png_set_shift(png_structp, png_const_color_8p true_bits)
8508 * The output pixels will be shifted by the given true_bits
8511 #define data ITDATA(shift)
8512 static png_color_8 data;
8515 image_transform_png_set_shift_set(const image_transform *this,
8516 transform_display *that, png_structp pp, png_infop pi)
8518 /* Get a random set of shifts. The shifts need to do something
8519 * to test the transform, so they are limited to the bit depth
8520 * of the input image. Notice that in the following the 'gray'
8521 * field is randomized independently. This acts as a check that
8522 * libpng does use the correct field.
8524 const unsigned int depth = that->this.bit_depth;
8526 data.red = (png_byte)/*SAFE*/(random_mod(depth)+1);
8527 data.green = (png_byte)/*SAFE*/(random_mod(depth)+1);
8528 data.blue = (png_byte)/*SAFE*/(random_mod(depth)+1);
8529 data.gray = (png_byte)/*SAFE*/(random_mod(depth)+1);
8530 data.alpha = (png_byte)/*SAFE*/(random_mod(depth)+1);
8532 png_set_shift(pp, &data);
8533 this->next->set(this->next, that, pp, pi);
8537 image_transform_png_set_shift_mod(const image_transform *this,
8538 image_pixel *that, png_const_structp pp,
8539 const transform_display *display)
8541 /* Copy the correct values into the sBIT fields, libpng does not do
8542 * anything to palette data:
8544 if (that->colour_type != PNG_COLOR_TYPE_PALETTE)
8548 /* The sBIT fields are reset to the values previously sent to
8549 * png_set_shift according to the colour type.
8552 if (that->colour_type & 2) /* RGB channels */
8554 that->red_sBIT = data.red;
8555 that->green_sBIT = data.green;
8556 that->blue_sBIT = data.blue;
8559 else /* One grey channel */
8560 that->red_sBIT = that->green_sBIT = that->blue_sBIT = data.gray;
8562 that->alpha_sBIT = data.alpha;
8565 this->next->mod(this->next, that, pp, display);
8569 image_transform_png_set_shift_add(image_transform *this,
8570 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8577 return colour_type != PNG_COLOR_TYPE_PALETTE;
8582 #define PT ITSTRUCT(shift)
8584 #endif /* PNG_READ_SHIFT_SUPPORTED */
8586 #ifdef THIS_IS_THE_PROFORMA
8588 image_transform_png_set_@_set(const image_transform *this,
8589 transform_display *that, png_structp pp, png_infop pi)
8592 this->next->set(this->next, that, pp, pi);
8596 image_transform_png_set_@_mod(const image_transform *this,
8597 image_pixel *that, png_const_structp pp,
8598 const transform_display *display)
8600 this->next->mod(this->next, that, pp, display);
8604 image_transform_png_set_@_add(image_transform *this,
8605 const image_transform **that, png_byte colour_type, png_byte bit_depth)
8617 /* This may just be 'end' if all the transforms are disabled! */
8618 static image_transform *const image_transform_first = &PT;
8621 transform_enable(const char *name)
8623 /* Everything starts out enabled, so if we see an 'enable' disabled
8624 * everything else the first time round.
8626 static int all_disabled = 0;
8628 image_transform *list = image_transform_first;
8630 while (list != &image_transform_end)
8632 if (strcmp(list->name, name) == 0)
8637 else if (!all_disabled)
8647 fprintf(stderr, "pngvalid: --transform-enable=%s: unknown transform\n",
8654 transform_disable(const char *name)
8656 image_transform *list = image_transform_first;
8658 while (list != &image_transform_end)
8660 if (strcmp(list->name, name) == 0)
8669 fprintf(stderr, "pngvalid: --transform-disable=%s: unknown transform\n",
8675 image_transform_reset_count(void)
8677 image_transform *next = image_transform_first;
8680 while (next != &image_transform_end)
8682 next->local_use = 0;
8688 /* This can only happen if we every have more than 32 transforms (excluding
8689 * the end) in the list.
8691 if (count > 32) abort();
8695 image_transform_test_counter(png_uint_32 counter, unsigned int max)
8697 /* Test the list to see if there is any point contining, given a current
8698 * counter and a 'max' value.
8700 image_transform *next = image_transform_first;
8702 while (next != &image_transform_end)
8704 /* For max 0 or 1 continue until the counter overflows: */
8707 /* Continue if any entry hasn't reacked the max. */
8708 if (max > 1 && next->local_use < max)
8713 return max <= 1 && counter == 0;
8717 image_transform_add(const image_transform **this, unsigned int max,
8718 png_uint_32 counter, char *name, size_t sizeof_name, size_t *pos,
8719 png_byte colour_type, png_byte bit_depth)
8721 for (;;) /* until we manage to add something */
8724 image_transform *list;
8726 /* Find the next counter value, if the counter is zero this is the start
8727 * of the list. This routine always returns the current counter (not the
8728 * next) so it returns 0 at the end and expects 0 at the beginning.
8730 if (counter == 0) /* first time */
8732 image_transform_reset_count();
8736 counter = random_32();
8738 else /* advance the counter */
8742 case 0: ++counter; break;
8743 case 1: counter <<= 1; break;
8744 default: counter = random_32(); break;
8748 /* Now add all these items, if possible */
8749 *this = &image_transform_end;
8750 list = image_transform_first;
8753 /* Go through the whole list adding anything that the counter selects: */
8754 while (list != &image_transform_end)
8756 if ((counter & mask) != 0 && list->enable &&
8757 (max == 0 || list->local_use < max))
8759 /* Candidate to add: */
8760 if (list->add(list, this, colour_type, bit_depth) || max == 0)
8762 /* Added, so add to the name too. */
8763 *pos = safecat(name, sizeof_name, *pos, " +");
8764 *pos = safecat(name, sizeof_name, *pos, list->name);
8769 /* Not useful and max>0, so remove it from *this: */
8773 /* And, since we know it isn't useful, stop it being added again
8776 list->local_use = max;
8784 /* Now if anything was added we have something to do. */
8785 if (*this != &image_transform_end)
8788 /* Nothing added, but was there anything in there to add? */
8789 if (!image_transform_test_counter(counter, max))
8795 perform_transform_test(png_modifier *pm)
8797 png_byte colour_type = 0;
8798 png_byte bit_depth = 0;
8799 unsigned int palette_number = 0;
8801 while (next_format(&colour_type, &bit_depth, &palette_number, pm->test_lbg,
8804 png_uint_32 counter = 0;
8808 base_pos = safecat(name, sizeof name, 0, "transform:");
8812 size_t pos = base_pos;
8813 const image_transform *list = 0;
8815 /* 'max' is currently hardwired to '1'; this should be settable on the
8818 counter = image_transform_add(&list, 1/*max*/, counter,
8819 name, sizeof name, &pos, colour_type, bit_depth);
8824 /* The command line can change this to checking interlaced images. */
8828 transform_test(pm, FILEID(colour_type, bit_depth, palette_number,
8829 pm->interlace_type, 0, 0, 0), list, name);
8838 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
8840 /********************************* GAMMA TESTS ********************************/
8841 #ifdef PNG_READ_GAMMA_SUPPORTED
8842 /* Reader callbacks and implementations, where they differ from the standard
8845 typedef struct gamma_display
8847 standard_display this;
8852 double screen_gamma;
8853 double background_gamma;
8856 int use_input_precision;
8860 png_color_16 background_color;
8862 /* Local variables */
8868 #define ALPHA_MODE_OFFSET 4
8871 gamma_display_init(gamma_display *dp, png_modifier *pm, png_uint_32 id,
8872 double file_gamma, double screen_gamma, png_byte sbit, int threshold_test,
8873 int use_input_precision, int scale16, int expand16,
8874 int do_background, const png_color_16 *pointer_to_the_background_color,
8875 double background_gamma)
8877 /* Standard fields */
8878 standard_display_init(&dp->this, &pm->this, id, do_read_interlace,
8879 pm->use_update_info);
8881 /* Parameter fields */
8883 dp->file_gamma = file_gamma;
8884 dp->screen_gamma = screen_gamma;
8885 dp->background_gamma = background_gamma;
8887 dp->threshold_test = threshold_test;
8888 dp->use_input_precision = use_input_precision;
8889 dp->scale16 = scale16;
8890 dp->expand16 = expand16;
8891 dp->do_background = do_background;
8892 if (do_background && pointer_to_the_background_color != 0)
8893 dp->background_color = *pointer_to_the_background_color;
8895 memset(&dp->background_color, 0, sizeof dp->background_color);
8897 /* Local variable fields */
8898 dp->maxerrout = dp->maxerrpc = dp->maxerrabs = 0;
8902 gamma_info_imp(gamma_display *dp, png_structp pp, png_infop pi)
8904 /* Reuse the standard stuff as appropriate. */
8905 standard_info_part1(&dp->this, pp, pi);
8907 /* If requested strip 16 to 8 bits - this is handled automagically below
8908 * because the output bit depth is read from the library. Note that there
8909 * are interactions with sBIT but, internally, libpng makes sbit at most
8910 * PNG_MAX_GAMMA_8 prior to 1.7 when doing the following.
8913 # ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
8914 png_set_scale_16(pp);
8916 /* The following works both in 1.5.4 and earlier versions: */
8917 # ifdef PNG_READ_16_TO_8_SUPPORTED
8918 png_set_strip_16(pp);
8920 png_error(pp, "scale16 (16 to 8 bit conversion) not supported");
8925 # ifdef PNG_READ_EXPAND_16_SUPPORTED
8926 png_set_expand_16(pp);
8928 png_error(pp, "expand16 (8 to 16 bit conversion) not supported");
8931 if (dp->do_background >= ALPHA_MODE_OFFSET)
8933 # ifdef PNG_READ_ALPHA_MODE_SUPPORTED
8935 /* This tests the alpha mode handling, if supported. */
8936 int mode = dp->do_background - ALPHA_MODE_OFFSET;
8938 /* The gamma value is the output gamma, and is in the standard,
8939 * non-inverted, represenation. It provides a default for the PNG file
8940 * gamma, but since the file has a gAMA chunk this does not matter.
8942 const double sg = dp->screen_gamma;
8943 # ifndef PNG_FLOATING_POINT_SUPPORTED
8944 const png_fixed_point g = fix(sg);
8947 # ifdef PNG_FLOATING_POINT_SUPPORTED
8948 png_set_alpha_mode(pp, mode, sg);
8950 png_set_alpha_mode_fixed(pp, mode, g);
8953 /* However, for the standard Porter-Duff algorithm the output defaults
8954 * to be linear, so if the test requires non-linear output it must be
8957 if (mode == PNG_ALPHA_STANDARD && sg != 1)
8959 # ifdef PNG_FLOATING_POINT_SUPPORTED
8960 png_set_gamma(pp, sg, dp->file_gamma);
8962 png_fixed_point f = fix(dp->file_gamma);
8963 png_set_gamma_fixed(pp, g, f);
8968 png_error(pp, "alpha mode handling not supported");
8974 /* Set up gamma processing. */
8975 # ifdef PNG_FLOATING_POINT_SUPPORTED
8976 png_set_gamma(pp, dp->screen_gamma, dp->file_gamma);
8979 png_fixed_point s = fix(dp->screen_gamma);
8980 png_fixed_point f = fix(dp->file_gamma);
8981 png_set_gamma_fixed(pp, s, f);
8985 if (dp->do_background)
8987 # ifdef PNG_READ_BACKGROUND_SUPPORTED
8988 /* NOTE: this assumes the caller provided the correct background gamma!
8990 const double bg = dp->background_gamma;
8991 # ifndef PNG_FLOATING_POINT_SUPPORTED
8992 const png_fixed_point g = fix(bg);
8995 # ifdef PNG_FLOATING_POINT_SUPPORTED
8996 png_set_background(pp, &dp->background_color, dp->do_background,
8997 0/*need_expand*/, bg);
8999 png_set_background_fixed(pp, &dp->background_color,
9000 dp->do_background, 0/*need_expand*/, g);
9003 png_error(pp, "png_set_background not supported");
9009 int i = dp->this.use_update_info;
9010 /* Always do one call, even if use_update_info is 0. */
9012 png_read_update_info(pp, pi);
9016 /* Now we may get a different cbRow: */
9017 standard_info_part2(&dp->this, pp, pi, 1 /*images*/);
9020 static void PNGCBAPI
9021 gamma_info(png_structp pp, png_infop pi)
9023 gamma_info_imp(voidcast(gamma_display*, png_get_progressive_ptr(pp)), pp,
9027 /* Validate a single component value - the routine gets the input and output
9028 * sample values as unscaled PNG component values along with a cache of all the
9029 * information required to validate the values.
9031 typedef struct validate_info
9033 png_const_structp pp;
9036 int use_input_precision;
9039 unsigned int sbit_max;
9040 unsigned int isbit_shift;
9041 unsigned int outmax;
9043 double gamma_correction; /* Overall correction required. */
9044 double file_inverse; /* Inverse of file gamma. */
9045 double screen_gamma;
9046 double screen_inverse; /* Inverse of screen gamma. */
9048 double background_red; /* Linear background value, red or gray. */
9049 double background_green;
9050 double background_blue;
9056 double maxout_total; /* Total including quantization error */
9063 init_validate_info(validate_info *vi, gamma_display *dp, png_const_structp pp,
9064 int in_depth, int out_depth)
9066 const unsigned int outmax = (1U<<out_depth)-1;
9071 if (dp->sbit > 0 && dp->sbit < in_depth)
9073 vi->sbit = dp->sbit;
9074 vi->isbit_shift = in_depth - dp->sbit;
9079 vi->sbit = (png_byte)in_depth;
9080 vi->isbit_shift = 0;
9083 vi->sbit_max = (1U << vi->sbit)-1;
9085 /* This mimics the libpng threshold test, '0' is used to prevent gamma
9086 * correction in the validation test.
9088 vi->screen_gamma = dp->screen_gamma;
9089 if (fabs(vi->screen_gamma-1) < PNG_GAMMA_THRESHOLD)
9090 vi->screen_gamma = vi->screen_inverse = 0;
9092 vi->screen_inverse = 1/vi->screen_gamma;
9094 vi->use_input_precision = dp->use_input_precision;
9095 vi->outmax = outmax;
9096 vi->maxabs = abserr(dp->pm, in_depth, out_depth);
9097 vi->maxpc = pcerr(dp->pm, in_depth, out_depth);
9098 vi->maxcalc = calcerr(dp->pm, in_depth, out_depth);
9099 vi->maxout = outerr(dp->pm, in_depth, out_depth);
9100 vi->outquant = output_quantization_factor(dp->pm, in_depth, out_depth);
9101 vi->maxout_total = vi->maxout + vi->outquant * .5;
9102 vi->outlog = outlog(dp->pm, in_depth, out_depth);
9104 if ((dp->this.colour_type & PNG_COLOR_MASK_ALPHA) != 0 ||
9105 (dp->this.colour_type == 3 && dp->this.is_transparent) ||
9106 ((dp->this.colour_type == 0 || dp->this.colour_type == 2) &&
9109 vi->do_background = dp->do_background;
9111 if (vi->do_background != 0)
9113 const double bg_inverse = 1/dp->background_gamma;
9116 /* Caller must at least put the gray value into the red channel */
9117 r = dp->background_color.red; r /= outmax;
9118 g = dp->background_color.green; g /= outmax;
9119 b = dp->background_color.blue; b /= outmax;
9122 /* libpng doesn't do this optimization, if we do pngvalid will fail.
9124 if (fabs(bg_inverse-1) >= PNG_GAMMA_THRESHOLD)
9127 r = pow(r, bg_inverse);
9128 g = pow(g, bg_inverse);
9129 b = pow(b, bg_inverse);
9132 vi->background_red = r;
9133 vi->background_green = g;
9134 vi->background_blue = b;
9137 else /* Do not expect any background processing */
9138 vi->do_background = 0;
9140 if (vi->do_background == 0)
9141 vi->background_red = vi->background_green = vi->background_blue = 0;
9143 vi->gamma_correction = 1/(dp->file_gamma*dp->screen_gamma);
9144 if (fabs(vi->gamma_correction-1) < PNG_GAMMA_THRESHOLD)
9145 vi->gamma_correction = 0;
9147 vi->file_inverse = 1/dp->file_gamma;
9148 if (fabs(vi->file_inverse-1) < PNG_GAMMA_THRESHOLD)
9149 vi->file_inverse = 0;
9151 vi->scale16 = dp->scale16;
9154 /* This function handles composition of a single non-alpha component. The
9155 * argument is the input sample value, in the range 0..1, and the alpha value.
9156 * The result is the composed, linear, input sample. If alpha is less than zero
9157 * this is the alpha component and the function should not be called!
9160 gamma_component_compose(int do_background, double input_sample, double alpha,
9161 double background, int *compose)
9163 switch (do_background)
9165 #ifdef PNG_READ_BACKGROUND_SUPPORTED
9166 case PNG_BACKGROUND_GAMMA_SCREEN:
9167 case PNG_BACKGROUND_GAMMA_FILE:
9168 case PNG_BACKGROUND_GAMMA_UNIQUE:
9169 /* Standard PNG background processing. */
9174 input_sample = input_sample * alpha + background * (1-alpha);
9175 if (compose != NULL)
9180 input_sample = background;
9185 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9186 case ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD:
9187 case ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN:
9188 /* The components are premultiplied in either case and the output is
9189 * gamma encoded (to get standard Porter-Duff we expect the output
9190 * gamma to be set to 1.0!)
9192 case ALPHA_MODE_OFFSET + PNG_ALPHA_OPTIMIZED:
9193 /* The optimization is that the partial-alpha entries are linear
9194 * while the opaque pixels are gamma encoded, but this only affects the
9201 input_sample *= alpha;
9202 if (compose != NULL)
9213 /* Standard cases where no compositing is done (so the component
9214 * value is already correct.)
9222 return input_sample;
9225 /* This API returns the encoded *input* component, in the range 0..1 */
9227 gamma_component_validate(const char *name, const validate_info *vi,
9228 const unsigned int id, const unsigned int od,
9229 const double alpha /* <0 for the alpha channel itself */,
9230 const double background /* component background value */)
9232 const unsigned int isbit = id >> vi->isbit_shift;
9233 const unsigned int sbit_max = vi->sbit_max;
9234 const unsigned int outmax = vi->outmax;
9235 const int do_background = vi->do_background;
9239 /* First check on the 'perfect' result obtained from the digitized input
9240 * value, id, and compare this against the actual digitized result, 'od'.
9241 * 'i' is the input result in the range 0..1:
9243 i = isbit; i /= sbit_max;
9245 /* Check for the fast route: if we don't do any background composition or if
9246 * this is the alpha channel ('alpha' < 0) or if the pixel is opaque then
9247 * just use the gamma_correction field to correct to the final output gamma.
9249 if (alpha == 1 /* opaque pixel component */ || !do_background
9250 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9251 || do_background == ALPHA_MODE_OFFSET + PNG_ALPHA_PNG
9253 || (alpha < 0 /* alpha channel */
9254 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9255 && do_background != ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN
9259 /* Then get the gamma corrected version of 'i' and compare to 'od', any
9260 * error less than .5 is insignificant - just quantization of the output
9261 * value to the nearest digital value (nevertheless the error is still
9262 * recorded - it's interesting ;-)
9264 double encoded_sample = i;
9265 double encoded_error;
9267 /* alpha less than 0 indicates the alpha channel, which is always linear
9269 if (alpha >= 0 && vi->gamma_correction > 0)
9270 encoded_sample = pow(encoded_sample, vi->gamma_correction);
9271 encoded_sample *= outmax;
9273 encoded_error = fabs(od-encoded_sample);
9275 if (encoded_error > vi->dp->maxerrout)
9276 vi->dp->maxerrout = encoded_error;
9278 if (encoded_error < vi->maxout_total && encoded_error < vi->outlog)
9282 /* The slow route - attempt to do linear calculations. */
9283 /* There may be an error, or background processing is required, so calculate
9284 * the actual sample values - unencoded light intensity values. Note that in
9285 * practice these are not completely unencoded because they include a
9286 * 'viewing correction' to decrease or (normally) increase the perceptual
9287 * contrast of the image. There's nothing we can do about this - we don't
9288 * know what it is - so assume the unencoded value is perceptually linear.
9291 double input_sample = i; /* In range 0..1 */
9292 double output, error, encoded_sample, encoded_error;
9293 double es_lo, es_hi;
9294 int compose = 0; /* Set to one if composition done */
9295 int output_is_encoded; /* Set if encoded to screen gamma */
9296 int log_max_error = 1; /* Check maximum error values */
9297 png_const_charp pass = 0; /* Reason test passes (or 0 for fail) */
9299 /* Convert to linear light (with the above caveat.) The alpha channel is
9306 if (vi->file_inverse > 0)
9307 input_sample = pow(input_sample, vi->file_inverse);
9309 /* Handle the compose processing: */
9311 input_sample = gamma_component_compose(do_background, input_sample,
9312 alpha, background, &tcompose);
9318 /* And similarly for the output value, but we need to check the background
9319 * handling to linearize it correctly.
9324 output_is_encoded = vi->screen_gamma > 0;
9326 if (alpha < 0) /* The alpha channel */
9328 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9329 if (do_background != ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN)
9332 /* In all other cases the output alpha channel is linear already,
9333 * don't log errors here, they are much larger in linear data.
9335 output_is_encoded = 0;
9340 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9341 else /* A component */
9343 if (do_background == ALPHA_MODE_OFFSET + PNG_ALPHA_OPTIMIZED &&
9344 alpha < 1) /* the optimized case - linear output */
9346 if (alpha > 0) log_max_error = 0;
9347 output_is_encoded = 0;
9352 if (output_is_encoded)
9353 output = pow(output, vi->screen_gamma);
9355 /* Calculate (or recalculate) the encoded_sample value and repeat the
9356 * check above (unnecessary if we took the fast route, but harmless.)
9358 encoded_sample = input_sample;
9359 if (output_is_encoded)
9360 encoded_sample = pow(encoded_sample, vi->screen_inverse);
9361 encoded_sample *= outmax;
9363 encoded_error = fabs(od-encoded_sample);
9365 /* Don't log errors in the alpha channel, or the 'optimized' case,
9366 * neither are significant to the overall perception.
9368 if (log_max_error && encoded_error > vi->dp->maxerrout)
9369 vi->dp->maxerrout = encoded_error;
9371 if (encoded_error < vi->maxout_total)
9373 if (encoded_error < vi->outlog)
9376 /* Test passed but error is bigger than the log limit, record why the
9379 pass = "less than maxout:\n";
9382 /* i: the original input value in the range 0..1
9384 * pngvalid calculations:
9385 * input_sample: linear result; i linearized and composed, range 0..1
9386 * encoded_sample: encoded result; input_sample scaled to ouput bit depth
9388 * libpng calculations:
9389 * output: linear result; od scaled to 0..1 and linearized
9390 * od: encoded result from libpng
9393 /* Now we have the numbers for real errors, both absolute values as as a
9394 * percentage of the correct value (output):
9396 error = fabs(input_sample-output);
9398 if (log_max_error && error > vi->dp->maxerrabs)
9399 vi->dp->maxerrabs = error;
9401 /* The following is an attempt to ignore the tendency of quantization to
9402 * dominate the percentage errors for lower result values:
9404 if (log_max_error && input_sample > .5)
9406 double percentage_error = error/input_sample;
9407 if (percentage_error > vi->dp->maxerrpc)
9408 vi->dp->maxerrpc = percentage_error;
9411 /* Now calculate the digitization limits for 'encoded_sample' using the
9412 * 'max' values. Note that maxout is in the encoded space but maxpc and
9413 * maxabs are in linear light space.
9415 * First find the maximum error in linear light space, range 0..1:
9418 double tmp = input_sample * vi->maxpc;
9419 if (tmp < vi->maxabs) tmp = vi->maxabs;
9420 /* If 'compose' is true the composition was done in linear space using
9421 * integer arithmetic. This introduces an extra error of +/- 0.5 (at
9422 * least) in the integer space used. 'maxcalc' records this, taking
9423 * into account the possibility that even for 16 bit output 8 bit space
9424 * may have been used.
9426 if (compose && tmp < vi->maxcalc) tmp = vi->maxcalc;
9428 /* The 'maxout' value refers to the encoded result, to compare with
9429 * this encode input_sample adjusted by the maximum error (tmp) above.
9431 es_lo = encoded_sample - vi->maxout;
9433 if (es_lo > 0 && input_sample-tmp > 0)
9435 double low_value = input_sample-tmp;
9436 if (output_is_encoded)
9437 low_value = pow(low_value, vi->screen_inverse);
9438 low_value *= outmax;
9439 if (low_value < es_lo) es_lo = low_value;
9441 /* Quantize this appropriately: */
9442 es_lo = ceil(es_lo / vi->outquant - .5) * vi->outquant;
9448 es_hi = encoded_sample + vi->maxout;
9450 if (es_hi < outmax && input_sample+tmp < 1)
9452 double high_value = input_sample+tmp;
9453 if (output_is_encoded)
9454 high_value = pow(high_value, vi->screen_inverse);
9455 high_value *= outmax;
9456 if (high_value > es_hi) es_hi = high_value;
9458 es_hi = floor(es_hi / vi->outquant + .5) * vi->outquant;
9465 /* The primary test is that the final encoded value returned by the
9466 * library should be between the two limits (inclusive) that were
9469 if (od >= es_lo && od <= es_hi)
9471 /* The value passes, but we may need to log the information anyway. */
9472 if (encoded_error < vi->outlog)
9476 pass = "within digitization limits:\n";
9480 /* There has been an error in processing, or we need to log this
9483 double is_lo, is_hi;
9485 /* pass is set at this point if either of the tests above would have
9486 * passed. Don't do these additional tests here - just log the
9487 * original [es_lo..es_hi] values.
9489 if (pass == 0 && vi->use_input_precision && vi->dp->sbit)
9491 /* Ok, something is wrong - this actually happens in current libpng
9492 * 16-to-8 processing. Assume that the input value (id, adjusted
9493 * for sbit) can be anywhere between value-.5 and value+.5 - quite a
9494 * large range if sbit is low.
9496 * NOTE: at present because the libpng gamma table stuff has been
9497 * changed to use a rounding algorithm to correct errors in 8-bit
9498 * calculations the precise sbit calculation (a shift) has been
9499 * lost. This can result in up to a +/-1 error in the presence of
9500 * an sbit less than the bit depth.
9502 # if PNG_LIBPNG_VER < 10700
9503 # define SBIT_ERROR .5
9505 # define SBIT_ERROR 1.
9507 double tmp = (isbit - SBIT_ERROR)/sbit_max;
9512 else if (alpha >= 0 && vi->file_inverse > 0 && tmp < 1)
9513 tmp = pow(tmp, vi->file_inverse);
9515 tmp = gamma_component_compose(do_background, tmp, alpha, background,
9518 if (output_is_encoded && tmp > 0 && tmp < 1)
9519 tmp = pow(tmp, vi->screen_inverse);
9521 is_lo = ceil(outmax * tmp - vi->maxout_total);
9526 tmp = (isbit + SBIT_ERROR)/sbit_max;
9531 else if (alpha >= 0 && vi->file_inverse > 0 && tmp < 1)
9532 tmp = pow(tmp, vi->file_inverse);
9534 tmp = gamma_component_compose(do_background, tmp, alpha, background,
9537 if (output_is_encoded && tmp > 0 && tmp < 1)
9538 tmp = pow(tmp, vi->screen_inverse);
9540 is_hi = floor(outmax * tmp + vi->maxout_total);
9545 if (!(od < is_lo || od > is_hi))
9547 if (encoded_error < vi->outlog)
9550 pass = "within input precision limits:\n";
9553 /* One last chance. If this is an alpha channel and the 16to8
9554 * option has been used and 'inaccurate' scaling is used then the
9555 * bit reduction is obtained by simply using the top 8 bits of the
9558 * This is only done for older libpng versions when the 'inaccurate'
9559 * (chop) method of scaling was used.
9561 # ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
9562 # if PNG_LIBPNG_VER < 10504
9563 /* This may be required for other components in the future,
9564 * but at present the presence of gamma correction effectively
9565 * prevents the errors in the component scaling (I don't quite
9566 * understand why, but since it's better this way I care not
9567 * to ask, JB 20110419.)
9569 if (pass == 0 && alpha < 0 && vi->scale16 && vi->sbit > 8 &&
9570 vi->sbit + vi->isbit_shift == 16)
9572 tmp = ((id >> 8) - .5)/255;
9576 is_lo = ceil(outmax * tmp - vi->maxout_total);
9577 if (is_lo < 0) is_lo = 0;
9583 tmp = ((id >> 8) + .5)/255;
9587 is_hi = floor(outmax * tmp + vi->maxout_total);
9588 if (is_hi > outmax) is_hi = outmax;
9594 if (!(od < is_lo || od > is_hi))
9596 if (encoded_error < vi->outlog)
9599 pass = "within 8 bit limits:\n";
9605 else /* !use_input_precision */
9606 is_lo = es_lo, is_hi = es_hi;
9608 /* Attempt to output a meaningful error/warning message: the message
9609 * output depends on the background/composite operation being performed
9610 * because this changes what parameters were actually used above.
9614 /* Need either 1/255 or 1/65535 precision here; 3 or 6 decimal
9615 * places. Just use outmax to work out which.
9617 int precision = (outmax >= 1000 ? 6 : 3);
9618 int use_input=1, use_background=0, do_compose=0;
9622 pos = safecat(msg, sizeof msg, pos, "\n\t");
9624 /* Set up the various flags, the output_is_encoded flag above
9625 * is also used below. do_compose is just a double check.
9627 switch (do_background)
9629 # ifdef PNG_READ_BACKGROUND_SUPPORTED
9630 case PNG_BACKGROUND_GAMMA_SCREEN:
9631 case PNG_BACKGROUND_GAMMA_FILE:
9632 case PNG_BACKGROUND_GAMMA_UNIQUE:
9633 use_background = (alpha >= 0 && alpha < 1);
9636 # ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9637 case ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD:
9638 case ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN:
9639 case ALPHA_MODE_OFFSET + PNG_ALPHA_OPTIMIZED:
9640 # endif /* ALPHA_MODE_SUPPORTED */
9641 do_compose = (alpha > 0 && alpha < 1);
9642 use_input = (alpha != 0);
9649 /* Check the 'compose' flag */
9650 if (compose != do_compose)
9651 png_error(vi->pp, "internal error (compose)");
9653 /* 'name' is the component name */
9654 pos = safecat(msg, sizeof msg, pos, name);
9655 pos = safecat(msg, sizeof msg, pos, "(");
9656 pos = safecatn(msg, sizeof msg, pos, id);
9657 if (use_input || pass != 0/*logging*/)
9661 /* sBIT has reduced the precision of the input: */
9662 pos = safecat(msg, sizeof msg, pos, ", sbit(");
9663 pos = safecatn(msg, sizeof msg, pos, vi->sbit);
9664 pos = safecat(msg, sizeof msg, pos, "): ");
9665 pos = safecatn(msg, sizeof msg, pos, isbit);
9667 pos = safecat(msg, sizeof msg, pos, "/");
9668 /* The output is either "id/max" or "id sbit(sbit): isbit/max" */
9669 pos = safecatn(msg, sizeof msg, pos, vi->sbit_max);
9671 pos = safecat(msg, sizeof msg, pos, ")");
9673 /* A component may have been multiplied (in linear space) by the
9674 * alpha value, 'compose' says whether this is relevant.
9676 if (compose || pass != 0)
9678 /* If any form of composition is being done report our
9679 * calculated linear value here (the code above doesn't record
9680 * the input value before composition is performed, so what
9681 * gets reported is the value after composition.)
9683 if (use_input || pass != 0)
9685 if (vi->file_inverse > 0)
9687 pos = safecat(msg, sizeof msg, pos, "^");
9688 pos = safecatd(msg, sizeof msg, pos, vi->file_inverse, 2);
9692 pos = safecat(msg, sizeof msg, pos, "[linear]");
9694 pos = safecat(msg, sizeof msg, pos, "*(alpha)");
9695 pos = safecatd(msg, sizeof msg, pos, alpha, precision);
9698 /* Now record the *linear* background value if it was used
9699 * (this function is not passed the original, non-linear,
9700 * value but it is contained in the test name.)
9704 pos = safecat(msg, sizeof msg, pos, use_input ? "+" : " ");
9705 pos = safecat(msg, sizeof msg, pos, "(background)");
9706 pos = safecatd(msg, sizeof msg, pos, background, precision);
9707 pos = safecat(msg, sizeof msg, pos, "*");
9708 pos = safecatd(msg, sizeof msg, pos, 1-alpha, precision);
9712 /* Report the calculated value (input_sample) and the linearized
9713 * libpng value (output) unless this is just a component gamma
9716 if (compose || alpha < 0 || pass != 0)
9718 pos = safecat(msg, sizeof msg, pos,
9719 pass != 0 ? " =\n\t" : " = ");
9720 pos = safecatd(msg, sizeof msg, pos, input_sample, precision);
9721 pos = safecat(msg, sizeof msg, pos, " (libpng: ");
9722 pos = safecatd(msg, sizeof msg, pos, output, precision);
9723 pos = safecat(msg, sizeof msg, pos, ")");
9725 /* Finally report the output gamma encoding, if any. */
9726 if (output_is_encoded)
9728 pos = safecat(msg, sizeof msg, pos, " ^");
9729 pos = safecatd(msg, sizeof msg, pos, vi->screen_inverse, 2);
9730 pos = safecat(msg, sizeof msg, pos, "(to screen) =");
9734 pos = safecat(msg, sizeof msg, pos, " [screen is linear] =");
9737 if ((!compose && alpha >= 0) || pass != 0)
9739 if (pass != 0) /* logging */
9740 pos = safecat(msg, sizeof msg, pos, "\n\t[overall:");
9742 /* This is the non-composition case, the internal linear
9743 * values are irrelevant (though the log below will reveal
9744 * them.) Output a much shorter warning/error message and report
9745 * the overall gamma correction.
9747 if (vi->gamma_correction > 0)
9749 pos = safecat(msg, sizeof msg, pos, " ^");
9750 pos = safecatd(msg, sizeof msg, pos, vi->gamma_correction, 2);
9751 pos = safecat(msg, sizeof msg, pos, "(gamma correction) =");
9755 pos = safecat(msg, sizeof msg, pos,
9756 " [no gamma correction] =");
9759 pos = safecat(msg, sizeof msg, pos, "]");
9762 /* This is our calculated encoded_sample which should (but does
9765 pos = safecat(msg, sizeof msg, pos, pass != 0 ? "\n\t" : " ");
9766 pos = safecatd(msg, sizeof msg, pos, is_lo, 1);
9767 pos = safecat(msg, sizeof msg, pos, " < ");
9768 pos = safecatd(msg, sizeof msg, pos, encoded_sample, 1);
9769 pos = safecat(msg, sizeof msg, pos, " (libpng: ");
9770 pos = safecatn(msg, sizeof msg, pos, od);
9771 pos = safecat(msg, sizeof msg, pos, ")");
9772 pos = safecat(msg, sizeof msg, pos, "/");
9773 pos = safecatn(msg, sizeof msg, pos, outmax);
9774 pos = safecat(msg, sizeof msg, pos, " < ");
9775 pos = safecatd(msg, sizeof msg, pos, is_hi, 1);
9777 if (pass == 0) /* The error condition */
9779 # ifdef PNG_WARNINGS_SUPPORTED
9780 png_warning(vi->pp, msg);
9782 store_warning(vi->pp, msg);
9786 else /* logging this value */
9787 store_verbose(&vi->dp->pm->this, vi->pp, pass, msg);
9796 gamma_image_validate(gamma_display *dp, png_const_structp pp,
9799 /* Get some constants derived from the input and output file formats: */
9800 const png_store* const ps = dp->this.ps;
9801 const png_byte in_ct = dp->this.colour_type;
9802 const png_byte in_bd = dp->this.bit_depth;
9803 const png_uint_32 w = dp->this.w;
9804 const png_uint_32 h = dp->this.h;
9805 const size_t cbRow = dp->this.cbRow;
9806 const png_byte out_ct = png_get_color_type(pp, pi);
9807 const png_byte out_bd = png_get_bit_depth(pp, pi);
9809 /* There are three sources of error, firstly the quantization in the
9810 * file encoding, determined by sbit and/or the file depth, secondly
9811 * the output (screen) gamma and thirdly the output file encoding.
9813 * Since this API receives the screen and file gamma in double
9814 * precision it is possible to calculate an exact answer given an input
9815 * pixel value. Therefore we assume that the *input* value is exact -
9816 * sample/maxsample - calculate the corresponding gamma corrected
9817 * output to the limits of double precision arithmetic and compare with
9818 * what libpng returns.
9820 * Since the library must quantize the output to 8 or 16 bits there is
9821 * a fundamental limit on the accuracy of the output of +/-.5 - this
9822 * quantization limit is included in addition to the other limits
9823 * specified by the paramaters to the API. (Effectively, add .5
9826 * The behavior of the 'sbit' paramter is defined by section 12.5
9827 * (sample depth scaling) of the PNG spec. That section forces the
9828 * decoder to assume that the PNG values have been scaled if sBIT is
9831 * png-sample = floor( input-sample * (max-out/max-in) + .5);
9833 * This means that only a subset of the possible PNG values should
9834 * appear in the input. However, the spec allows the encoder to use a
9835 * variety of approximations to the above and doesn't require any
9836 * restriction of the values produced.
9838 * Nevertheless the spec requires that the upper 'sBIT' bits of the
9839 * value stored in a PNG file be the original sample bits.
9840 * Consequently the code below simply scales the top sbit bits by
9841 * (1<<sbit)-1 to obtain an original sample value.
9843 * Because there is limited precision in the input it is arguable that
9844 * an acceptable result is any valid result from input-.5 to input+.5.
9845 * The basic tests below do not do this, however if 'use_input_precision'
9846 * is set a subsequent test is performed above.
9848 const unsigned int samples_per_pixel = (out_ct & 2U) ? 3U : 1U;
9851 const store_palette_entry *in_palette = dp->this.palette;
9852 const int in_is_transparent = dp->this.is_transparent;
9854 int out_npalette = -1;
9855 int out_is_transparent = 0; /* Just refers to the palette case */
9856 store_palette out_palette;
9859 /* Check for row overwrite errors */
9860 store_image_check(dp->this.ps, pp, 0);
9862 /* Supply the input and output sample depths here - 8 for an indexed image,
9863 * otherwise the bit depth.
9865 init_validate_info(&vi, dp, pp, in_ct==3?8:in_bd, out_ct==3?8:out_bd);
9867 processing = (vi.gamma_correction > 0 && !dp->threshold_test)
9868 || in_bd != out_bd || in_ct != out_ct || vi.do_background;
9869 process_tRNS = dp->this.has_tRNS && vi.do_background;
9871 /* TODO: FIX THIS: MAJOR BUG! If the transformations all happen inside
9872 * the palette there is no way of finding out, because libpng fails to
9873 * update the palette on png_read_update_info. Indeed, libpng doesn't
9874 * even do the required work until much later, when it doesn't have any
9875 * info pointer. Oops. For the moment 'processing' is turned off if
9876 * out_ct is palette.
9878 if (in_ct == 3 && out_ct == 3)
9881 if (processing && out_ct == 3)
9882 out_is_transparent = read_palette(out_palette, &out_npalette, pp, pi);
9886 png_const_bytep pRow = store_image_row(ps, pp, 0, y);
9887 png_byte std[STANDARD_ROWMAX];
9889 transform_row(pp, std, in_ct, in_bd, y);
9897 double alpha = 1; /* serves as a flag value */
9899 /* Record the palette index for index images. */
9900 const unsigned int in_index =
9901 in_ct == 3 ? sample(std, 3, in_bd, x, 0, 0, 0) : 256;
9902 const unsigned int out_index =
9903 out_ct == 3 ? sample(std, 3, out_bd, x, 0, 0, 0) : 256;
9905 /* Handle input alpha - png_set_background will cause the output
9906 * alpha to disappear so there is nothing to check.
9908 if ((in_ct & PNG_COLOR_MASK_ALPHA) != 0 ||
9909 (in_ct == 3 && in_is_transparent))
9911 const unsigned int input_alpha = in_ct == 3 ?
9912 dp->this.palette[in_index].alpha :
9913 sample(std, in_ct, in_bd, x, samples_per_pixel, 0, 0);
9915 unsigned int output_alpha = 65536 /* as a flag value */;
9919 if (out_is_transparent)
9920 output_alpha = out_palette[out_index].alpha;
9923 else if ((out_ct & PNG_COLOR_MASK_ALPHA) != 0)
9924 output_alpha = sample(pRow, out_ct, out_bd, x,
9925 samples_per_pixel, 0, 0);
9927 if (output_alpha != 65536)
9928 alpha = gamma_component_validate("alpha", &vi, input_alpha,
9929 output_alpha, -1/*alpha*/, 0/*background*/);
9931 else /* no alpha in output */
9933 /* This is a copy of the calculation of 'i' above in order to
9934 * have the alpha value to use in the background calculation.
9936 alpha = input_alpha >> vi.isbit_shift;
9937 alpha /= vi.sbit_max;
9941 else if (process_tRNS)
9943 /* alpha needs to be set appropriately for this pixel, it is
9944 * currently 1 and needs to be 0 for an input pixel which matches
9945 * the values in tRNS.
9950 if (sample(std, in_ct, in_bd, x, 0, 0, 0) ==
9951 dp->this.transparent.red)
9956 if (sample(std, in_ct, in_bd, x, 0, 0, 0) ==
9957 dp->this.transparent.red &&
9958 sample(std, in_ct, in_bd, x, 1, 0, 0) ==
9959 dp->this.transparent.green &&
9960 sample(std, in_ct, in_bd, x, 2, 0, 0) ==
9961 dp->this.transparent.blue)
9970 /* Handle grayscale or RGB components. */
9971 if ((in_ct & PNG_COLOR_MASK_COLOR) == 0) /* grayscale */
9972 (void)gamma_component_validate("gray", &vi,
9973 sample(std, in_ct, in_bd, x, 0, 0, 0),
9974 sample(pRow, out_ct, out_bd, x, 0, 0, 0),
9975 alpha/*component*/, vi.background_red);
9976 else /* RGB or palette */
9978 (void)gamma_component_validate("red", &vi,
9979 in_ct == 3 ? in_palette[in_index].red :
9980 sample(std, in_ct, in_bd, x, 0, 0, 0),
9981 out_ct == 3 ? out_palette[out_index].red :
9982 sample(pRow, out_ct, out_bd, x, 0, 0, 0),
9983 alpha/*component*/, vi.background_red);
9985 (void)gamma_component_validate("green", &vi,
9986 in_ct == 3 ? in_palette[in_index].green :
9987 sample(std, in_ct, in_bd, x, 1, 0, 0),
9988 out_ct == 3 ? out_palette[out_index].green :
9989 sample(pRow, out_ct, out_bd, x, 1, 0, 0),
9990 alpha/*component*/, vi.background_green);
9992 (void)gamma_component_validate("blue", &vi,
9993 in_ct == 3 ? in_palette[in_index].blue :
9994 sample(std, in_ct, in_bd, x, 2, 0, 0),
9995 out_ct == 3 ? out_palette[out_index].blue :
9996 sample(pRow, out_ct, out_bd, x, 2, 0, 0),
9997 alpha/*component*/, vi.background_blue);
10002 else if (memcmp(std, pRow, cbRow) != 0)
10006 /* No transform is expected on the threshold tests. */
10007 sprintf(msg, "gamma: below threshold row %lu changed",
10010 png_error(pp, msg);
10012 } /* row (y) loop */
10014 dp->this.ps->validated = 1;
10017 static void PNGCBAPI
10018 gamma_end(png_structp ppIn, png_infop pi)
10020 png_const_structp pp = ppIn;
10021 gamma_display *dp = voidcast(gamma_display*, png_get_progressive_ptr(pp));
10023 if (!dp->this.speed)
10024 gamma_image_validate(dp, pp, pi);
10026 dp->this.ps->validated = 1;
10029 /* A single test run checking a gamma transformation.
10031 * maxabs: maximum absolute error as a fraction
10032 * maxout: maximum output error in the output units
10033 * maxpc: maximum percentage error (as a percentage)
10036 gamma_test(png_modifier *pmIn, const png_byte colour_typeIn,
10037 const png_byte bit_depthIn, const int palette_numberIn,
10038 const int interlace_typeIn,
10039 const double file_gammaIn, const double screen_gammaIn,
10040 const png_byte sbitIn, const int threshold_testIn,
10042 const int use_input_precisionIn, const int scale16In,
10043 const int expand16In, const int do_backgroundIn,
10044 const png_color_16 *bkgd_colorIn, double bkgd_gammaIn)
10047 context(&pmIn->this, fault);
10049 gamma_display_init(&d, pmIn, FILEID(colour_typeIn, bit_depthIn,
10050 palette_numberIn, interlace_typeIn, 0, 0, 0),
10051 file_gammaIn, screen_gammaIn, sbitIn,
10052 threshold_testIn, use_input_precisionIn, scale16In,
10053 expand16In, do_backgroundIn, bkgd_colorIn, bkgd_gammaIn);
10059 gama_modification gama_mod;
10060 srgb_modification srgb_mod;
10061 sbit_modification sbit_mod;
10063 /* For the moment don't use the png_modifier support here. */
10064 d.pm->encoding_counter = 0;
10065 modifier_set_encoding(d.pm); /* Just resets everything */
10066 d.pm->current_gamma = d.file_gamma;
10068 /* Make an appropriate modifier to set the PNG file gamma to the
10069 * given gamma value and the sBIT chunk to the given precision.
10071 d.pm->modifications = NULL;
10072 gama_modification_init(&gama_mod, d.pm, d.file_gamma);
10073 srgb_modification_init(&srgb_mod, d.pm, 127 /*delete*/);
10075 sbit_modification_init(&sbit_mod, d.pm, d.sbit);
10077 modification_reset(d.pm->modifications);
10079 /* Get a png_struct for reading the image. */
10080 pp = set_modifier_for_read(d.pm, &pi, d.this.id, name);
10081 standard_palette_init(&d.this);
10083 /* Introduce the correct read function. */
10084 if (d.pm->this.progressive)
10086 /* Share the row function with the standard implementation. */
10087 png_set_progressive_read_fn(pp, &d, gamma_info, progressive_row,
10090 /* Now feed data into the reader until we reach the end: */
10091 modifier_progressive_read(d.pm, pp, pi);
10095 /* modifier_read expects a png_modifier* */
10096 png_set_read_fn(pp, d.pm, modifier_read);
10098 /* Check the header values: */
10099 png_read_info(pp, pi);
10101 /* Process the 'info' requirements. Only one image is generated */
10102 gamma_info_imp(&d, pp, pi);
10104 sequential_row(&d.this, pp, pi, -1, 0);
10107 gamma_image_validate(&d, pp, pi);
10109 d.this.ps->validated = 1;
10112 modifier_reset(d.pm);
10114 if (d.pm->log && !d.threshold_test && !d.this.speed)
10115 fprintf(stderr, "%d bit %s %s: max error %f (%.2g, %2g%%)\n",
10116 d.this.bit_depth, colour_types[d.this.colour_type], name,
10117 d.maxerrout, d.maxerrabs, 100*d.maxerrpc);
10119 /* Log the summary values too. */
10120 if (d.this.colour_type == 0 || d.this.colour_type == 4)
10122 switch (d.this.bit_depth)
10128 if (d.maxerrout > d.pm->error_gray_2)
10129 d.pm->error_gray_2 = d.maxerrout;
10134 if (d.maxerrout > d.pm->error_gray_4)
10135 d.pm->error_gray_4 = d.maxerrout;
10140 if (d.maxerrout > d.pm->error_gray_8)
10141 d.pm->error_gray_8 = d.maxerrout;
10146 if (d.maxerrout > d.pm->error_gray_16)
10147 d.pm->error_gray_16 = d.maxerrout;
10152 png_error(pp, "bad bit depth (internal: 1)");
10156 else if (d.this.colour_type == 2 || d.this.colour_type == 6)
10158 switch (d.this.bit_depth)
10162 if (d.maxerrout > d.pm->error_color_8)
10163 d.pm->error_color_8 = d.maxerrout;
10169 if (d.maxerrout > d.pm->error_color_16)
10170 d.pm->error_color_16 = d.maxerrout;
10175 png_error(pp, "bad bit depth (internal: 2)");
10179 else if (d.this.colour_type == 3)
10181 if (d.maxerrout > d.pm->error_indexed)
10182 d.pm->error_indexed = d.maxerrout;
10187 modifier_reset(voidcast(png_modifier*,(void*)fault));
10190 static void gamma_threshold_test(png_modifier *pm, png_byte colour_type,
10191 png_byte bit_depth, int interlace_type, double file_gamma,
10192 double screen_gamma)
10196 pos = safecat(name, sizeof name, pos, "threshold ");
10197 pos = safecatd(name, sizeof name, pos, file_gamma, 3);
10198 pos = safecat(name, sizeof name, pos, "/");
10199 pos = safecatd(name, sizeof name, pos, screen_gamma, 3);
10201 (void)gamma_test(pm, colour_type, bit_depth, 0/*palette*/, interlace_type,
10202 file_gamma, screen_gamma, 0/*sBIT*/, 1/*threshold test*/, name,
10203 0 /*no input precision*/,
10204 0 /*no scale16*/, 0 /*no expand16*/, 0 /*no background*/, 0 /*hence*/,
10205 0 /*no background gamma*/);
10209 perform_gamma_threshold_tests(png_modifier *pm)
10211 png_byte colour_type = 0;
10212 png_byte bit_depth = 0;
10213 unsigned int palette_number = 0;
10215 /* Don't test more than one instance of each palette - it's pointless, in
10216 * fact this test is somewhat excessive since libpng doesn't make this
10217 * decision based on colour type or bit depth!
10219 * CHANGED: now test two palettes and, as a side effect, images with and
10222 while (next_format(&colour_type, &bit_depth, &palette_number,
10223 pm->test_lbg_gamma_threshold, pm->test_tRNS))
10224 if (palette_number < 2)
10226 double test_gamma = 1.0;
10227 while (test_gamma >= .4)
10229 /* There's little point testing the interlacing vs non-interlacing,
10230 * but this can be set from the command line.
10232 gamma_threshold_test(pm, colour_type, bit_depth, pm->interlace_type,
10233 test_gamma, 1/test_gamma);
10237 /* And a special test for sRGB */
10238 gamma_threshold_test(pm, colour_type, bit_depth, pm->interlace_type,
10246 static void gamma_transform_test(png_modifier *pm,
10247 const png_byte colour_type, const png_byte bit_depth,
10248 const int palette_number,
10249 const int interlace_type, const double file_gamma,
10250 const double screen_gamma, const png_byte sbit,
10251 const int use_input_precision, const int scale16)
10256 if (sbit != bit_depth && sbit != 0)
10258 pos = safecat(name, sizeof name, pos, "sbit(");
10259 pos = safecatn(name, sizeof name, pos, sbit);
10260 pos = safecat(name, sizeof name, pos, ") ");
10264 pos = safecat(name, sizeof name, pos, "gamma ");
10267 pos = safecat(name, sizeof name, pos, "16to8 ");
10269 pos = safecatd(name, sizeof name, pos, file_gamma, 3);
10270 pos = safecat(name, sizeof name, pos, "->");
10271 pos = safecatd(name, sizeof name, pos, screen_gamma, 3);
10273 gamma_test(pm, colour_type, bit_depth, palette_number, interlace_type,
10274 file_gamma, screen_gamma, sbit, 0, name, use_input_precision,
10275 scale16, pm->test_gamma_expand16, 0 , 0, 0);
10278 static void perform_gamma_transform_tests(png_modifier *pm)
10280 png_byte colour_type = 0;
10281 png_byte bit_depth = 0;
10282 unsigned int palette_number = 0;
10284 while (next_format(&colour_type, &bit_depth, &palette_number,
10285 pm->test_lbg_gamma_transform, pm->test_tRNS))
10289 for (i=0; i<pm->ngamma_tests; ++i) for (j=0; j<pm->ngamma_tests; ++j)
10292 gamma_transform_test(pm, colour_type, bit_depth, palette_number,
10293 pm->interlace_type, 1/pm->gammas[i], pm->gammas[j], 0/*sBIT*/,
10294 pm->use_input_precision, 0 /*do not scale16*/);
10302 static void perform_gamma_sbit_tests(png_modifier *pm)
10306 /* The only interesting cases are colour and grayscale, alpha is ignored here
10307 * for overall speed. Only bit depths where sbit is less than the bit depth
10310 for (sbit=pm->sbitlow; sbit<(1<<READ_BDHI); ++sbit)
10312 png_byte colour_type = 0, bit_depth = 0;
10313 unsigned int npalette = 0;
10315 while (next_format(&colour_type, &bit_depth, &npalette,
10316 pm->test_lbg_gamma_sbit, pm->test_tRNS))
10317 if ((colour_type & PNG_COLOR_MASK_ALPHA) == 0 &&
10318 ((colour_type == 3 && sbit < 8) ||
10319 (colour_type != 3 && sbit < bit_depth)))
10323 for (i=0; i<pm->ngamma_tests; ++i)
10327 for (j=0; j<pm->ngamma_tests; ++j) if (i != j)
10329 gamma_transform_test(pm, colour_type, bit_depth, npalette,
10330 pm->interlace_type, 1/pm->gammas[i], pm->gammas[j],
10331 sbit, pm->use_input_precision_sbit, 0 /*scale16*/);
10341 /* Note that this requires a 16 bit source image but produces 8 bit output, so
10342 * we only need the 16bit write support, but the 16 bit images are only
10343 * generated if DO_16BIT is defined.
10346 static void perform_gamma_scale16_tests(png_modifier *pm)
10348 # ifndef PNG_MAX_GAMMA_8
10349 # define PNG_MAX_GAMMA_8 11
10351 # if defined PNG_MAX_GAMMA_8 || PNG_LIBPNG_VER < 10700
10352 # define SBIT_16_TO_8 PNG_MAX_GAMMA_8
10354 # define SBIT_16_TO_8 16
10356 /* Include the alpha cases here. Note that sbit matches the internal value
10357 * used by the library - otherwise we will get spurious errors from the
10358 * internal sbit style approximation.
10360 * The threshold test is here because otherwise the 16 to 8 conversion will
10361 * proceed *without* gamma correction, and the tests above will fail (but not
10362 * by much) - this could be fixed, it only appears with the -g option.
10365 for (i=0; i<pm->ngamma_tests; ++i)
10367 for (j=0; j<pm->ngamma_tests; ++j)
10370 fabs(pm->gammas[j]/pm->gammas[i]-1) >= PNG_GAMMA_THRESHOLD)
10372 gamma_transform_test(pm, 0, 16, 0, pm->interlace_type,
10373 1/pm->gammas[i], pm->gammas[j], SBIT_16_TO_8,
10374 pm->use_input_precision_16to8, 1 /*scale16*/);
10379 gamma_transform_test(pm, 2, 16, 0, pm->interlace_type,
10380 1/pm->gammas[i], pm->gammas[j], SBIT_16_TO_8,
10381 pm->use_input_precision_16to8, 1 /*scale16*/);
10386 gamma_transform_test(pm, 4, 16, 0, pm->interlace_type,
10387 1/pm->gammas[i], pm->gammas[j], SBIT_16_TO_8,
10388 pm->use_input_precision_16to8, 1 /*scale16*/);
10393 gamma_transform_test(pm, 6, 16, 0, pm->interlace_type,
10394 1/pm->gammas[i], pm->gammas[j], SBIT_16_TO_8,
10395 pm->use_input_precision_16to8, 1 /*scale16*/);
10403 #endif /* 16 to 8 bit conversion */
10405 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
10406 defined(PNG_READ_ALPHA_MODE_SUPPORTED)
10407 static void gamma_composition_test(png_modifier *pm,
10408 const png_byte colour_type, const png_byte bit_depth,
10409 const int palette_number,
10410 const int interlace_type, const double file_gamma,
10411 const double screen_gamma,
10412 const int use_input_precision, const int do_background,
10413 const int expand_16)
10416 png_const_charp base;
10419 png_color_16 background;
10421 /* Make up a name and get an appropriate background gamma value. */
10422 switch (do_background)
10426 bg = 4; /* should not be used */
10428 case PNG_BACKGROUND_GAMMA_SCREEN:
10429 base = " bckg(Screen):";
10430 bg = 1/screen_gamma;
10432 case PNG_BACKGROUND_GAMMA_FILE:
10433 base = " bckg(File):";
10436 case PNG_BACKGROUND_GAMMA_UNIQUE:
10437 base = " bckg(Unique):";
10438 /* This tests the handling of a unique value, the math is such that the
10439 * value tends to be <1, but is neither screen nor file (even if they
10442 bg = (file_gamma + screen_gamma) / 3;
10444 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
10445 case ALPHA_MODE_OFFSET + PNG_ALPHA_PNG:
10446 base = " alpha(PNG)";
10447 bg = 4; /* should not be used */
10449 case ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD:
10450 base = " alpha(Porter-Duff)";
10451 bg = 4; /* should not be used */
10453 case ALPHA_MODE_OFFSET + PNG_ALPHA_OPTIMIZED:
10454 base = " alpha(Optimized)";
10455 bg = 4; /* should not be used */
10457 case ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN:
10458 base = " alpha(Broken)";
10459 bg = 4; /* should not be used */
10464 /* Use random background values - the background is always presented in the
10465 * output space (8 or 16 bit components).
10467 if (expand_16 || bit_depth == 16)
10469 png_uint_32 r = random_32();
10471 background.red = (png_uint_16)r;
10472 background.green = (png_uint_16)(r >> 16);
10474 background.blue = (png_uint_16)r;
10475 background.gray = (png_uint_16)(r >> 16);
10477 /* In earlier libpng versions, those where DIGITIZE is set, any background
10478 * gamma correction in the expand16 case was done using 8-bit gamma
10479 * correction tables, resulting in larger errors. To cope with those
10480 * cases use a 16-bit background value which will handle this gamma
10484 if (expand_16 && (do_background == PNG_BACKGROUND_GAMMA_UNIQUE ||
10485 do_background == PNG_BACKGROUND_GAMMA_FILE) &&
10486 fabs(bg*screen_gamma-1) > PNG_GAMMA_THRESHOLD)
10488 /* The background values will be looked up in an 8-bit table to do
10489 * the gamma correction, so only select values which are an exact
10490 * match for the 8-bit table entries:
10492 background.red = (png_uint_16)((background.red >> 8) * 257);
10493 background.green = (png_uint_16)((background.green >> 8) * 257);
10494 background.blue = (png_uint_16)((background.blue >> 8) * 257);
10495 background.gray = (png_uint_16)((background.gray >> 8) * 257);
10500 else /* 8 bit colors */
10502 png_uint_32 r = random_32();
10504 background.red = (png_byte)r;
10505 background.green = (png_byte)(r >> 8);
10506 background.blue = (png_byte)(r >> 16);
10507 background.gray = (png_byte)(r >> 24);
10510 background.index = 193; /* rgb(193,193,193) to detect errors */
10512 if (!(colour_type & PNG_COLOR_MASK_COLOR))
10514 /* Because, currently, png_set_background is always called with
10515 * 'need_expand' false in this case and because the gamma test itself
10516 * doesn't cause an expand to 8-bit for lower bit depths the colour must
10517 * be reduced to the correct range.
10520 background.gray &= (png_uint_16)((1U << bit_depth)-1);
10522 /* Grayscale input, we do not convert to RGB (TBD), so we must set the
10523 * background to gray - else libpng seems to fail.
10525 background.red = background.green = background.blue = background.gray;
10528 pos = safecat(name, sizeof name, pos, "gamma ");
10529 pos = safecatd(name, sizeof name, pos, file_gamma, 3);
10530 pos = safecat(name, sizeof name, pos, "->");
10531 pos = safecatd(name, sizeof name, pos, screen_gamma, 3);
10533 pos = safecat(name, sizeof name, pos, base);
10534 if (do_background < ALPHA_MODE_OFFSET)
10536 /* Include the background color and gamma in the name: */
10537 pos = safecat(name, sizeof name, pos, "(");
10538 /* This assumes no expand gray->rgb - the current code won't handle that!
10540 if (colour_type & PNG_COLOR_MASK_COLOR)
10542 pos = safecatn(name, sizeof name, pos, background.red);
10543 pos = safecat(name, sizeof name, pos, ",");
10544 pos = safecatn(name, sizeof name, pos, background.green);
10545 pos = safecat(name, sizeof name, pos, ",");
10546 pos = safecatn(name, sizeof name, pos, background.blue);
10549 pos = safecatn(name, sizeof name, pos, background.gray);
10550 pos = safecat(name, sizeof name, pos, ")^");
10551 pos = safecatd(name, sizeof name, pos, bg, 3);
10554 gamma_test(pm, colour_type, bit_depth, palette_number, interlace_type,
10555 file_gamma, screen_gamma, 0/*sBIT*/, 0, name, use_input_precision,
10556 0/*strip 16*/, expand_16, do_background, &background, bg);
10561 perform_gamma_composition_tests(png_modifier *pm, int do_background,
10564 png_byte colour_type = 0;
10565 png_byte bit_depth = 0;
10566 unsigned int palette_number = 0;
10568 /* Skip the non-alpha cases - there is no setting of a transparency colour at
10571 * TODO: incorrect; the palette case sets tRNS and, now RGB and gray do,
10572 * however the palette case fails miserably so is commented out below.
10574 while (next_format(&colour_type, &bit_depth, &palette_number,
10575 pm->test_lbg_gamma_composition, pm->test_tRNS))
10576 if ((colour_type & PNG_COLOR_MASK_ALPHA) != 0
10577 #if 0 /* TODO: FIXME */
10578 /*TODO: FIXME: this should work */
10579 || colour_type == 3
10581 || (colour_type != 3 && palette_number != 0))
10585 /* Don't skip the i==j case here - it's relevant. */
10586 for (i=0; i<pm->ngamma_tests; ++i) for (j=0; j<pm->ngamma_tests; ++j)
10588 gamma_composition_test(pm, colour_type, bit_depth, palette_number,
10589 pm->interlace_type, 1/pm->gammas[i], pm->gammas[j],
10590 pm->use_input_precision, do_background, expand_16);
10597 #endif /* READ_BACKGROUND || READ_ALPHA_MODE */
10600 init_gamma_errors(png_modifier *pm)
10602 /* Use -1 to catch tests that were not actually run */
10603 pm->error_gray_2 = pm->error_gray_4 = pm->error_gray_8 = -1.;
10604 pm->error_color_8 = -1.;
10605 pm->error_indexed = -1.;
10606 pm->error_gray_16 = pm->error_color_16 = -1.;
10610 print_one(const char *leader, double err)
10613 printf(" %s %.5f\n", leader, err);
10617 summarize_gamma_errors(png_modifier *pm, png_const_charp who, int low_bit_depth,
10623 printf("\nGamma correction with %s:\n", who);
10626 printf("\nBasic gamma correction:\n");
10630 print_one(" 2 bit gray: ", pm->error_gray_2);
10631 print_one(" 4 bit gray: ", pm->error_gray_4);
10632 print_one(" 8 bit gray: ", pm->error_gray_8);
10633 print_one(" 8 bit color:", pm->error_color_8);
10635 print_one(" indexed: ", pm->error_indexed);
10638 print_one("16 bit gray: ", pm->error_gray_16);
10639 print_one("16 bit color:", pm->error_color_16);
10645 perform_gamma_test(png_modifier *pm, int summary)
10647 /*TODO: remove this*/
10648 /* Save certain values for the temporary overrides below. */
10649 unsigned int calculations_use_input_precision =
10650 pm->calculations_use_input_precision;
10651 # ifdef PNG_READ_BACKGROUND_SUPPORTED
10652 double maxout8 = pm->maxout8;
10655 /* First some arbitrary no-transform tests: */
10656 if (!pm->this.speed && pm->test_gamma_threshold)
10658 perform_gamma_threshold_tests(pm);
10664 /* Now some real transforms. */
10665 if (pm->test_gamma_transform)
10670 printf("Gamma correction error summary\n\n");
10671 printf("The printed value is the maximum error in the pixel values\n");
10672 printf("calculated by the libpng gamma correction code. The error\n");
10673 printf("is calculated as the difference between the output pixel\n");
10674 printf("value (always an integer) and the ideal value from the\n");
10675 printf("libpng specification (typically not an integer).\n\n");
10677 printf("Expect this value to be less than .5 for 8 bit formats,\n");
10678 printf("less than 1 for formats with fewer than 8 bits and a small\n");
10679 printf("number (typically less than 5) for the 16 bit formats.\n");
10680 printf("For performance reasons the value for 16 bit formats\n");
10681 printf("increases when the image file includes an sBIT chunk.\n");
10685 init_gamma_errors(pm);
10686 /*TODO: remove this. Necessary because the current libpng
10687 * implementation works in 8 bits:
10689 if (pm->test_gamma_expand16)
10690 pm->calculations_use_input_precision = 1;
10691 perform_gamma_transform_tests(pm);
10692 if (!calculations_use_input_precision)
10693 pm->calculations_use_input_precision = 0;
10696 summarize_gamma_errors(pm, 0/*who*/, 1/*low bit depth*/, 1/*indexed*/);
10702 /* The sbit tests produce much larger errors: */
10703 if (pm->test_gamma_sbit)
10705 init_gamma_errors(pm);
10706 perform_gamma_sbit_tests(pm);
10709 summarize_gamma_errors(pm, "sBIT", pm->sbitlow < 8U, 1/*indexed*/);
10715 #ifdef DO_16BIT /* Should be READ_16BIT_SUPPORTED */
10716 if (pm->test_gamma_scale16)
10718 /* The 16 to 8 bit strip operations: */
10719 init_gamma_errors(pm);
10720 perform_gamma_scale16_tests(pm);
10725 printf("\nGamma correction with 16 to 8 bit reduction:\n");
10726 printf(" 16 bit gray: %.5f\n", pm->error_gray_16);
10727 printf(" 16 bit color: %.5f\n", pm->error_color_16);
10736 #ifdef PNG_READ_BACKGROUND_SUPPORTED
10737 if (pm->test_gamma_background)
10739 init_gamma_errors(pm);
10741 /*TODO: remove this. Necessary because the current libpng
10742 * implementation works in 8 bits:
10744 if (pm->test_gamma_expand16)
10746 pm->calculations_use_input_precision = 1;
10747 pm->maxout8 = .499; /* because the 16 bit background is smashed */
10749 perform_gamma_composition_tests(pm, PNG_BACKGROUND_GAMMA_UNIQUE,
10750 pm->test_gamma_expand16);
10751 if (!calculations_use_input_precision)
10752 pm->calculations_use_input_precision = 0;
10753 pm->maxout8 = maxout8;
10756 summarize_gamma_errors(pm, "background", 1, 0/*indexed*/);
10763 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
10764 if (pm->test_gamma_alpha_mode)
10768 init_gamma_errors(pm);
10770 /*TODO: remove this. Necessary because the current libpng
10771 * implementation works in 8 bits:
10773 if (pm->test_gamma_expand16)
10774 pm->calculations_use_input_precision = 1;
10775 for (do_background = ALPHA_MODE_OFFSET + PNG_ALPHA_STANDARD;
10776 do_background <= ALPHA_MODE_OFFSET + PNG_ALPHA_BROKEN && !fail(pm);
10778 perform_gamma_composition_tests(pm, do_background,
10779 pm->test_gamma_expand16);
10780 if (!calculations_use_input_precision)
10781 pm->calculations_use_input_precision = 0;
10784 summarize_gamma_errors(pm, "alpha mode", 1, 0/*indexed*/);
10791 #endif /* PNG_READ_GAMMA_SUPPORTED */
10792 #endif /* PNG_READ_SUPPORTED */
10794 /* INTERLACE MACRO VALIDATION */
10795 /* This is copied verbatim from the specification, it is simply the pass
10796 * number in which each pixel in each 8x8 tile appears. The array must
10797 * be indexed adam7[y][x] and notice that the pass numbers are based at
10798 * 1, not 0 - the base libpng uses.
10801 png_byte adam7[8][8] =
10803 { 1,6,4,6,2,6,4,6 },
10804 { 7,7,7,7,7,7,7,7 },
10805 { 5,6,5,6,5,6,5,6 },
10806 { 7,7,7,7,7,7,7,7 },
10807 { 3,6,4,6,3,6,4,6 },
10808 { 7,7,7,7,7,7,7,7 },
10809 { 5,6,5,6,5,6,5,6 },
10810 { 7,7,7,7,7,7,7,7 }
10813 /* This routine validates all the interlace support macros in png.h for
10814 * a variety of valid PNG widths and heights. It uses a number of similarly
10815 * named internal routines that feed off the above array.
10818 png_pass_start_row(int pass)
10822 for (y=0; y<8; ++y) for (x=0; x<8; ++x) if (adam7[y][x] == pass)
10828 png_pass_start_col(int pass)
10832 for (x=0; x<8; ++x) for (y=0; y<8; ++y) if (adam7[y][x] == pass)
10838 png_pass_row_shift(int pass)
10840 int x, y, base=(-1), inc=8;
10842 for (y=0; y<8; ++y) for (x=0; x<8; ++x) if (adam7[y][x] == pass)
10846 else if (base == y)
10848 else if (inc == y-base)
10851 inc = y-base, base=y;
10852 else if (inc != y-base)
10853 return 0xff; /* error - more than one 'inc' value! */
10856 if (base == (-1)) return 0xfe; /* error - no row in pass! */
10858 /* The shift is always 1, 2 or 3 - no pass has all the rows! */
10867 /* error - unrecognized 'inc' */
10868 return (inc << 8) + 0xfd;
10872 png_pass_col_shift(int pass)
10874 int x, y, base=(-1), inc=8;
10876 for (x=0; x<8; ++x) for (y=0; y<8; ++y) if (adam7[y][x] == pass)
10880 else if (base == x)
10882 else if (inc == x-base)
10885 inc = x-base, base=x;
10886 else if (inc != x-base)
10887 return 0xff; /* error - more than one 'inc' value! */
10890 if (base == (-1)) return 0xfe; /* error - no row in pass! */
10892 /* The shift is always 1, 2 or 3 - no pass has all the rows! */
10895 case 1: return 0; /* pass 7 has all the columns */
10902 /* error - unrecognized 'inc' */
10903 return (inc << 8) + 0xfd;
10907 png_row_from_pass_row(png_uint_32 yIn, int pass)
10909 /* By examination of the array: */
10912 case 0: return yIn * 8;
10913 case 1: return yIn * 8;
10914 case 2: return yIn * 8 + 4;
10915 case 3: return yIn * 4;
10916 case 4: return yIn * 4 + 2;
10917 case 5: return yIn * 2;
10918 case 6: return yIn * 2 + 1;
10922 return 0xff; /* bad pass number */
10926 png_col_from_pass_col(png_uint_32 xIn, int pass)
10928 /* By examination of the array: */
10931 case 0: return xIn * 8;
10932 case 1: return xIn * 8 + 4;
10933 case 2: return xIn * 4;
10934 case 3: return xIn * 4 + 2;
10935 case 4: return xIn * 2;
10936 case 5: return xIn * 2 + 1;
10937 case 6: return xIn;
10941 return 0xff; /* bad pass number */
10945 png_row_in_interlace_pass(png_uint_32 y, int pass)
10947 /* Is row 'y' in pass 'pass'? */
10951 for (x=0; x<8; ++x) if (adam7[y][x] == pass)
10958 png_col_in_interlace_pass(png_uint_32 x, int pass)
10960 /* Is column 'x' in pass 'pass'? */
10964 for (y=0; y<8; ++y) if (adam7[y][x] == pass)
10971 png_pass_rows(png_uint_32 height, int pass)
10973 png_uint_32 tiles = height>>3;
10974 png_uint_32 rows = 0;
10979 for (y=0; y<8; ++y) for (x=0; x<8; ++x) if (adam7[y][x] == pass)
10982 if (y < height) ++rows;
10983 break; /* i.e. break the 'x', column, loop. */
10990 png_pass_cols(png_uint_32 width, int pass)
10992 png_uint_32 tiles = width>>3;
10993 png_uint_32 cols = 0;
10998 for (x=0; x<8; ++x) for (y=0; y<8; ++y) if (adam7[y][x] == pass)
11001 if (x < width) ++cols;
11002 break; /* i.e. break the 'y', row, loop. */
11009 perform_interlace_macro_validation(void)
11011 /* The macros to validate, first those that depend only on pass:
11013 * PNG_PASS_START_ROW(pass)
11014 * PNG_PASS_START_COL(pass)
11015 * PNG_PASS_ROW_SHIFT(pass)
11016 * PNG_PASS_COL_SHIFT(pass)
11020 for (pass=0; pass<7; ++pass)
11022 png_uint_32 m, f, v;
11024 m = PNG_PASS_START_ROW(pass);
11025 f = png_pass_start_row(pass);
11028 fprintf(stderr, "PNG_PASS_START_ROW(%d) = %u != %x\n", pass, m, f);
11032 m = PNG_PASS_START_COL(pass);
11033 f = png_pass_start_col(pass);
11036 fprintf(stderr, "PNG_PASS_START_COL(%d) = %u != %x\n", pass, m, f);
11040 m = PNG_PASS_ROW_SHIFT(pass);
11041 f = png_pass_row_shift(pass);
11044 fprintf(stderr, "PNG_PASS_ROW_SHIFT(%d) = %u != %x\n", pass, m, f);
11048 m = PNG_PASS_COL_SHIFT(pass);
11049 f = png_pass_col_shift(pass);
11052 fprintf(stderr, "PNG_PASS_COL_SHIFT(%d) = %u != %x\n", pass, m, f);
11056 /* Macros that depend on the image or sub-image height too:
11058 * PNG_PASS_ROWS(height, pass)
11059 * PNG_PASS_COLS(width, pass)
11060 * PNG_ROW_FROM_PASS_ROW(yIn, pass)
11061 * PNG_COL_FROM_PASS_COL(xIn, pass)
11062 * PNG_ROW_IN_INTERLACE_PASS(y, pass)
11063 * PNG_COL_IN_INTERLACE_PASS(x, pass)
11067 /* First the base 0 stuff: */
11068 m = PNG_ROW_FROM_PASS_ROW(v, pass);
11069 f = png_row_from_pass_row(v, pass);
11072 fprintf(stderr, "PNG_ROW_FROM_PASS_ROW(%u, %d) = %u != %x\n",
11077 m = PNG_COL_FROM_PASS_COL(v, pass);
11078 f = png_col_from_pass_col(v, pass);
11081 fprintf(stderr, "PNG_COL_FROM_PASS_COL(%u, %d) = %u != %x\n",
11086 m = PNG_ROW_IN_INTERLACE_PASS(v, pass);
11087 f = png_row_in_interlace_pass(v, pass);
11090 fprintf(stderr, "PNG_ROW_IN_INTERLACE_PASS(%u, %d) = %u != %x\n",
11095 m = PNG_COL_IN_INTERLACE_PASS(v, pass);
11096 f = png_col_in_interlace_pass(v, pass);
11099 fprintf(stderr, "PNG_COL_IN_INTERLACE_PASS(%u, %d) = %u != %x\n",
11104 /* Then the base 1 stuff: */
11106 m = PNG_PASS_ROWS(v, pass);
11107 f = png_pass_rows(v, pass);
11110 fprintf(stderr, "PNG_PASS_ROWS(%u, %d) = %u != %x\n",
11115 m = PNG_PASS_COLS(v, pass);
11116 f = png_pass_cols(v, pass);
11119 fprintf(stderr, "PNG_PASS_COLS(%u, %d) = %u != %x\n",
11124 /* Move to the next v - the stepping algorithm starts skipping
11125 * values above 1024.
11129 if (v == PNG_UINT_31_MAX)
11133 if (v >= PNG_UINT_31_MAX)
11134 v = PNG_UINT_31_MAX-1;
11140 /* Test color encodings. These values are back-calculated from the published
11141 * chromaticities. The values are accurate to about 14 decimal places; 15 are
11142 * given. These values are much more accurate than the ones given in the spec,
11143 * which typically don't exceed 4 decimal places. This allows testing of the
11144 * libpng code to its theoretical accuracy of 4 decimal places. (If pngvalid
11145 * used the published errors the 'slack' permitted would have to be +/-.5E-4 or
11148 * The png_modifier code assumes that encodings[0] is sRGB and treats it
11149 * specially: do not change the first entry in this list!
11151 static const color_encoding test_encodings[] =
11153 /* sRGB: must be first in this list! */
11154 /*gamma:*/ { 1/2.2,
11155 /*red: */ { 0.412390799265959, 0.212639005871510, 0.019330818715592 },
11156 /*green:*/ { 0.357584339383878, 0.715168678767756, 0.119194779794626 },
11157 /*blue: */ { 0.180480788401834, 0.072192315360734, 0.950532152249660} },
11158 /* Kodak ProPhoto (wide gamut) */
11159 /*gamma:*/ { 1/1.6 /*approximate: uses 1.8 power law compared to sRGB 2.4*/,
11160 /*red: */ { 0.797760489672303, 0.288071128229293, 0.000000000000000 },
11161 /*green:*/ { 0.135185837175740, 0.711843217810102, 0.000000000000000 },
11162 /*blue: */ { 0.031349349581525, 0.000085653960605, 0.825104602510460} },
11163 /* Adobe RGB (1998) */
11164 /*gamma:*/ { 1/(2+51./256),
11165 /*red: */ { 0.576669042910131, 0.297344975250536, 0.027031361386412 },
11166 /*green:*/ { 0.185558237906546, 0.627363566255466, 0.070688852535827 },
11167 /*blue: */ { 0.188228646234995, 0.075291458493998, 0.991337536837639} },
11168 /* Adobe Wide Gamut RGB */
11169 /*gamma:*/ { 1/(2+51./256),
11170 /*red: */ { 0.716500716779386, 0.258728243040113, 0.000000000000000 },
11171 /*green:*/ { 0.101020574397477, 0.724682314948566, 0.051211818965388 },
11172 /*blue: */ { 0.146774385252705, 0.016589442011321, 0.773892783545073} },
11173 /* Fake encoding which selects just the green channel */
11174 /*gamma:*/ { 1.45/2.2, /* the 'Mac' gamma */
11175 /*red: */ { 0.716500716779386, 0.000000000000000, 0.000000000000000 },
11176 /*green:*/ { 0.101020574397477, 1.000000000000000, 0.051211818965388 },
11177 /*blue: */ { 0.146774385252705, 0.000000000000000, 0.773892783545073} },
11182 * This attempts to trap signals and escape without crashing. It needs a
11183 * context pointer so that it can throw an exception (call longjmp) to recover
11184 * from the condition; this is handled by making the png_modifier used by 'main'
11185 * into a global variable.
11187 static png_modifier pm;
11189 static void signal_handler(int signum)
11195 pos = safecat(msg, sizeof msg, pos, "caught signal: ");
11200 pos = safecat(msg, sizeof msg, pos, "abort");
11204 pos = safecat(msg, sizeof msg, pos, "floating point exception");
11208 pos = safecat(msg, sizeof msg, pos, "illegal instruction");
11212 pos = safecat(msg, sizeof msg, pos, "interrupt");
11216 pos = safecat(msg, sizeof msg, pos, "invalid memory access");
11220 pos = safecat(msg, sizeof msg, pos, "termination request");
11224 pos = safecat(msg, sizeof msg, pos, "unknown ");
11225 pos = safecatn(msg, sizeof msg, pos, signum);
11229 store_log(&pm.this, NULL/*png_structp*/, msg, 1/*error*/);
11231 /* And finally throw an exception so we can keep going, unless this is
11232 * SIGTERM in which case stop now.
11234 if (signum != SIGTERM)
11236 struct exception_context *the_exception_context =
11237 &pm.this.exception_context;
11247 int main(int argc, char **argv)
11249 int summary = 1; /* Print the error summary at the end */
11250 int memstats = 0; /* Print memory statistics at the end */
11252 /* Create the given output file on success: */
11253 const char *touch = NULL;
11255 /* This is an array of standard gamma values (believe it or not I've seen
11256 * every one of these mentioned somewhere.)
11258 * In the following list the most useful values are first!
11261 gammas[]={2.2, 1.0, 2.2/1.45, 1.8, 1.5, 2.4, 2.5, 2.62, 2.9};
11263 /* This records the command and arguments: */
11265 char command[1024];
11267 anon_context(&pm.this);
11269 gnu_volatile(summary)
11270 gnu_volatile(memstats)
11271 gnu_volatile(touch)
11273 /* Add appropriate signal handlers, just the ANSI specified ones: */
11274 signal(SIGABRT, signal_handler);
11275 signal(SIGFPE, signal_handler);
11276 signal(SIGILL, signal_handler);
11277 signal(SIGINT, signal_handler);
11278 signal(SIGSEGV, signal_handler);
11279 signal(SIGTERM, signal_handler);
11281 #ifdef HAVE_FEENABLEEXCEPT
11282 /* Only required to enable FP exceptions on platforms where they start off
11283 * disabled; this is not necessary but if it is not done pngvalid will likely
11284 * end up ignoring FP conditions that other platforms fault.
11286 feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
11289 modifier_init(&pm);
11291 /* Preallocate the image buffer, because we know how big it needs to be,
11292 * note that, for testing purposes, it is deliberately mis-aligned by tag
11293 * bytes either side. All rows have an additional five bytes of padding for
11294 * overwrite checking.
11296 store_ensure_image(&pm.this, NULL, 2, TRANSFORM_ROWMAX, TRANSFORM_HEIGHTMAX);
11298 /* Don't give argv[0], it's normally some horrible libtool string: */
11299 cp = safecat(command, sizeof command, cp, "pngvalid");
11301 /* Default to error on warning: */
11302 pm.this.treat_warnings_as_errors = 1;
11304 /* Default assume_16_bit_calculations appropriately; this tells the checking
11305 * code that 16-bit arithmetic is used for 8-bit samples when it would make a
11308 pm.assume_16_bit_calculations = PNG_LIBPNG_VER >= 10700;
11310 /* Currently 16 bit expansion happens at the end of the pipeline, so the
11311 * calculations are done in the input bit depth not the output.
11315 pm.calculations_use_input_precision = 1U;
11317 /* Store the test gammas */
11318 pm.gammas = gammas;
11319 pm.ngammas = ARRAY_SIZE(gammas);
11320 pm.ngamma_tests = 0; /* default to off */
11322 /* Low bit depth gray images don't do well in the gamma tests, until
11323 * this is fixed turn them off for some gamma cases:
11325 # ifdef PNG_WRITE_tRNS_SUPPORTED
11328 pm.test_lbg = PNG_LIBPNG_VER >= 10600;
11329 pm.test_lbg_gamma_threshold = 1;
11330 pm.test_lbg_gamma_transform = PNG_LIBPNG_VER >= 10600;
11331 pm.test_lbg_gamma_sbit = 1;
11332 pm.test_lbg_gamma_composition = PNG_LIBPNG_VER >= 10700;
11334 /* And the test encodings */
11335 pm.encodings = test_encodings;
11336 pm.nencodings = ARRAY_SIZE(test_encodings);
11338 # if PNG_LIBPNG_VER < 10700
11339 pm.sbitlow = 8U; /* because libpng doesn't do sBIT below 8! */
11344 /* The following allows results to pass if they correspond to anything in the
11345 * transformed range [input-.5,input+.5]; this is is required because of the
11346 * way libpng treates the 16_TO_8 flag when building the gamma tables in
11347 * releases up to 1.6.0.
11349 * TODO: review this
11351 pm.use_input_precision_16to8 = 1U;
11352 pm.use_input_precision_sbit = 1U; /* because libpng now rounds sBIT */
11354 /* Some default values (set the behavior for 'make check' here).
11355 * These values simply control the maximum error permitted in the gamma
11356 * transformations. The practial limits for human perception are described
11357 * below (the setting for maxpc16), however for 8 bit encodings it isn't
11358 * possible to meet the accepted capabilities of human vision - i.e. 8 bit
11359 * images can never be good enough, regardless of encoding.
11361 pm.maxout8 = .1; /* Arithmetic error in *encoded* value */
11362 pm.maxabs8 = .00005; /* 1/20000 */
11363 pm.maxcalc8 = 1./255; /* +/-1 in 8 bits for compose errors */
11364 pm.maxpc8 = .499; /* I.e., .499% fractional error */
11365 pm.maxout16 = .499; /* Error in *encoded* value */
11366 pm.maxabs16 = .00005;/* 1/20000 */
11367 pm.maxcalc16 =1./65535;/* +/-1 in 16 bits for compose errors */
11368 # if PNG_LIBPNG_VER < 10700
11369 pm.maxcalcG = 1./((1<<PNG_MAX_GAMMA_8)-1);
11371 pm.maxcalcG = 1./((1<<16)-1);
11374 /* NOTE: this is a reasonable perceptual limit. We assume that humans can
11375 * perceive light level differences of 1% over a 100:1 range, so we need to
11376 * maintain 1 in 10000 accuracy (in linear light space), which is what the
11377 * following guarantees. It also allows significantly higher errors at
11378 * higher 16 bit values, which is important for performance. The actual
11379 * maximum 16 bit error is about +/-1.9 in the fixed point implementation but
11380 * this is only allowed for values >38149 by the following:
11382 pm.maxpc16 = .005; /* I.e., 1/200% - 1/20000 */
11384 /* Now parse the command line options. */
11385 while (--argc >= 1)
11387 int catmore = 0; /* Set if the argument has an argument. */
11389 /* Record each argument for posterity: */
11390 cp = safecat(command, sizeof command, cp, " ");
11391 cp = safecat(command, sizeof command, cp, *++argv);
11393 if (strcmp(*argv, "-v") == 0)
11394 pm.this.verbose = 1;
11396 else if (strcmp(*argv, "-l") == 0)
11399 else if (strcmp(*argv, "-q") == 0)
11400 summary = pm.this.verbose = pm.log = 0;
11402 else if (strcmp(*argv, "-w") == 0 ||
11403 strcmp(*argv, "--strict") == 0)
11404 pm.this.treat_warnings_as_errors = 1; /* NOTE: this is the default! */
11406 else if (strcmp(*argv, "--nostrict") == 0)
11407 pm.this.treat_warnings_as_errors = 0;
11409 else if (strcmp(*argv, "--speed") == 0)
11410 pm.this.speed = 1, pm.ngamma_tests = pm.ngammas, pm.test_standard = 0,
11413 else if (strcmp(*argv, "--memory") == 0)
11416 else if (strcmp(*argv, "--size") == 0)
11419 else if (strcmp(*argv, "--nosize") == 0)
11422 else if (strcmp(*argv, "--standard") == 0)
11423 pm.test_standard = 1;
11425 else if (strcmp(*argv, "--nostandard") == 0)
11426 pm.test_standard = 0;
11428 else if (strcmp(*argv, "--transform") == 0)
11429 pm.test_transform = 1;
11431 else if (strcmp(*argv, "--notransform") == 0)
11432 pm.test_transform = 0;
11434 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
11435 else if (strncmp(*argv, "--transform-disable=",
11436 sizeof "--transform-disable") == 0)
11438 pm.test_transform = 1;
11439 transform_disable(*argv + sizeof "--transform-disable");
11442 else if (strncmp(*argv, "--transform-enable=",
11443 sizeof "--transform-enable") == 0)
11445 pm.test_transform = 1;
11446 transform_enable(*argv + sizeof "--transform-enable");
11448 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
11450 else if (strcmp(*argv, "--gamma") == 0)
11452 /* Just do two gamma tests here (2.2 and linear) for speed: */
11453 pm.ngamma_tests = 2U;
11454 pm.test_gamma_threshold = 1;
11455 pm.test_gamma_transform = 1;
11456 pm.test_gamma_sbit = 1;
11457 pm.test_gamma_scale16 = 1;
11458 pm.test_gamma_background = 1; /* composition */
11459 pm.test_gamma_alpha_mode = 1;
11462 else if (strcmp(*argv, "--nogamma") == 0)
11463 pm.ngamma_tests = 0;
11465 else if (strcmp(*argv, "--gamma-threshold") == 0)
11466 pm.ngamma_tests = 2U, pm.test_gamma_threshold = 1;
11468 else if (strcmp(*argv, "--nogamma-threshold") == 0)
11469 pm.test_gamma_threshold = 0;
11471 else if (strcmp(*argv, "--gamma-transform") == 0)
11472 pm.ngamma_tests = 2U, pm.test_gamma_transform = 1;
11474 else if (strcmp(*argv, "--nogamma-transform") == 0)
11475 pm.test_gamma_transform = 0;
11477 else if (strcmp(*argv, "--gamma-sbit") == 0)
11478 pm.ngamma_tests = 2U, pm.test_gamma_sbit = 1;
11480 else if (strcmp(*argv, "--nogamma-sbit") == 0)
11481 pm.test_gamma_sbit = 0;
11483 else if (strcmp(*argv, "--gamma-16-to-8") == 0)
11484 pm.ngamma_tests = 2U, pm.test_gamma_scale16 = 1;
11486 else if (strcmp(*argv, "--nogamma-16-to-8") == 0)
11487 pm.test_gamma_scale16 = 0;
11489 else if (strcmp(*argv, "--gamma-background") == 0)
11490 pm.ngamma_tests = 2U, pm.test_gamma_background = 1;
11492 else if (strcmp(*argv, "--nogamma-background") == 0)
11493 pm.test_gamma_background = 0;
11495 else if (strcmp(*argv, "--gamma-alpha-mode") == 0)
11496 pm.ngamma_tests = 2U, pm.test_gamma_alpha_mode = 1;
11498 else if (strcmp(*argv, "--nogamma-alpha-mode") == 0)
11499 pm.test_gamma_alpha_mode = 0;
11501 else if (strcmp(*argv, "--expand16") == 0)
11502 pm.test_gamma_expand16 = 1;
11504 else if (strcmp(*argv, "--noexpand16") == 0)
11505 pm.test_gamma_expand16 = 0;
11507 else if (strcmp(*argv, "--low-depth-gray") == 0)
11508 pm.test_lbg = pm.test_lbg_gamma_threshold =
11509 pm.test_lbg_gamma_transform = pm.test_lbg_gamma_sbit =
11510 pm.test_lbg_gamma_composition = 1;
11512 else if (strcmp(*argv, "--nolow-depth-gray") == 0)
11513 pm.test_lbg = pm.test_lbg_gamma_threshold =
11514 pm.test_lbg_gamma_transform = pm.test_lbg_gamma_sbit =
11515 pm.test_lbg_gamma_composition = 0;
11517 # ifdef PNG_WRITE_tRNS_SUPPORTED
11518 else if (strcmp(*argv, "--tRNS") == 0)
11522 else if (strcmp(*argv, "--notRNS") == 0)
11525 else if (strcmp(*argv, "--more-gammas") == 0)
11526 pm.ngamma_tests = 3U;
11528 else if (strcmp(*argv, "--all-gammas") == 0)
11529 pm.ngamma_tests = pm.ngammas;
11531 else if (strcmp(*argv, "--progressive-read") == 0)
11532 pm.this.progressive = 1;
11534 else if (strcmp(*argv, "--use-update-info") == 0)
11535 ++pm.use_update_info; /* Can call multiple times */
11537 else if (strcmp(*argv, "--interlace") == 0)
11539 # if CAN_WRITE_INTERLACE
11540 pm.interlace_type = PNG_INTERLACE_ADAM7;
11541 # else /* !CAN_WRITE_INTERLACE */
11542 fprintf(stderr, "pngvalid: no write interlace support\n");
11544 # endif /* !CAN_WRITE_INTERLACE */
11547 else if (strcmp(*argv, "--use-input-precision") == 0)
11548 pm.use_input_precision = 1U;
11550 else if (strcmp(*argv, "--use-calculation-precision") == 0)
11551 pm.use_input_precision = 0;
11553 else if (strcmp(*argv, "--calculations-use-input-precision") == 0)
11554 pm.calculations_use_input_precision = 1U;
11556 else if (strcmp(*argv, "--assume-16-bit-calculations") == 0)
11557 pm.assume_16_bit_calculations = 1U;
11559 else if (strcmp(*argv, "--calculations-follow-bit-depth") == 0)
11560 pm.calculations_use_input_precision =
11561 pm.assume_16_bit_calculations = 0;
11563 else if (strcmp(*argv, "--exhaustive") == 0)
11564 pm.test_exhaustive = 1;
11566 else if (argc > 1 && strcmp(*argv, "--sbitlow") == 0)
11567 --argc, pm.sbitlow = (png_byte)atoi(*++argv), catmore = 1;
11569 else if (argc > 1 && strcmp(*argv, "--touch") == 0)
11570 --argc, touch = *++argv, catmore = 1;
11572 else if (argc > 1 && strncmp(*argv, "--max", 5) == 0)
11576 if (strcmp(5+*argv, "abs8") == 0)
11577 pm.maxabs8 = atof(*++argv);
11579 else if (strcmp(5+*argv, "abs16") == 0)
11580 pm.maxabs16 = atof(*++argv);
11582 else if (strcmp(5+*argv, "calc8") == 0)
11583 pm.maxcalc8 = atof(*++argv);
11585 else if (strcmp(5+*argv, "calc16") == 0)
11586 pm.maxcalc16 = atof(*++argv);
11588 else if (strcmp(5+*argv, "out8") == 0)
11589 pm.maxout8 = atof(*++argv);
11591 else if (strcmp(5+*argv, "out16") == 0)
11592 pm.maxout16 = atof(*++argv);
11594 else if (strcmp(5+*argv, "pc8") == 0)
11595 pm.maxpc8 = atof(*++argv);
11597 else if (strcmp(5+*argv, "pc16") == 0)
11598 pm.maxpc16 = atof(*++argv);
11602 fprintf(stderr, "pngvalid: %s: unknown 'max' option\n", *argv);
11609 else if (strcmp(*argv, "--log8") == 0)
11610 --argc, pm.log8 = atof(*++argv), catmore = 1;
11612 else if (strcmp(*argv, "--log16") == 0)
11613 --argc, pm.log16 = atof(*++argv), catmore = 1;
11615 #ifdef PNG_SET_OPTION_SUPPORTED
11616 else if (strncmp(*argv, "--option=", 9) == 0)
11618 /* Syntax of the argument is <option>:{on|off} */
11619 const char *arg = 9+*argv;
11620 unsigned char option=0, setting=0;
11622 #ifdef PNG_ARM_NEON
11623 if (strncmp(arg, "arm-neon:", 9) == 0)
11624 option = PNG_ARM_NEON, arg += 9;
11628 #ifdef PNG_EXTENSIONS
11629 if (strncmp(arg, "extensions:", 11) == 0)
11630 option = PNG_EXTENSIONS, arg += 11;
11634 #ifdef PNG_MAXIMUM_INFLATE_WINDOW
11635 if (strncmp(arg, "max-inflate-window:", 19) == 0)
11636 option = PNG_MAXIMUM_INFLATE_WINDOW, arg += 19;
11641 fprintf(stderr, "pngvalid: %s: %s: unknown option\n", *argv, arg);
11645 if (strcmp(arg, "off") == 0)
11646 setting = PNG_OPTION_OFF;
11648 else if (strcmp(arg, "on") == 0)
11649 setting = PNG_OPTION_ON;
11654 "pngvalid: %s: %s: unknown setting (use 'on' or 'off')\n",
11659 pm.this.options[pm.this.noptions].option = option;
11660 pm.this.options[pm.this.noptions++].setting = setting;
11662 #endif /* PNG_SET_OPTION_SUPPORTED */
11666 fprintf(stderr, "pngvalid: %s: unknown argument\n", *argv);
11670 if (catmore) /* consumed an extra *argv */
11672 cp = safecat(command, sizeof command, cp, " ");
11673 cp = safecat(command, sizeof command, cp, *argv);
11677 /* If pngvalid is run with no arguments default to a reasonable set of the
11680 if (pm.test_standard == 0 && pm.test_size == 0 && pm.test_transform == 0 &&
11681 pm.ngamma_tests == 0)
11683 /* Make this do all the tests done in the test shell scripts with the same
11684 * parameters, where possible. The limitation is that all the progressive
11685 * read and interlace stuff has to be done in separate runs, so only the
11686 * basic 'standard' and 'size' tests are done.
11688 pm.test_standard = 1;
11690 pm.test_transform = 1;
11691 pm.ngamma_tests = 2U;
11694 if (pm.ngamma_tests > 0 &&
11695 pm.test_gamma_threshold == 0 && pm.test_gamma_transform == 0 &&
11696 pm.test_gamma_sbit == 0 && pm.test_gamma_scale16 == 0 &&
11697 pm.test_gamma_background == 0 && pm.test_gamma_alpha_mode == 0)
11699 pm.test_gamma_threshold = 1;
11700 pm.test_gamma_transform = 1;
11701 pm.test_gamma_sbit = 1;
11702 pm.test_gamma_scale16 = 1;
11703 pm.test_gamma_background = 1;
11704 pm.test_gamma_alpha_mode = 1;
11707 else if (pm.ngamma_tests == 0)
11709 /* Nothing to test so turn everything off: */
11710 pm.test_gamma_threshold = 0;
11711 pm.test_gamma_transform = 0;
11712 pm.test_gamma_sbit = 0;
11713 pm.test_gamma_scale16 = 0;
11714 pm.test_gamma_background = 0;
11715 pm.test_gamma_alpha_mode = 0;
11720 /* Make useful base images */
11721 make_transform_images(&pm);
11723 /* Perform the standard and gamma tests. */
11724 if (pm.test_standard)
11726 perform_interlace_macro_validation();
11727 perform_formatting_test(&pm.this);
11728 # ifdef PNG_READ_SUPPORTED
11729 perform_standard_test(&pm);
11731 perform_error_test(&pm);
11734 /* Various oddly sized images: */
11737 make_size_images(&pm.this);
11738 # ifdef PNG_READ_SUPPORTED
11739 perform_size_test(&pm);
11743 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
11744 /* Combinatorial transforms: */
11745 if (pm.test_transform)
11746 perform_transform_test(&pm);
11747 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
11749 #ifdef PNG_READ_GAMMA_SUPPORTED
11750 if (pm.ngamma_tests > 0)
11751 perform_gamma_test(&pm, summary);
11757 fprintf(stderr, "pngvalid: test aborted (probably failed in cleanup)\n");
11758 if (!pm.this.verbose)
11760 if (pm.this.error[0] != 0)
11761 fprintf(stderr, "pngvalid: first error: %s\n", pm.this.error);
11763 fprintf(stderr, "pngvalid: run with -v to see what happened\n");
11770 printf("%s: %s (%s point arithmetic)\n",
11771 (pm.this.nerrors || (pm.this.treat_warnings_as_errors &&
11772 pm.this.nwarnings)) ? "FAIL" : "PASS",
11774 #if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || PNG_LIBPNG_VER < 10500
11784 printf("Allocated memory statistics (in bytes):\n"
11785 "\tread %lu maximum single, %lu peak, %lu total\n"
11786 "\twrite %lu maximum single, %lu peak, %lu total\n",
11787 (unsigned long)pm.this.read_memory_pool.max_max,
11788 (unsigned long)pm.this.read_memory_pool.max_limit,
11789 (unsigned long)pm.this.read_memory_pool.max_total,
11790 (unsigned long)pm.this.write_memory_pool.max_max,
11791 (unsigned long)pm.this.write_memory_pool.max_limit,
11792 (unsigned long)pm.this.write_memory_pool.max_total);
11795 /* Do this here to provoke memory corruption errors in memory not directly
11796 * allocated by libpng - not a complete test, but better than nothing.
11798 store_delete(&pm.this);
11800 /* Error exit if there are any errors, and maybe if there are any
11803 if (pm.this.nerrors || (pm.this.treat_warnings_as_errors &&
11804 pm.this.nwarnings))
11806 if (!pm.this.verbose)
11807 fprintf(stderr, "pngvalid: %s\n", pm.this.error);
11809 fprintf(stderr, "pngvalid: %d errors, %d warnings\n", pm.this.nerrors,
11810 pm.this.nwarnings);
11815 /* Success case. */
11818 FILE *fsuccess = fopen(touch, "wt");
11820 if (fsuccess != NULL)
11823 fprintf(fsuccess, "PNG validation succeeded\n");
11825 error = ferror(fsuccess);
11827 if (fclose(fsuccess) || error)
11829 fprintf(stderr, "%s: write failed\n", touch);
11836 fprintf(stderr, "%s: open failed\n", touch);
11841 /* This is required because some very minimal configurations do not use it:
11846 #else /* write or low level APIs not supported */
11850 "pngvalid: no low level write support in libpng, all tests skipped\n");
11851 /* So the test is skipped: */