2 /* pngvalid.c - validate libpng by constructing then reading png files.
4 * Last changed in libpng 1.6.31 [July 27, 2017]
5 * Copyright (c) 2014-2017 John Cunningham Bowler
7 * This code is released under the libpng license.
8 * For conditions of distribution and use, see the disclaimer
12 * This is a C program that is intended to be linked against libpng. It
13 * generates bitmaps internally, stores them as PNG files (using the
14 * sequential write code) then reads them back (using the sequential
15 * read code) and validates that the result has the correct data.
17 * The program can be modified and extended to test the correctness of
18 * transformations performed by libpng.
21 #define _POSIX_SOURCE 1
22 #define _ISOC99_SOURCE 1 /* For floating point */
23 #define _GNU_SOURCE 1 /* For the floating point exception extension */
24 #define _BSD_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 && defined(HAVE_CONFIG_H)
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 after 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 /* Convenience macros. */
135 #define CHUNK(a,b,c,d) (((a)<<24)+((b)<<16)+((c)<<8)+(d))
136 #define CHUNK_IHDR CHUNK(73,72,68,82)
137 #define CHUNK_PLTE CHUNK(80,76,84,69)
138 #define CHUNK_IDAT CHUNK(73,68,65,84)
139 #define CHUNK_IEND CHUNK(73,69,78,68)
140 #define CHUNK_cHRM CHUNK(99,72,82,77)
141 #define CHUNK_gAMA CHUNK(103,65,77,65)
142 #define CHUNK_sBIT CHUNK(115,66,73,84)
143 #define CHUNK_sRGB CHUNK(115,82,71,66)
145 /* Unused formal parameter errors are removed using the following macro which is
146 * expected to have no bad effects on performance.
149 # if defined(__GNUC__) || defined(_MSC_VER)
150 # define UNUSED(param) (void)param;
152 # define UNUSED(param)
156 /***************************** EXCEPTION HANDLING *****************************/
157 #ifdef PNG_FREESTANDING_TESTS
158 # include <cexcept.h>
160 # include "../visupng/cexcept.h"
164 # define this not_the_cpp_this
165 # define new not_the_cpp_new
166 # define voidcast(type, value) static_cast<type>(value)
168 # define voidcast(type, value) (value)
169 #endif /* __cplusplus */
172 define_exception_type(struct png_store
*);
174 /* The following are macros to reduce typing everywhere where the well known
175 * name 'the_exception_context' must be defined.
177 #define anon_context(ps) struct exception_context *the_exception_context = \
178 &(ps)->exception_context
179 #define context(ps,fault) anon_context(ps); png_store *fault
181 /* This macro returns the number of elements in an array as an (unsigned int),
182 * it is necessary to avoid the inability of certain versions of GCC to use
183 * the value of a compile-time constant when performing range checks. It must
184 * be passed an array name.
186 #define ARRAY_SIZE(a) ((unsigned int)((sizeof (a))/(sizeof (a)[0])))
188 /* GCC BUG 66447 (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66447) requires
189 * some broken GCC versions to be fixed up to avoid invalid whining about auto
190 * variables that are *not* changed within the scope of a setjmp being changed.
192 * Feel free to extend the list of broken versions.
194 #define is_gnu(major,minor)\
195 (defined __GNUC__) && __GNUC__ == (major) && __GNUC_MINOR__ == (minor)
196 #define is_gnu_patch(major,minor,patch)\
197 is_gnu(major,minor) && __GNUC_PATCHLEVEL__ == 0
198 /* For the moment just do it always; all versions of GCC seem to be broken: */
200 const void * volatile make_volatile_for_gnu
;
201 # define gnu_volatile(x) make_volatile_for_gnu = &x;
202 #else /* !GNUC broken versions */
203 # define gnu_volatile(x)
204 #endif /* !GNUC broken versions */
206 /******************************* UTILITIES ************************************/
207 /* Error handling is particularly problematic in production code - error
208 * handlers often themselves have bugs which lead to programs that detect
209 * minor errors crashing. The following functions deal with one very
210 * common class of errors in error handlers - attempting to format error or
211 * warning messages into buffers that are too small.
213 static size_t safecat(char *buffer
, size_t bufsize
, size_t pos
,
216 while (pos
< bufsize
&& cat
!= NULL
&& *cat
!= 0)
217 buffer
[pos
++] = *cat
++;
226 static size_t safecatn(char *buffer
, size_t bufsize
, size_t pos
, int n
)
229 sprintf(number
, "%d", n
);
230 return safecat(buffer
, bufsize
, pos
, number
);
233 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
234 static size_t safecatd(char *buffer
, size_t bufsize
, size_t pos
, double d
,
238 sprintf(number
, "%.*f", precision
, d
);
239 return safecat(buffer
, bufsize
, pos
, number
);
243 static const char invalid
[] = "invalid";
244 static const char sep
[] = ": ";
246 static const char *colour_types
[8] =
248 "grayscale", invalid
, "truecolour", "indexed-colour",
249 "grayscale with alpha", invalid
, "truecolour with alpha", invalid
252 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
253 /* Convert a double precision value to fixed point. */
254 static png_fixed_point
257 d
= floor(d
* PNG_FP_1
+ .5);
258 return (png_fixed_point
)d
;
260 #endif /* PNG_READ_SUPPORTED */
262 /* Generate random bytes. This uses a boring repeatable algorithm and it
263 * is implemented here so that it gives the same set of numbers on every
264 * architecture. It's a linear congruential generator (Knuth or Sedgewick
265 * "Algorithms") but it comes from the 'feedback taps' table in Horowitz and
266 * Hill, "The Art of Electronics" (Pseudo-Random Bit Sequences and Noise
270 make_random_bytes(png_uint_32
* seed
, void* pv
, size_t size
)
272 png_uint_32 u0
= seed
[0], u1
= seed
[1];
273 png_bytep bytes
= voidcast(png_bytep
, pv
);
275 /* There are thirty three bits, the next bit in the sequence is bit-33 XOR
276 * bit-20. The top 1 bit is in u1, the bottom 32 are in u0.
279 for (i
=0; i
<size
; ++i
)
281 /* First generate 8 new bits then shift them in at the end. */
282 png_uint_32 u
= ((u0
>> (20-8)) ^ ((u1
<< 7) | (u0
>> (32-7)))) & 0xff;
287 *bytes
++ = (png_byte
)u
;
295 make_four_random_bytes(png_uint_32
* seed
, png_bytep bytes
)
297 make_random_bytes(seed
, bytes
, 4);
300 #if defined PNG_READ_SUPPORTED || defined PNG_WRITE_tRNS_SUPPORTED ||\
301 defined PNG_WRITE_FILTER_SUPPORTED
303 randomize(void *pv
, size_t size
)
305 static png_uint_32 random_seed
[2] = {0x56789abc, 0xd};
306 make_random_bytes(random_seed
, pv
, size
);
309 #define R8(this) randomize(&(this), sizeof (this))
311 #ifdef PNG_READ_SUPPORTED
316 randomize(b1
, sizeof b1
);
325 randomize(b2
, sizeof b2
);
326 return png_get_uint_16(b2
);
329 #if defined PNG_READ_RGB_TO_GRAY_SUPPORTED ||\
330 defined PNG_READ_FILLER_SUPPORTED
335 randomize(b4
, sizeof b4
);
336 return png_get_uint_32(b4
);
338 #endif /* READ_FILLER || READ_RGB_TO_GRAY */
340 #endif /* READ || WRITE_tRNS || WRITE_FILTER */
342 #if defined PNG_READ_TRANSFORMS_SUPPORTED ||\
343 defined PNG_WRITE_FILTER_SUPPORTED
345 random_mod(unsigned int max
)
347 return random_u16() % max
; /* 0 .. max-1 */
349 #endif /* READ_TRANSFORMS || WRITE_FILTER */
351 #if (defined PNG_READ_RGB_TO_GRAY_SUPPORTED) ||\
352 (defined PNG_READ_FILLER_SUPPORTED)
356 return random_byte() & 1;
358 #endif /* READ_RGB_TO_GRAY || READ_FILLER */
360 /* A numeric ID based on PNG file characteristics. The 'do_interlace' field
361 * simply records whether pngvalid did the interlace itself or whether it
362 * was done by libpng. Width and height must be less than 256. 'palette' is an
363 * index of the palette to use for formats with a palette otherwise a boolean
364 * indicating if a tRNS chunk was generated.
366 #define FILEID(col, depth, palette, interlace, width, height, do_interlace) \
367 ((png_uint_32)((col) + ((depth)<<3) + ((palette)<<8) + ((interlace)<<13) + \
368 (((do_interlace)!=0)<<15) + ((width)<<16) + ((height)<<24)))
370 #define COL_FROM_ID(id) ((png_byte)((id)& 0x7U))
371 #define DEPTH_FROM_ID(id) ((png_byte)(((id) >> 3) & 0x1fU))
372 #define PALETTE_FROM_ID(id) (((id) >> 8) & 0x1f)
373 #define INTERLACE_FROM_ID(id) ((png_byte)(((id) >> 13) & 0x3))
374 #define DO_INTERLACE_FROM_ID(id) ((int)(((id)>>15) & 1))
375 #define WIDTH_FROM_ID(id) (((id)>>16) & 0xff)
376 #define HEIGHT_FROM_ID(id) (((id)>>24) & 0xff)
378 /* Utility to construct a standard name for a standard image. */
380 standard_name(char *buffer
, size_t bufsize
, size_t pos
, png_byte colour_type
,
381 int bit_depth
, unsigned int npalette
, int interlace_type
,
382 png_uint_32 w
, png_uint_32 h
, int do_interlace
)
384 pos
= safecat(buffer
, bufsize
, pos
, colour_types
[colour_type
]);
385 if (colour_type
== 3) /* must have a palette */
387 pos
= safecat(buffer
, bufsize
, pos
, "[");
388 pos
= safecatn(buffer
, bufsize
, pos
, npalette
);
389 pos
= safecat(buffer
, bufsize
, pos
, "]");
392 else if (npalette
!= 0)
393 pos
= safecat(buffer
, bufsize
, pos
, "+tRNS");
395 pos
= safecat(buffer
, bufsize
, pos
, " ");
396 pos
= safecatn(buffer
, bufsize
, pos
, bit_depth
);
397 pos
= safecat(buffer
, bufsize
, pos
, " bit");
399 if (interlace_type
!= PNG_INTERLACE_NONE
)
401 pos
= safecat(buffer
, bufsize
, pos
, " interlaced");
403 pos
= safecat(buffer
, bufsize
, pos
, "(pngvalid)");
405 pos
= safecat(buffer
, bufsize
, pos
, "(libpng)");
410 pos
= safecat(buffer
, bufsize
, pos
, " ");
411 pos
= safecatn(buffer
, bufsize
, pos
, w
);
412 pos
= safecat(buffer
, bufsize
, pos
, "x");
413 pos
= safecatn(buffer
, bufsize
, pos
, h
);
420 standard_name_from_id(char *buffer
, size_t bufsize
, size_t pos
, png_uint_32 id
)
422 return standard_name(buffer
, bufsize
, pos
, COL_FROM_ID(id
),
423 DEPTH_FROM_ID(id
), PALETTE_FROM_ID(id
), INTERLACE_FROM_ID(id
),
424 WIDTH_FROM_ID(id
), HEIGHT_FROM_ID(id
), DO_INTERLACE_FROM_ID(id
));
427 /* Convenience API and defines to list valid formats. Note that 16 bit read and
428 * write support is required to do 16 bit read tests (we must be able to make a
429 * 16 bit image to test!)
431 #ifdef PNG_WRITE_16BIT_SUPPORTED
432 # define WRITE_BDHI 4
433 # ifdef PNG_READ_16BIT_SUPPORTED
438 # define WRITE_BDHI 3
444 /* The following defines the number of different palettes to generate for
445 * each log bit depth of a colour type 3 standard image.
447 #define PALETTE_COUNT(bit_depth) ((bit_depth) > 4 ? 1U : 16U)
450 next_format(png_bytep colour_type
, png_bytep bit_depth
,
451 unsigned int* palette_number
, int low_depth_gray
, int tRNS
)
464 if (*colour_type
< 4/*no alpha channel*/)
466 /* Add multiple palettes for colour type 3, one image with tRNS
467 * and one without for other non-alpha formats:
469 unsigned int pn
= ++*palette_number
;
470 png_byte ct
= *colour_type
;
472 if (((ct
== 0/*GRAY*/ || ct
/*RGB*/ == 2) && tRNS
&& pn
< 2) ||
473 (ct
== 3/*PALETTE*/ && pn
< PALETTE_COUNT(*bit_depth
)))
476 /* No: next bit depth */
480 *bit_depth
= (png_byte
)(*bit_depth
<< 1);
482 /* Palette images are restricted to 8 bit depth */
485 || (*colour_type
!= 3 && *bit_depth
<= 16)
490 /* Move to the next color type, or return 0 at the end. */
491 switch (*colour_type
)
518 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
520 sample(png_const_bytep row
, png_byte colour_type
, png_byte bit_depth
,
521 png_uint_32 x
, unsigned int sample_index
, int swap16
, int littleendian
)
523 png_uint_32 bit_index
, result
;
525 /* Find a sample index for the desired sample: */
529 if ((colour_type
& 1) == 0) /* !palette */
535 bit_index
+= x
; /* Alpha channel */
537 /* Multiple channels; select one: */
538 if (colour_type
& (2+4))
539 bit_index
+= sample_index
* bit_depth
;
542 /* Return the sample from the row as an integer. */
543 row
+= bit_index
>> 3;
549 else if (bit_depth
> 8)
552 return (*++row
<< 8) + result
;
554 return (result
<< 8) + *++row
;
557 /* Less than 8 bits per sample. By default PNG has the big end of
558 * the egg on the left of the screen, but if littleendian is set
559 * then the big end is on the right.
564 bit_index
= 8-bit_index
-bit_depth
;
566 return (result
>> bit_index
) & ((1U<<bit_depth
)-1);
568 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
570 /* Copy a single pixel, of a given size, from one buffer to another -
571 * while this is basically bit addressed there is an implicit assumption
572 * that pixels 8 or more bits in size are byte aligned and that pixels
573 * do not otherwise cross byte boundaries. (This is, so far as I know,
574 * universally true in bitmap computer graphics. [JCB 20101212])
576 * NOTE: The to and from buffers may be the same.
579 pixel_copy(png_bytep toBuffer
, png_uint_32 toIndex
,
580 png_const_bytep fromBuffer
, png_uint_32 fromIndex
, unsigned int pixelSize
,
583 /* Assume we can multiply by 'size' without overflow because we are
584 * just working in a single buffer.
586 toIndex
*= pixelSize
;
587 fromIndex
*= pixelSize
;
588 if (pixelSize
< 8) /* Sub-byte */
590 /* Mask to select the location of the copied pixel: */
591 unsigned int destMask
= ((1U<<pixelSize
)-1) <<
592 (littleendian
? toIndex
&7 : 8-pixelSize
-(toIndex
&7));
593 /* The following read the entire pixels and clears the extra: */
594 unsigned int destByte
= toBuffer
[toIndex
>> 3] & ~destMask
;
595 unsigned int sourceByte
= fromBuffer
[fromIndex
>> 3];
597 /* Don't rely on << or >> supporting '0' here, just in case: */
601 if (fromIndex
> 0) sourceByte
>>= fromIndex
;
602 if ((toIndex
& 7) > 0) sourceByte
<<= toIndex
& 7;
607 if (fromIndex
> 0) sourceByte
<<= fromIndex
;
608 if ((toIndex
& 7) > 0) sourceByte
>>= toIndex
& 7;
611 toBuffer
[toIndex
>> 3] = (png_byte
)(destByte
| (sourceByte
& destMask
));
613 else /* One or more bytes */
614 memmove(toBuffer
+(toIndex
>>3), fromBuffer
+(fromIndex
>>3), pixelSize
>>3);
617 #ifdef PNG_READ_SUPPORTED
618 /* Copy a complete row of pixels, taking into account potential partial
622 row_copy(png_bytep toBuffer
, png_const_bytep fromBuffer
, unsigned int bitWidth
,
625 memcpy(toBuffer
, fromBuffer
, bitWidth
>> 3);
627 if ((bitWidth
& 7) != 0)
631 toBuffer
+= bitWidth
>> 3;
632 fromBuffer
+= bitWidth
>> 3;
634 mask
= 0xff << (bitWidth
& 7);
636 mask
= 0xff >> (bitWidth
& 7);
637 *toBuffer
= (png_byte
)((*toBuffer
& mask
) | (*fromBuffer
& ~mask
));
641 /* Compare pixels - they are assumed to start at the first byte in the
645 pixel_cmp(png_const_bytep pa
, png_const_bytep pb
, png_uint_32 bit_width
)
647 #if PNG_LIBPNG_VER < 10506
648 if (memcmp(pa
, pb
, bit_width
>>3) == 0)
652 if ((bit_width
& 7) == 0) return 0;
654 /* Ok, any differences? */
655 p
= pa
[bit_width
>> 3];
656 p
^= pb
[bit_width
>> 3];
658 if (p
== 0) return 0;
660 /* There are, but they may not be significant, remove the bits
661 * after the end (the low order bits in PNG.)
666 if (p
== 0) return 0;
669 /* From libpng-1.5.6 the overwrite should be fixed, so compare the trailing
672 if (memcmp(pa
, pb
, (bit_width
+7)>>3) == 0)
676 /* Return the index of the changed byte. */
678 png_uint_32 where
= 0;
680 while (pa
[where
] == pb
[where
]) ++where
;
684 #endif /* PNG_READ_SUPPORTED */
686 /*************************** BASIC PNG FILE WRITING ***************************/
687 /* A png_store takes data from the sequential writer or provides data
688 * to the sequential reader. It can also store the result of a PNG
689 * write for later retrieval.
691 #define STORE_BUFFER_SIZE 500 /* arbitrary */
692 typedef struct png_store_buffer
694 struct png_store_buffer
* prev
; /* NOTE: stored in reverse order */
695 png_byte buffer
[STORE_BUFFER_SIZE
];
698 #define FILE_NAME_SIZE 64
700 typedef struct store_palette_entry
/* record of a single palette entry */
706 } store_palette_entry
, store_palette
[256];
708 typedef struct png_store_file
710 struct png_store_file
* next
; /* as many as you like... */
711 char name
[FILE_NAME_SIZE
];
712 unsigned int IDAT_bits
; /* Number of bits in IDAT size */
713 png_uint_32 IDAT_size
; /* Total size of IDAT data */
714 png_uint_32 id
; /* must be correct (see FILEID) */
715 size_t datacount
; /* In this (the last) buffer */
716 png_store_buffer data
; /* Last buffer in file */
717 int npalette
; /* Number of entries in palette */
718 store_palette_entry
* palette
; /* May be NULL */
721 /* The following is a pool of memory allocated by a single libpng read or write
724 typedef struct store_pool
726 struct png_store
*store
; /* Back pointer */
727 struct store_memory
*list
; /* List of allocated memory */
728 png_byte mark
[4]; /* Before and after data */
730 /* Statistics for this run. */
731 png_alloc_size_t max
; /* Maximum single allocation */
732 png_alloc_size_t current
; /* Current allocation */
733 png_alloc_size_t limit
; /* Highest current allocation */
734 png_alloc_size_t total
; /* Total allocation */
736 /* Overall statistics (retained across successive runs). */
737 png_alloc_size_t max_max
;
738 png_alloc_size_t max_limit
;
739 png_alloc_size_t max_total
;
742 typedef struct png_store
744 /* For cexcept.h exception handling - simply store one of these;
745 * the context is a self pointer but it may point to a different
746 * png_store (in fact it never does in this program.)
748 struct exception_context
751 unsigned int verbose
:1;
752 unsigned int treat_warnings_as_errors
:1;
753 unsigned int expect_error
:1;
754 unsigned int expect_warning
:1;
755 unsigned int saw_warning
:1;
756 unsigned int speed
:1;
757 unsigned int progressive
:1; /* use progressive read */
758 unsigned int validated
:1; /* used as a temporary flag */
761 int noptions
; /* number of options below: */
763 unsigned char option
; /* option number, 0..30 */
764 unsigned char setting
; /* setting (unset,invalid,on,off) */
766 char test
[128]; /* Name of test */
770 png_uint_32 chunklen
; /* Length of chunk+overhead (chunkpos >= 8) */
771 png_uint_32 chunktype
;/* Type of chunk (valid if chunkpos >= 4) */
772 png_uint_32 chunkpos
; /* Position in chunk */
773 png_uint_32 IDAT_size
;/* Accumulated IDAT size in .new */
774 unsigned int IDAT_bits
;/* Cache of the file store value */
777 png_structp pread
; /* Used to read a saved file */
779 png_store_file
* current
; /* Set when reading */
780 png_store_buffer
* next
; /* Set when reading */
781 size_t readpos
; /* Position in *next */
782 png_byte
* image
; /* Buffer for reading interlaced images */
783 size_t cb_image
; /* Size of this buffer */
784 size_t cb_row
; /* Row size of the image(s) */
786 png_uint_32 IDAT_len
; /* Used when re-chunking IDAT chunks */
787 png_uint_32 IDAT_pos
; /* Used when re-chunking IDAT chunks */
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 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
;
886 store_freebuffer(png_store_buffer
* psb
)
890 store_freebuffer(psb
->prev
);
897 store_freenew(png_store
*ps
)
899 store_freebuffer(&ps
->new);
906 if (ps
->palette
!= NULL
)
915 store_storenew(png_store
*ps
)
917 png_store_buffer
*pb
;
919 pb
= voidcast(png_store_buffer
*, malloc(sizeof *pb
));
922 png_error(ps
->pwrite
, "store new: OOM");
930 store_freefile(png_store_file
**ppf
)
934 store_freefile(&(*ppf
)->next
);
936 store_freebuffer(&(*ppf
)->data
);
937 (*ppf
)->datacount
= 0;
938 if ((*ppf
)->palette
!= NULL
)
940 free((*ppf
)->palette
);
941 (*ppf
)->palette
= NULL
;
942 (*ppf
)->npalette
= 0;
950 bits_of(png_uint_32 num
)
952 /* Return the number of bits in 'num' */
955 if (num
& 0xffff0000U
) b
+= 16U, num
>>= 16;
956 if (num
& 0xff00U
) b
+= 8U, num
>>= 8;
957 if (num
& 0xf0U
) b
+= 4U, num
>>= 4;
958 if (num
& 0xcU
) b
+= 2U, num
>>= 2;
959 if (num
& 0x2U
) ++b
, num
>>= 1;
962 return b
; /* 0..32 */
965 /* Main interface to file storage, after writing a new PNG file (see the API
966 * below) call store_storefile to store the result with the given name and id.
969 store_storefile(png_store
*ps
, png_uint_32 id
)
973 if (ps
->chunkpos
!= 0U || ps
->chunktype
!= 0U || ps
->chunklen
!= 0U ||
975 png_error(ps
->pwrite
, "storefile: incomplete write");
977 pf
= voidcast(png_store_file
*, malloc(sizeof *pf
));
979 png_error(ps
->pwrite
, "storefile: OOM");
980 safecat(pf
->name
, sizeof pf
->name
, 0, ps
->wname
);
983 pf
->datacount
= ps
->writepos
;
984 pf
->IDAT_size
= ps
->IDAT_size
;
985 pf
->IDAT_bits
= bits_of(ps
->IDAT_size
);
986 /* Because the IDAT always has zlib header stuff this must be true: */
987 if (pf
->IDAT_bits
== 0U)
988 png_error(ps
->pwrite
, "storefile: 0 sized IDAT");
995 pf
->palette
= ps
->palette
;
996 pf
->npalette
= ps
->npalette
;
1001 pf
->next
= ps
->saved
;
1005 /* Generate an error message (in the given buffer) */
1007 store_message(png_store
*ps
, png_const_structp pp
, char *buffer
, size_t bufsize
,
1008 size_t pos
, const char *msg
)
1010 if (pp
!= NULL
&& pp
== ps
->pread
)
1012 /* Reading a file */
1013 pos
= safecat(buffer
, bufsize
, pos
, "read: ");
1015 if (ps
->current
!= NULL
)
1017 pos
= safecat(buffer
, bufsize
, pos
, ps
->current
->name
);
1018 pos
= safecat(buffer
, bufsize
, pos
, sep
);
1022 else if (pp
!= NULL
&& pp
== ps
->pwrite
)
1024 /* Writing a file */
1025 pos
= safecat(buffer
, bufsize
, pos
, "write: ");
1026 pos
= safecat(buffer
, bufsize
, pos
, ps
->wname
);
1027 pos
= safecat(buffer
, bufsize
, pos
, sep
);
1032 /* Neither reading nor writing (or a memory error in struct delete) */
1033 pos
= safecat(buffer
, bufsize
, pos
, "pngvalid: ");
1036 if (ps
->test
[0] != 0)
1038 pos
= safecat(buffer
, bufsize
, pos
, ps
->test
);
1039 pos
= safecat(buffer
, bufsize
, pos
, sep
);
1041 pos
= safecat(buffer
, bufsize
, pos
, msg
);
1045 /* Verbose output to the error stream: */
1047 store_verbose(png_store
*ps
, png_const_structp pp
, png_const_charp prefix
,
1048 png_const_charp message
)
1053 fputs(prefix
, stderr
);
1055 (void)store_message(ps
, pp
, buffer
, sizeof buffer
, 0, message
);
1056 fputs(buffer
, stderr
);
1057 fputc('\n', stderr
);
1060 /* Log an error or warning - the relevant count is always incremented. */
1062 store_log(png_store
* ps
, png_const_structp pp
, png_const_charp message
,
1065 /* The warning is copied to the error buffer if there are no errors and it is
1066 * the first warning. The error is copied to the error buffer if it is the
1067 * first error (overwriting any prior warnings).
1069 if (is_error
? (ps
->nerrors
)++ == 0 :
1070 (ps
->nwarnings
)++ == 0 && ps
->nerrors
== 0)
1071 store_message(ps
, pp
, ps
->error
, sizeof ps
->error
, 0, message
);
1074 store_verbose(ps
, pp
, is_error
? "error: " : "warning: ", message
);
1077 #ifdef PNG_READ_SUPPORTED
1078 /* Internal error function, called with a png_store but no libpng stuff. */
1080 internal_error(png_store
*ps
, png_const_charp message
)
1082 store_log(ps
, NULL
, message
, 1 /* error */);
1084 /* And finally throw an exception. */
1086 struct exception_context
*the_exception_context
= &ps
->exception_context
;
1090 #endif /* PNG_READ_SUPPORTED */
1092 /* Functions to use as PNG callbacks. */
1093 static void PNGCBAPI
1094 store_error(png_structp ppIn
, png_const_charp message
) /* PNG_NORETURN */
1096 png_const_structp pp
= ppIn
;
1097 png_store
*ps
= voidcast(png_store
*, png_get_error_ptr(pp
));
1099 if (!ps
->expect_error
)
1100 store_log(ps
, pp
, message
, 1 /* error */);
1102 /* And finally throw an exception. */
1104 struct exception_context
*the_exception_context
= &ps
->exception_context
;
1109 static void PNGCBAPI
1110 store_warning(png_structp ppIn
, png_const_charp message
)
1112 png_const_structp pp
= ppIn
;
1113 png_store
*ps
= voidcast(png_store
*, png_get_error_ptr(pp
));
1115 if (!ps
->expect_warning
)
1116 store_log(ps
, pp
, message
, 0 /* warning */);
1118 ps
->saw_warning
= 1;
1121 /* These somewhat odd functions are used when reading an image to ensure that
1122 * the buffer is big enough, the png_structp is for errors.
1124 /* Return a single row from the correct image. */
1126 store_image_row(const png_store
* ps
, png_const_structp pp
, int nImage
,
1129 size_t coffset
= (nImage
* ps
->image_h
+ y
) * (ps
->cb_row
+ 5) + 2;
1131 if (ps
->image
== NULL
)
1132 png_error(pp
, "no allocated image");
1134 if (coffset
+ ps
->cb_row
+ 3 > ps
->cb_image
)
1135 png_error(pp
, "image too small");
1137 return ps
->image
+ coffset
;
1141 store_image_free(png_store
*ps
, png_const_structp pp
)
1143 if (ps
->image
!= NULL
)
1145 png_bytep image
= ps
->image
;
1147 if (image
[-1] != 0xed || image
[ps
->cb_image
] != 0xfe)
1150 png_error(pp
, "png_store image overwrite (1)");
1152 store_log(ps
, NULL
, "png_store image overwrite (2)", 1);
1163 store_ensure_image(png_store
*ps
, png_const_structp pp
, int nImages
,
1164 size_t cbRow
, png_uint_32 cRows
)
1166 size_t cb
= nImages
* cRows
* (cbRow
+ 5);
1168 if (ps
->cb_image
< cb
)
1172 store_image_free(ps
, pp
);
1174 /* The buffer is deliberately mis-aligned. */
1175 image
= voidcast(png_bytep
, malloc(cb
+2));
1178 /* Called from the startup - ignore the error for the moment. */
1182 png_error(pp
, "OOM allocating image buffer");
1185 /* These magic tags are used to detect overwrites above. */
1194 /* We have an adequate sized image; lay out the rows. There are 2 bytes at
1195 * the start and three at the end of each (this ensures that the row
1196 * alignment starts out odd - 2+1 and changes for larger images on each row.)
1199 ps
->image_h
= cRows
;
1201 /* For error checking, the whole buffer is set to 10110010 (0xb2 - 178).
1202 * This deliberately doesn't match the bits in the size test image which are
1203 * outside the image; these are set to 0xff (all 1). To make the row
1204 * comparison work in the 'size' test case the size rows are pre-initialized
1205 * to the same value prior to calling 'standard_row'.
1207 memset(ps
->image
, 178, cb
);
1209 /* Then put in the marks. */
1210 while (--nImages
>= 0)
1214 for (y
=0; y
<cRows
; ++y
)
1216 png_bytep row
= store_image_row(ps
, pp
, nImages
, y
);
1228 #ifdef PNG_READ_SUPPORTED
1230 store_image_check(const png_store
* ps
, png_const_structp pp
, int iImage
)
1232 png_const_bytep image
= ps
->image
;
1234 if (image
[-1] != 0xed || image
[ps
->cb_image
] != 0xfe)
1235 png_error(pp
, "image overwrite");
1238 size_t cbRow
= ps
->cb_row
;
1239 png_uint_32 rows
= ps
->image_h
;
1241 image
+= iImage
* (cbRow
+5) * ps
->image_h
;
1243 image
+= 2; /* skip image first row markers */
1245 for (; rows
> 0; --rows
)
1247 if (image
[-2] != 190 || image
[-1] != 239)
1248 png_error(pp
, "row start overwritten");
1250 if (image
[cbRow
] != 222 || image
[cbRow
+1] != 173 ||
1251 image
[cbRow
+2] != 17)
1252 png_error(pp
, "row end overwritten");
1258 #endif /* PNG_READ_SUPPORTED */
1261 valid_chunktype(png_uint_32 chunktype
)
1263 /* Each byte in the chunk type must be in one of the ranges 65..90, 97..122
1264 * (both inclusive), so:
1270 unsigned int c
= chunktype
& 0xffU
;
1272 if (!((c
>= 65U && c
<= 90U) || (c
>= 97U && c
<= 122U)))
1278 return 1; /* It's valid */
1281 static void PNGCBAPI
1282 store_write(png_structp ppIn
, png_bytep pb
, size_t st
)
1284 png_const_structp pp
= ppIn
;
1285 png_store
*ps
= voidcast(png_store
*, png_get_io_ptr(pp
));
1286 size_t writepos
= ps
->writepos
;
1287 png_uint_32 chunkpos
= ps
->chunkpos
;
1288 png_uint_32 chunktype
= ps
->chunktype
;
1289 png_uint_32 chunklen
= ps
->chunklen
;
1291 if (ps
->pwrite
!= pp
)
1292 png_error(pp
, "store state damaged");
1294 /* Technically this is legal, but in practice libpng never writes more than
1295 * the maximum chunk size at once so if it happens something weird has
1296 * changed inside libpng (probably).
1298 if (st
> 0x7fffffffU
)
1299 png_error(pp
, "unexpected write size");
1301 /* Now process the bytes to be written. Do this in units of the space in the
1302 * output (write) buffer or, at the start 4 bytes for the chunk type and
1303 * length limited in any case by the amount of data.
1307 if (writepos
>= STORE_BUFFER_SIZE
)
1308 store_storenew(ps
), writepos
= 0;
1314 chunklen
= (chunklen
<< 8) + b
;
1315 ps
->new.buffer
[writepos
++] = b
;
1319 else if (chunkpos
< 8)
1323 chunktype
= (chunktype
<< 8) + b
;
1324 ps
->new.buffer
[writepos
++] = b
;
1326 if (++chunkpos
== 8)
1328 chunklen
&= 0xffffffffU
;
1329 if (chunklen
> 0x7fffffffU
)
1330 png_error(pp
, "chunk length too great");
1332 chunktype
&= 0xffffffffU
;
1333 if (chunktype
== CHUNK_IDAT
)
1335 if (chunklen
> ~ps
->IDAT_size
)
1336 png_error(pp
, "pngvalid internal image too large");
1338 ps
->IDAT_size
+= chunklen
;
1341 else if (!valid_chunktype(chunktype
))
1342 png_error(pp
, "invalid chunk type");
1344 chunklen
+= 12; /* for header and CRC */
1348 else /* chunkpos >= 8 */
1352 if (cb
> STORE_BUFFER_SIZE
- writepos
)
1353 cb
= STORE_BUFFER_SIZE
- writepos
;
1355 if (cb
> chunklen
- chunkpos
/* bytes left in chunk*/)
1356 cb
= (size_t)/*SAFE*/(chunklen
- chunkpos
);
1358 memcpy(ps
->new.buffer
+ writepos
, pb
, cb
);
1359 chunkpos
+= (png_uint_32
)/*SAFE*/cb
;
1364 if (chunkpos
>= chunklen
) /* must be equal */
1365 chunkpos
= chunktype
= chunklen
= 0;
1367 } /* while (st > 0) */
1369 ps
->writepos
= writepos
;
1370 ps
->chunkpos
= chunkpos
;
1371 ps
->chunktype
= chunktype
;
1372 ps
->chunklen
= chunklen
;
1375 static void PNGCBAPI
1376 store_flush(png_structp ppIn
)
1378 UNUSED(ppIn
) /*DOES NOTHING*/
1381 #ifdef PNG_READ_SUPPORTED
1383 store_read_buffer_size(png_store
*ps
)
1385 /* Return the bytes available for read in the current buffer. */
1386 if (ps
->next
!= &ps
->current
->data
)
1387 return STORE_BUFFER_SIZE
;
1389 return ps
->current
->datacount
;
1392 /* Return total bytes available for read. */
1394 store_read_buffer_avail(png_store
*ps
)
1396 if (ps
->current
!= NULL
&& ps
->next
!= NULL
)
1398 png_store_buffer
*next
= &ps
->current
->data
;
1399 size_t cbAvail
= ps
->current
->datacount
;
1401 while (next
!= ps
->next
&& next
!= NULL
)
1404 cbAvail
+= STORE_BUFFER_SIZE
;
1407 if (next
!= ps
->next
)
1408 png_error(ps
->pread
, "buffer read error");
1410 if (cbAvail
> ps
->readpos
)
1411 return cbAvail
- ps
->readpos
;
1418 store_read_buffer_next(png_store
*ps
)
1420 png_store_buffer
*pbOld
= ps
->next
;
1421 png_store_buffer
*pbNew
= &ps
->current
->data
;
1424 while (pbNew
!= NULL
&& pbNew
->prev
!= pbOld
)
1425 pbNew
= pbNew
->prev
;
1434 png_error(ps
->pread
, "buffer lost");
1437 return 0; /* EOF or error */
1440 /* Need separate implementation and callback to allow use of the same code
1441 * during progressive read, where the io_ptr is set internally by libpng.
1444 store_read_imp(png_store
*ps
, png_bytep pb
, size_t st
)
1446 if (ps
->current
== NULL
|| ps
->next
== NULL
)
1447 png_error(ps
->pread
, "store state damaged");
1451 size_t cbAvail
= store_read_buffer_size(ps
) - ps
->readpos
;
1455 if (cbAvail
> st
) cbAvail
= st
;
1456 memcpy(pb
, ps
->next
->buffer
+ ps
->readpos
, cbAvail
);
1459 ps
->readpos
+= cbAvail
;
1462 else if (!store_read_buffer_next(ps
))
1463 png_error(ps
->pread
, "read beyond end of file");
1468 store_read_chunk(png_store
*ps
, png_bytep pb
, size_t max
, size_t min
)
1470 png_uint_32 chunklen
= ps
->chunklen
;
1471 png_uint_32 chunktype
= ps
->chunktype
;
1472 png_uint_32 chunkpos
= ps
->chunkpos
;
1477 if (chunkpos
>= chunklen
) /* end of last chunk */
1481 /* Read the header of the next chunk: */
1482 store_read_imp(ps
, buffer
, 8U);
1483 chunklen
= png_get_uint_32(buffer
) + 12U;
1484 chunktype
= png_get_uint_32(buffer
+4U);
1485 chunkpos
= 0U; /* Position read so far */
1488 if (chunktype
== CHUNK_IDAT
)
1490 png_uint_32 IDAT_pos
= ps
->IDAT_pos
;
1491 png_uint_32 IDAT_len
= ps
->IDAT_len
;
1492 png_uint_32 IDAT_size
= ps
->IDAT_size
;
1494 /* The IDAT headers are constructed here; skip the input header. */
1498 if (IDAT_pos
== IDAT_len
)
1500 png_byte random
= random_byte();
1502 /* Make a new IDAT chunk, if IDAT_len is 0 this is the first IDAT,
1503 * if IDAT_size is 0 this is the end. At present this is set up
1504 * using a random number so that there is a 25% chance before
1505 * the start of the first IDAT chunk being 0 length.
1507 if (IDAT_len
== 0U) /* First IDAT */
1509 switch (random
& 3U)
1511 case 0U: IDAT_len
= 12U; break; /* 0 bytes */
1512 case 1U: IDAT_len
= 13U; break; /* 1 byte */
1513 default: IDAT_len
= random_u32();
1514 IDAT_len
%= IDAT_size
;
1515 IDAT_len
+= 13U; /* 1..IDAT_size bytes */
1520 else if (IDAT_size
== 0U) /* all IDAT data read */
1522 /* The last (IDAT) chunk should be positioned at the CRC now: */
1523 if (chunkpos
!= chunklen
-4U)
1524 png_error(ps
->pread
, "internal: IDAT size mismatch");
1526 /* The only option here is to add a zero length IDAT, this
1527 * happens 25% of the time. Because of the check above
1528 * chunklen-4U-chunkpos must be zero, we just need to skip the
1531 if ((random
& 3U) == 0U)
1532 IDAT_len
= 12U; /* Output another 0 length IDAT */
1536 /* End of IDATs, skip the CRC to make the code above load the
1537 * next chunk header next time round.
1541 store_read_imp(ps
, buffer
, 4U);
1543 ps
->IDAT_pos
= IDAT_pos
;
1544 ps
->IDAT_len
= IDAT_len
;
1546 continue; /* Read the next chunk */
1552 /* Middle of IDATs, use 'random' to determine the number of bits
1553 * to use in the IDAT length.
1555 IDAT_len
= random_u32();
1556 IDAT_len
&= (1U << (1U + random
% ps
->IDAT_bits
)) - 1U;
1557 if (IDAT_len
> IDAT_size
)
1558 IDAT_len
= IDAT_size
;
1559 IDAT_len
+= 12U; /* zero bytes may occur */
1563 ps
->IDAT_crc
= 0x35af061e; /* Ie: crc32(0UL, "IDAT", 4) */
1564 } /* IDAT_pos == IDAT_len */
1566 if (IDAT_pos
< 8U) /* Return the header */ do
1577 shift
= 3U & IDAT_pos
;
1581 b
>>= 8U*(3U-shift
);
1585 while (--st
> 0 && IDAT_pos
< 8);
1587 else if (IDAT_pos
< IDAT_len
- 4U) /* I.e not the CRC */
1589 if (chunkpos
< chunklen
-4U)
1591 uInt avail
= (uInt
)-1;
1593 if (avail
> (IDAT_len
-4U) - IDAT_pos
)
1594 avail
= (uInt
)/*SAFE*/((IDAT_len
-4U) - IDAT_pos
);
1597 avail
= (uInt
)/*SAFE*/st
;
1599 if (avail
> (chunklen
-4U) - chunkpos
)
1600 avail
= (uInt
)/*SAFE*/((chunklen
-4U) - chunkpos
);
1602 store_read_imp(ps
, pb
, avail
);
1603 ps
->IDAT_crc
= crc32(ps
->IDAT_crc
, pb
, avail
);
1604 pb
+= (size_t)/*SAFE*/avail
;
1605 st
-= (size_t)/*SAFE*/avail
;
1606 chunkpos
+= (png_uint_32
)/*SAFE*/avail
;
1607 IDAT_size
-= (png_uint_32
)/*SAFE*/avail
;
1608 IDAT_pos
+= (png_uint_32
)/*SAFE*/avail
;
1611 else /* skip the input CRC */
1615 store_read_imp(ps
, buffer
, 4U);
1620 else /* IDAT crc */ do
1622 uLong b
= ps
->IDAT_crc
;
1623 unsigned int shift
= (IDAT_len
- IDAT_pos
); /* 4..1 */
1627 b
>>= 8U*(shift
-1U);
1631 while (--st
> 0 && IDAT_pos
< IDAT_len
);
1633 ps
->IDAT_pos
= IDAT_pos
;
1634 ps
->IDAT_len
= IDAT_len
;
1635 ps
->IDAT_size
= IDAT_size
;
1640 /* If there is still some pending IDAT data after the IDAT chunks have
1641 * been processed there is a problem:
1643 if (ps
->IDAT_len
> 0 && ps
->IDAT_size
> 0)
1644 png_error(ps
->pread
, "internal: missing IDAT data");
1646 if (chunktype
== CHUNK_IEND
&& ps
->IDAT_len
== 0U)
1647 png_error(ps
->pread
, "internal: missing IDAT");
1649 if (chunkpos
< 8U) /* Return the header */ do
1660 shift
= 3U & chunkpos
;
1664 b
>>= 8U*(3U-shift
);
1668 while (--st
> 0 && chunkpos
< 8);
1670 else /* Return chunk bytes, including the CRC */
1674 if (avail
> chunklen
- chunkpos
)
1675 avail
= (size_t)/*SAFE*/(chunklen
- chunkpos
);
1677 store_read_imp(ps
, pb
, avail
);
1680 chunkpos
+= (png_uint_32
)/*SAFE*/avail
;
1682 /* Check for end of chunk and end-of-file; don't try to read a new
1683 * chunk header at this point unless instructed to do so by 'min'.
1685 if (chunkpos
>= chunklen
&& max
-st
>= min
&&
1686 store_read_buffer_avail(ps
) == 0)
1693 ps
->chunklen
= chunklen
;
1694 ps
->chunktype
= chunktype
;
1695 ps
->chunkpos
= chunkpos
;
1697 return st
; /* space left */
1700 static void PNGCBAPI
1701 store_read(png_structp ppIn
, png_bytep pb
, size_t st
)
1703 png_const_structp pp
= ppIn
;
1704 png_store
*ps
= voidcast(png_store
*, png_get_io_ptr(pp
));
1706 if (ps
== NULL
|| ps
->pread
!= pp
)
1707 png_error(pp
, "bad store read call");
1709 store_read_chunk(ps
, pb
, st
, st
);
1713 store_progressive_read(png_store
*ps
, png_structp pp
, png_infop pi
)
1715 if (ps
->pread
!= pp
|| ps
->current
== NULL
|| ps
->next
== NULL
)
1716 png_error(pp
, "store state damaged (progressive)");
1718 /* This is another Horowitz and Hill random noise generator. In this case
1719 * the aim is to stress the progressive reader with truly horrible variable
1720 * buffer sizes in the range 1..500, so a sequence of 9 bit random numbers
1721 * is generated. We could probably just count from 1 to 32767 and get as
1724 while (store_read_buffer_avail(ps
) > 0)
1726 static png_uint_32 noise
= 2;
1728 png_byte buffer
[512];
1730 /* Generate 15 more bits of stuff: */
1731 noise
= (noise
<< 9) | ((noise
^ (noise
>> (9-5))) & 0x1ff);
1733 cb
-= store_read_chunk(ps
, buffer
, cb
, 1);
1734 png_process_data(pp
, pi
, buffer
, cb
);
1737 #endif /* PNG_READ_SUPPORTED */
1739 /* The caller must fill this in: */
1740 static store_palette_entry
*
1741 store_write_palette(png_store
*ps
, int npalette
)
1743 if (ps
->pwrite
== NULL
)
1744 store_log(ps
, NULL
, "attempt to write palette without write stream", 1);
1746 if (ps
->palette
!= NULL
)
1747 png_error(ps
->pwrite
, "multiple store_write_palette calls");
1749 /* This function can only return NULL if called with '0'! */
1752 ps
->palette
= voidcast(store_palette_entry
*, malloc(npalette
*
1753 sizeof *ps
->palette
));
1755 if (ps
->palette
== NULL
)
1756 png_error(ps
->pwrite
, "store new palette: OOM");
1758 ps
->npalette
= npalette
;
1764 #ifdef PNG_READ_SUPPORTED
1765 static store_palette_entry
*
1766 store_current_palette(png_store
*ps
, int *npalette
)
1768 /* This is an internal error (the call has been made outside a read
1771 if (ps
->current
== NULL
)
1773 store_log(ps
, ps
->pread
, "no current stream for palette", 1);
1777 /* The result may be null if there is no palette. */
1778 *npalette
= ps
->current
->npalette
;
1779 return ps
->current
->palette
;
1781 #endif /* PNG_READ_SUPPORTED */
1783 /***************************** MEMORY MANAGEMENT*** ***************************/
1784 #ifdef PNG_USER_MEM_SUPPORTED
1785 /* A store_memory is simply the header for an allocated block of memory. The
1786 * pointer returned to libpng is just after the end of the header block, the
1787 * allocated memory is followed by a second copy of the 'mark'.
1789 typedef struct store_memory
1791 store_pool
*pool
; /* Originating pool */
1792 struct store_memory
*next
; /* Singly linked list */
1793 png_alloc_size_t size
; /* Size of memory allocated */
1794 png_byte mark
[4]; /* ID marker */
1797 /* Handle a fatal error in memory allocation. This calls png_error if the
1798 * libpng struct is non-NULL, else it outputs a message and returns. This means
1799 * that a memory problem while libpng is running will abort (png_error) the
1800 * handling of particular file while one in cleanup (after the destroy of the
1801 * struct has returned) will simply keep going and free (or attempt to free)
1805 store_pool_error(png_store
*ps
, png_const_structp pp
, const char *msg
)
1810 /* Else we have to do it ourselves. png_error eventually calls store_log,
1811 * above. store_log accepts a NULL png_structp - it just changes what gets
1812 * output by store_message.
1814 store_log(ps
, pp
, msg
, 1 /* error */);
1818 store_memory_free(png_const_structp pp
, store_pool
*pool
, store_memory
*memory
)
1820 /* Note that pp may be NULL (see store_pool_delete below), the caller has
1821 * found 'memory' in pool->list *and* unlinked this entry, so this is a valid
1822 * pointer (for sure), but the contents may have been trashed.
1824 if (memory
->pool
!= pool
)
1825 store_pool_error(pool
->store
, pp
, "memory corrupted (pool)");
1827 else if (memcmp(memory
->mark
, pool
->mark
, sizeof memory
->mark
) != 0)
1828 store_pool_error(pool
->store
, pp
, "memory corrupted (start)");
1830 /* It should be safe to read the size field now. */
1833 png_alloc_size_t cb
= memory
->size
;
1836 store_pool_error(pool
->store
, pp
, "memory corrupted (size)");
1838 else if (memcmp((png_bytep
)(memory
+1)+cb
, pool
->mark
, sizeof pool
->mark
)
1840 store_pool_error(pool
->store
, pp
, "memory corrupted (end)");
1842 /* Finally give the library a chance to find problems too: */
1845 pool
->current
-= cb
;
1852 store_pool_delete(png_store
*ps
, store_pool
*pool
)
1854 if (pool
->list
!= NULL
)
1856 fprintf(stderr
, "%s: %s %s: memory lost (list follows):\n", ps
->test
,
1857 pool
== &ps
->read_memory_pool
? "read" : "write",
1858 pool
== &ps
->read_memory_pool
? (ps
->current
!= NULL
?
1859 ps
->current
->name
: "unknown file") : ps
->wname
);
1864 store_memory
*next
= pool
->list
;
1865 pool
->list
= next
->next
;
1868 fprintf(stderr
, "\t%lu bytes @ %p\n",
1869 (unsigned long)next
->size
, (const void*)(next
+1));
1870 /* The NULL means this will always return, even if the memory is
1873 store_memory_free(NULL
, pool
, next
);
1875 while (pool
->list
!= NULL
);
1878 /* And reset the other fields too for the next time. */
1879 if (pool
->max
> pool
->max_max
) pool
->max_max
= pool
->max
;
1881 if (pool
->current
!= 0) /* unexpected internal error */
1882 fprintf(stderr
, "%s: %s %s: memory counter mismatch (internal error)\n",
1883 ps
->test
, pool
== &ps
->read_memory_pool
? "read" : "write",
1884 pool
== &ps
->read_memory_pool
? (ps
->current
!= NULL
?
1885 ps
->current
->name
: "unknown file") : ps
->wname
);
1888 if (pool
->limit
> pool
->max_limit
)
1889 pool
->max_limit
= pool
->limit
;
1893 if (pool
->total
> pool
->max_total
)
1894 pool
->max_total
= pool
->total
;
1898 /* Get a new mark too. */
1899 store_pool_mark(pool
->mark
);
1902 /* The memory callbacks: */
1903 static png_voidp PNGCBAPI
1904 store_malloc(png_structp ppIn
, png_alloc_size_t cb
)
1906 png_const_structp pp
= ppIn
;
1907 store_pool
*pool
= voidcast(store_pool
*, png_get_mem_ptr(pp
));
1908 store_memory
*new = voidcast(store_memory
*, malloc(cb
+ (sizeof *new) +
1909 (sizeof pool
->mark
)));
1916 pool
->current
+= cb
;
1918 if (pool
->current
> pool
->limit
)
1919 pool
->limit
= pool
->current
;
1924 memcpy(new->mark
, pool
->mark
, sizeof new->mark
);
1925 memcpy((png_byte
*)(new+1) + cb
, pool
->mark
, sizeof pool
->mark
);
1927 new->next
= pool
->list
;
1934 /* NOTE: the PNG user malloc function cannot use the png_ptr it is passed
1935 * other than to retrieve the allocation pointer! libpng calls the
1936 * store_malloc callback in two basic cases:
1938 * 1) From png_malloc; png_malloc will do a png_error itself if NULL is
1940 * 2) From png_struct or png_info structure creation; png_malloc is
1941 * to return so cleanup can be performed.
1943 * To handle this store_malloc can log a message, but can't do anything
1946 store_log(pool
->store
, pp
, "out of memory", 1 /* is_error */);
1952 static void PNGCBAPI
1953 store_free(png_structp ppIn
, png_voidp memory
)
1955 png_const_structp pp
= ppIn
;
1956 store_pool
*pool
= voidcast(store_pool
*, png_get_mem_ptr(pp
));
1957 store_memory
*this = voidcast(store_memory
*, memory
), **test
;
1959 /* Because libpng calls store_free with a dummy png_struct when deleting
1960 * png_struct or png_info via png_destroy_struct_2 it is necessary to check
1961 * the passed in png_structp to ensure it is valid, and not pass it to
1962 * png_error if it is not.
1964 if (pp
!= pool
->store
->pread
&& pp
!= pool
->store
->pwrite
)
1967 /* First check that this 'memory' really is valid memory - it must be in the
1968 * pool list. If it is, use the shared memory_free function to free it.
1971 for (test
= &pool
->list
; *test
!= this; test
= &(*test
)->next
)
1975 store_pool_error(pool
->store
, pp
, "bad pointer to free");
1980 /* Unlink this entry, *test == this. */
1983 store_memory_free(pp
, pool
, this);
1985 #endif /* PNG_USER_MEM_SUPPORTED */
1987 /* Setup functions. */
1988 /* Cleanup when aborting a write or after storing the new file. */
1990 store_write_reset(png_store
*ps
)
1992 if (ps
->pwrite
!= NULL
)
1997 png_destroy_write_struct(&ps
->pwrite
, &ps
->piwrite
);
2001 /* memory corruption: continue. */
2008 /* And make sure that all the memory has been freed - this will output
2009 * spurious errors in the case of memory corruption above, but this is safe.
2011 # ifdef PNG_USER_MEM_SUPPORTED
2012 store_pool_delete(ps
, &ps
->write_memory_pool
);
2018 /* The following is the main write function, it returns a png_struct and,
2019 * optionally, a png_info suitable for writiing a new PNG file. Use
2020 * store_storefile above to record this file after it has been written. The
2021 * returned libpng structures as destroyed by store_write_reset above.
2024 set_store_for_write(png_store
*ps
, png_infopp ppi
, const char *name
)
2030 if (ps
->pwrite
!= NULL
)
2031 png_error(ps
->pwrite
, "write store already in use");
2033 store_write_reset(ps
);
2034 safecat(ps
->wname
, sizeof ps
->wname
, 0, name
);
2036 /* Don't do the slow memory checks if doing a speed test, also if user
2037 * memory is not supported we can't do it anyway.
2039 # ifdef PNG_USER_MEM_SUPPORTED
2041 ps
->pwrite
= png_create_write_struct_2(PNG_LIBPNG_VER_STRING
,
2042 ps
, store_error
, store_warning
, &ps
->write_memory_pool
,
2043 store_malloc
, store_free
);
2047 ps
->pwrite
= png_create_write_struct(PNG_LIBPNG_VER_STRING
,
2048 ps
, store_error
, store_warning
);
2050 png_set_write_fn(ps
->pwrite
, ps
, store_write
, store_flush
);
2052 # ifdef PNG_SET_OPTION_SUPPORTED
2055 for (opt
=0; opt
<ps
->noptions
; ++opt
)
2056 if (png_set_option(ps
->pwrite
, ps
->options
[opt
].option
,
2057 ps
->options
[opt
].setting
) == PNG_OPTION_INVALID
)
2058 png_error(ps
->pwrite
, "png option invalid");
2063 *ppi
= ps
->piwrite
= png_create_info_struct(ps
->pwrite
);
2072 /* Cleanup when finished reading (either due to error or in the success case).
2073 * This routine exists even when there is no read support to make the code
2074 * tidier (avoid a mass of ifdefs) and so easier to maintain.
2077 store_read_reset(png_store
*ps
)
2079 # ifdef PNG_READ_SUPPORTED
2080 if (ps
->pread
!= NULL
)
2085 png_destroy_read_struct(&ps
->pread
, &ps
->piread
, NULL
);
2089 /* error already output: continue */
2097 # ifdef PNG_USER_MEM_SUPPORTED
2098 /* Always do this to be safe. */
2099 store_pool_delete(ps
, &ps
->read_memory_pool
);
2113 #ifdef PNG_READ_SUPPORTED
2115 store_read_set(png_store
*ps
, png_uint_32 id
)
2117 png_store_file
*pf
= ps
->saved
;
2125 ps
->IDAT_size
= pf
->IDAT_size
;
2126 ps
->IDAT_bits
= pf
->IDAT_bits
; /* just a cache */
2130 store_read_buffer_next(ps
);
2139 char msg
[FILE_NAME_SIZE
+64];
2141 pos
= standard_name_from_id(msg
, sizeof msg
, 0, id
);
2142 pos
= safecat(msg
, sizeof msg
, pos
, ": file not found");
2143 png_error(ps
->pread
, msg
);
2147 /* The main interface for reading a saved file - pass the id number of the file
2148 * to retrieve. Ids must be unique or the earlier file will be hidden. The API
2149 * returns a png_struct and, optionally, a png_info. Both of these will be
2150 * destroyed by store_read_reset above.
2153 set_store_for_read(png_store
*ps
, png_infopp ppi
, png_uint_32 id
,
2156 /* Set the name for png_error */
2157 safecat(ps
->test
, sizeof ps
->test
, 0, name
);
2159 if (ps
->pread
!= NULL
)
2160 png_error(ps
->pread
, "read store already in use");
2162 store_read_reset(ps
);
2164 /* Both the create APIs can return NULL if used in their default mode
2165 * (because there is no other way of handling an error because the jmp_buf
2166 * by default is stored in png_struct and that has not been allocated!)
2167 * However, given that store_error works correctly in these circumstances
2168 * we don't ever expect NULL in this program.
2170 # ifdef PNG_USER_MEM_SUPPORTED
2172 ps
->pread
= png_create_read_struct_2(PNG_LIBPNG_VER_STRING
, ps
,
2173 store_error
, store_warning
, &ps
->read_memory_pool
, store_malloc
,
2178 ps
->pread
= png_create_read_struct(PNG_LIBPNG_VER_STRING
, ps
, store_error
,
2181 if (ps
->pread
== NULL
)
2183 struct exception_context
*the_exception_context
= &ps
->exception_context
;
2185 store_log(ps
, NULL
, "png_create_read_struct returned NULL (unexpected)",
2191 # ifdef PNG_SET_OPTION_SUPPORTED
2194 for (opt
=0; opt
<ps
->noptions
; ++opt
)
2195 if (png_set_option(ps
->pread
, ps
->options
[opt
].option
,
2196 ps
->options
[opt
].setting
) == PNG_OPTION_INVALID
)
2197 png_error(ps
->pread
, "png option invalid");
2201 store_read_set(ps
, id
);
2204 *ppi
= ps
->piread
= png_create_info_struct(ps
->pread
);
2208 #endif /* PNG_READ_SUPPORTED */
2210 /* The overall cleanup of a store simply calls the above then removes all the
2211 * saved files. This does not delete the store itself.
2214 store_delete(png_store
*ps
)
2216 store_write_reset(ps
);
2217 store_read_reset(ps
);
2218 store_freefile(&ps
->saved
);
2219 store_image_free(ps
, NULL
);
2222 /*********************** PNG FILE MODIFICATION ON READ ************************/
2223 /* Files may be modified on read. The following structure contains a complete
2224 * png_store together with extra members to handle modification and a special
2225 * read callback for libpng. To use this the 'modifications' field must be set
2226 * to a list of png_modification structures that actually perform the
2227 * modification, otherwise a png_modifier is functionally equivalent to a
2228 * png_store. There is a special read function, set_modifier_for_read, which
2229 * replaces set_store_for_read.
2231 typedef enum modifier_state
2233 modifier_start
, /* Initial value */
2234 modifier_signature
, /* Have a signature */
2235 modifier_IHDR
/* Have an IHDR */
2238 typedef struct CIE_color
2240 /* A single CIE tristimulus value, representing the unique response of a
2241 * standard observer to a variety of light spectra. The observer recognizes
2242 * all spectra that produce this response as the same color, therefore this
2243 * is effectively a description of a color.
2248 typedef struct color_encoding
2250 /* A description of an (R,G,B) encoding of color (as defined above); this
2251 * includes the actual colors of the (R,G,B) triples (1,0,0), (0,1,0) and
2252 * (0,0,1) plus an encoding value that is used to encode the linear
2253 * components R, G and B to give the actual values R^gamma, G^gamma and
2254 * B^gamma that are stored.
2256 double gamma
; /* Encoding (file) gamma of space */
2257 CIE_color red
, green
, blue
; /* End points */
2260 #ifdef PNG_READ_SUPPORTED
2261 #if defined PNG_READ_TRANSFORMS_SUPPORTED && defined PNG_READ_cHRM_SUPPORTED
2263 chromaticity_x(CIE_color c
)
2265 return c
.X
/ (c
.X
+ c
.Y
+ c
.Z
);
2269 chromaticity_y(CIE_color c
)
2271 return c
.Y
/ (c
.X
+ c
.Y
+ c
.Z
);
2275 white_point(const color_encoding
*encoding
)
2279 white
.X
= encoding
->red
.X
+ encoding
->green
.X
+ encoding
->blue
.X
;
2280 white
.Y
= encoding
->red
.Y
+ encoding
->green
.Y
+ encoding
->blue
.Y
;
2281 white
.Z
= encoding
->red
.Z
+ encoding
->green
.Z
+ encoding
->blue
.Z
;
2285 #endif /* READ_TRANSFORMS && READ_cHRM */
2287 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
2289 normalize_color_encoding(color_encoding
*encoding
)
2291 const double whiteY
= encoding
->red
.Y
+ encoding
->green
.Y
+
2296 encoding
->red
.X
/= whiteY
;
2297 encoding
->red
.Y
/= whiteY
;
2298 encoding
->red
.Z
/= whiteY
;
2299 encoding
->green
.X
/= whiteY
;
2300 encoding
->green
.Y
/= whiteY
;
2301 encoding
->green
.Z
/= whiteY
;
2302 encoding
->blue
.X
/= whiteY
;
2303 encoding
->blue
.Y
/= whiteY
;
2304 encoding
->blue
.Z
/= whiteY
;
2309 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
2311 safecat_color_encoding(char *buffer
, size_t bufsize
, size_t pos
,
2312 const color_encoding
*e
, double encoding_gamma
)
2316 if (encoding_gamma
!= 0)
2317 pos
= safecat(buffer
, bufsize
, pos
, "(");
2318 pos
= safecat(buffer
, bufsize
, pos
, "R(");
2319 pos
= safecatd(buffer
, bufsize
, pos
, e
->red
.X
, 4);
2320 pos
= safecat(buffer
, bufsize
, pos
, ",");
2321 pos
= safecatd(buffer
, bufsize
, pos
, e
->red
.Y
, 4);
2322 pos
= safecat(buffer
, bufsize
, pos
, ",");
2323 pos
= safecatd(buffer
, bufsize
, pos
, e
->red
.Z
, 4);
2324 pos
= safecat(buffer
, bufsize
, pos
, "),G(");
2325 pos
= safecatd(buffer
, bufsize
, pos
, e
->green
.X
, 4);
2326 pos
= safecat(buffer
, bufsize
, pos
, ",");
2327 pos
= safecatd(buffer
, bufsize
, pos
, e
->green
.Y
, 4);
2328 pos
= safecat(buffer
, bufsize
, pos
, ",");
2329 pos
= safecatd(buffer
, bufsize
, pos
, e
->green
.Z
, 4);
2330 pos
= safecat(buffer
, bufsize
, pos
, "),B(");
2331 pos
= safecatd(buffer
, bufsize
, pos
, e
->blue
.X
, 4);
2332 pos
= safecat(buffer
, bufsize
, pos
, ",");
2333 pos
= safecatd(buffer
, bufsize
, pos
, e
->blue
.Y
, 4);
2334 pos
= safecat(buffer
, bufsize
, pos
, ",");
2335 pos
= safecatd(buffer
, bufsize
, pos
, e
->blue
.Z
, 4);
2336 pos
= safecat(buffer
, bufsize
, pos
, ")");
2337 if (encoding_gamma
!= 0)
2338 pos
= safecat(buffer
, bufsize
, pos
, ")");
2341 if (encoding_gamma
!= 0)
2343 pos
= safecat(buffer
, bufsize
, pos
, "^");
2344 pos
= safecatd(buffer
, bufsize
, pos
, encoding_gamma
, 5);
2349 #endif /* READ_TRANSFORMS */
2350 #endif /* PNG_READ_SUPPORTED */
2352 typedef struct png_modifier
2354 png_store
this; /* I am a png_store */
2355 struct png_modification
*modifications
; /* Changes to make */
2357 modifier_state state
; /* My state */
2359 /* Information from IHDR: */
2360 png_byte bit_depth
; /* From IHDR */
2361 png_byte colour_type
; /* From IHDR */
2363 /* While handling PLTE, IDAT and IEND these chunks may be pended to allow
2364 * other chunks to be inserted.
2366 png_uint_32 pending_len
;
2367 png_uint_32 pending_chunk
;
2371 unsigned int ngammas
;
2372 unsigned int ngamma_tests
; /* Number of gamma tests to run*/
2373 double current_gamma
; /* 0 if not set */
2374 const color_encoding
*encodings
;
2375 unsigned int nencodings
;
2376 const color_encoding
*current_encoding
; /* If an encoding has been set */
2377 unsigned int encoding_counter
; /* For iteration */
2378 int encoding_ignored
; /* Something overwrote it */
2380 /* Control variables used to iterate through possible encodings, the
2381 * following must be set to 0 and tested by the function that uses the
2382 * png_modifier because the modifier only sets it to 1 (true.)
2384 unsigned int repeat
:1; /* Repeat this transform test. */
2385 unsigned int test_uses_encoding
:1;
2387 /* Lowest sbit to test (pre-1.7 libpng fails for sbit < 8) */
2390 /* Error control - these are the limits on errors accepted by the gamma tests
2393 double maxout8
; /* Maximum output value error */
2394 double maxabs8
; /* Absolute sample error 0..1 */
2395 double maxcalc8
; /* Absolute sample error 0..1 */
2396 double maxpc8
; /* Percentage sample error 0..100% */
2397 double maxout16
; /* Maximum output value error */
2398 double maxabs16
; /* Absolute sample error 0..1 */
2399 double maxcalc16
;/* Absolute sample error 0..1 */
2400 double maxcalcG
; /* Absolute sample error 0..1 */
2401 double maxpc16
; /* Percentage sample error 0..100% */
2403 /* This is set by transforms that need to allow a higher limit, it is an
2404 * internal check on pngvalid to ensure that the calculated error limits are
2405 * not ridiculous; without this it is too easy to make a mistake in pngvalid
2406 * that allows any value through.
2408 * NOTE: this is not checked in release builds.
2410 double limit
; /* limit on error values, normally 4E-3 */
2412 /* Log limits - values above this are logged, but not necessarily
2415 double log8
; /* Absolute error in 8 bits to log */
2416 double log16
; /* Absolute error in 16 bits to log */
2418 /* Logged 8 and 16 bit errors ('output' values): */
2419 double error_gray_2
;
2420 double error_gray_4
;
2421 double error_gray_8
;
2422 double error_gray_16
;
2423 double error_color_8
;
2424 double error_color_16
;
2425 double error_indexed
;
2428 /* Whether to call png_read_update_info, not png_read_start_image, and how
2429 * many times to call it.
2431 int use_update_info
;
2433 /* Whether or not to interlace. */
2434 int interlace_type
:9; /* int, but must store '1' */
2436 /* Run the standard tests? */
2437 unsigned int test_standard
:1;
2439 /* Run the odd-sized image and interlace read/write tests? */
2440 unsigned int test_size
:1;
2442 /* Run tests on reading with a combination of transforms, */
2443 unsigned int test_transform
:1;
2444 unsigned int test_tRNS
:1; /* Includes tRNS images */
2446 /* When to use the use_input_precision option, this controls the gamma
2447 * validation code checks. If set any value that is within the transformed
2448 * range input-.5 to input+.5 will be accepted, otherwise the value must be
2449 * within the normal limits. It should not be necessary to set this; the
2450 * result should always be exact within the permitted error limits.
2452 unsigned int use_input_precision
:1;
2453 unsigned int use_input_precision_sbit
:1;
2454 unsigned int use_input_precision_16to8
:1;
2456 /* If set assume that the calculation bit depth is set by the input
2457 * precision, not the output precision.
2459 unsigned int calculations_use_input_precision
:1;
2461 /* If set assume that the calculations are done in 16 bits even if the sample
2464 unsigned int assume_16_bit_calculations
:1;
2466 /* Which gamma tests to run: */
2467 unsigned int test_gamma_threshold
:1;
2468 unsigned int test_gamma_transform
:1; /* main tests */
2469 unsigned int test_gamma_sbit
:1;
2470 unsigned int test_gamma_scale16
:1;
2471 unsigned int test_gamma_background
:1;
2472 unsigned int test_gamma_alpha_mode
:1;
2473 unsigned int test_gamma_expand16
:1;
2474 unsigned int test_exhaustive
:1;
2476 /* Whether or not to run the low-bit-depth grayscale tests. This fails on
2477 * gamma images in some cases because of gross inaccuracies in the grayscale
2478 * gamma handling for low bit depth.
2480 unsigned int test_lbg
:1;
2481 unsigned int test_lbg_gamma_threshold
:1;
2482 unsigned int test_lbg_gamma_transform
:1;
2483 unsigned int test_lbg_gamma_sbit
:1;
2484 unsigned int test_lbg_gamma_composition
:1;
2486 unsigned int log
:1; /* Log max error */
2488 /* Buffer information, the buffer size limits the size of the chunks that can
2489 * be modified - they must fit (including header and CRC) into the buffer!
2491 size_t flush
; /* Count of bytes to flush */
2492 size_t buffer_count
; /* Bytes in buffer */
2493 size_t buffer_position
; /* Position in buffer */
2494 png_byte buffer
[1024];
2497 /* This returns true if the test should be stopped now because it has already
2498 * failed and it is running silently.
2500 static int fail(png_modifier
*pm
)
2502 return !pm
->log
&& !pm
->this.verbose
&& (pm
->this.nerrors
> 0 ||
2503 (pm
->this.treat_warnings_as_errors
&& pm
->this.nwarnings
> 0));
2507 modifier_init(png_modifier
*pm
)
2509 memset(pm
, 0, sizeof *pm
);
2510 store_init(&pm
->this);
2511 pm
->modifications
= NULL
;
2512 pm
->state
= modifier_start
;
2515 pm
->ngamma_tests
= 0;
2517 pm
->current_gamma
= 0;
2520 pm
->current_encoding
= 0;
2521 pm
->encoding_counter
= 0;
2522 pm
->encoding_ignored
= 0;
2524 pm
->test_uses_encoding
= 0;
2525 pm
->maxout8
= pm
->maxpc8
= pm
->maxabs8
= pm
->maxcalc8
= 0;
2526 pm
->maxout16
= pm
->maxpc16
= pm
->maxabs16
= pm
->maxcalc16
= 0;
2529 pm
->log8
= pm
->log16
= 0; /* Means 'off' */
2530 pm
->error_gray_2
= pm
->error_gray_4
= pm
->error_gray_8
= 0;
2531 pm
->error_gray_16
= pm
->error_color_8
= pm
->error_color_16
= 0;
2532 pm
->error_indexed
= 0;
2533 pm
->use_update_info
= 0;
2534 pm
->interlace_type
= PNG_INTERLACE_NONE
;
2535 pm
->test_standard
= 0;
2537 pm
->test_transform
= 0;
2538 # ifdef PNG_WRITE_tRNS_SUPPORTED
2543 pm
->use_input_precision
= 0;
2544 pm
->use_input_precision_sbit
= 0;
2545 pm
->use_input_precision_16to8
= 0;
2546 pm
->calculations_use_input_precision
= 0;
2547 pm
->assume_16_bit_calculations
= 0;
2548 pm
->test_gamma_threshold
= 0;
2549 pm
->test_gamma_transform
= 0;
2550 pm
->test_gamma_sbit
= 0;
2551 pm
->test_gamma_scale16
= 0;
2552 pm
->test_gamma_background
= 0;
2553 pm
->test_gamma_alpha_mode
= 0;
2554 pm
->test_gamma_expand16
= 0;
2556 pm
->test_lbg_gamma_threshold
= 1;
2557 pm
->test_lbg_gamma_transform
= 1;
2558 pm
->test_lbg_gamma_sbit
= 1;
2559 pm
->test_lbg_gamma_composition
= 1;
2560 pm
->test_exhaustive
= 0;
2563 /* Rely on the memset for all the other fields - there are no pointers */
2566 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
2568 /* This controls use of checks that explicitly know how libpng digitizes the
2569 * samples in calculations; setting this circumvents simple error limit checking
2570 * in the rgb_to_gray check, replacing it with an exact copy of the libpng 1.5
2573 #define DIGITIZE PNG_LIBPNG_VER < 10700
2575 /* If pm->calculations_use_input_precision is set then operations will happen
2576 * with the precision of the input, not the precision of the output depth.
2578 * If pm->assume_16_bit_calculations is set then even 8 bit calculations use 16
2579 * bit precision. This only affects those of the following limits that pertain
2580 * to a calculation - not a digitization operation - unless the following API is
2583 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
2585 static double digitize(double value
, int depth
, int do_round
)
2587 /* 'value' is in the range 0 to 1, the result is the same value rounded to a
2588 * multiple of the digitization factor - 8 or 16 bits depending on both the
2589 * sample depth and the 'assume' setting. Digitization is normally by
2590 * rounding and 'do_round' should be 1, if it is 0 the digitized value will
2593 unsigned int digitization_factor
= (1U << depth
) - 1;
2595 /* Limiting the range is done as a convenience to the caller - it's easier to
2596 * do it once here than every time at the call site.
2601 else if (value
>= 1)
2604 value
*= digitization_factor
;
2605 if (do_round
) value
+= .5;
2606 return floor(value
)/digitization_factor
;
2609 #endif /* RGB_TO_GRAY */
2611 #ifdef PNG_READ_GAMMA_SUPPORTED
2612 static double abserr(const png_modifier
*pm
, int in_depth
, int out_depth
)
2614 /* Absolute error permitted in linear values - affected by the bit depth of
2617 if (pm
->assume_16_bit_calculations
||
2618 (pm
->calculations_use_input_precision
? in_depth
: out_depth
) == 16)
2619 return pm
->maxabs16
;
2624 static double calcerr(const png_modifier
*pm
, int in_depth
, int out_depth
)
2626 /* Error in the linear composition arithmetic - only relevant when
2627 * composition actually happens (0 < alpha < 1).
2629 if ((pm
->calculations_use_input_precision
? in_depth
: out_depth
) == 16)
2630 return pm
->maxcalc16
;
2631 else if (pm
->assume_16_bit_calculations
)
2632 return pm
->maxcalcG
;
2634 return pm
->maxcalc8
;
2637 static double pcerr(const png_modifier
*pm
, int in_depth
, int out_depth
)
2639 /* Percentage error permitted in the linear values. Note that the specified
2640 * value is a percentage but this routine returns a simple number.
2642 if (pm
->assume_16_bit_calculations
||
2643 (pm
->calculations_use_input_precision
? in_depth
: out_depth
) == 16)
2644 return pm
->maxpc16
* .01;
2646 return pm
->maxpc8
* .01;
2649 /* Output error - the error in the encoded value. This is determined by the
2650 * digitization of the output so can be +/-0.5 in the actual output value. In
2651 * the expand_16 case with the current code in libpng the expand happens after
2652 * all the calculations are done in 8 bit arithmetic, so even though the output
2653 * depth is 16 the output error is determined by the 8 bit calculation.
2655 * This limit is not determined by the bit depth of internal calculations.
2657 * The specified parameter does *not* include the base .5 digitization error but
2660 static double outerr(const png_modifier
*pm
, int in_depth
, int out_depth
)
2662 /* There is a serious error in the 2 and 4 bit grayscale transform because
2663 * the gamma table value (8 bits) is simply shifted, not rounded, so the
2664 * error in 4 bit grayscale gamma is up to the value below. This is a hack
2665 * to allow pngvalid to succeed:
2667 * TODO: fix this in libpng
2675 if ((pm
->calculations_use_input_precision
? in_depth
: out_depth
) == 16)
2676 return pm
->maxout16
;
2678 /* This is the case where the value was calculated at 8-bit precision then
2679 * scaled to 16 bits.
2681 else if (out_depth
== 16)
2682 return pm
->maxout8
* 257;
2688 /* This does the same thing as the above however it returns the value to log,
2689 * rather than raising a warning. This is useful for debugging to track down
2690 * exactly what set of parameters cause high error values.
2692 static double outlog(const png_modifier
*pm
, int in_depth
, int out_depth
)
2694 /* The command line parameters are either 8 bit (0..255) or 16 bit (0..65535)
2695 * and so must be adjusted for low bit depth grayscale:
2699 if (pm
->log8
== 0) /* switched off */
2703 return pm
->log8
/ 255 * ((1<<out_depth
)-1);
2708 if ((pm
->calculations_use_input_precision
? in_depth
: out_depth
) == 16)
2716 /* This is the case where the value was calculated at 8-bit precision then
2717 * scaled to 16 bits.
2722 return pm
->log8
* 257;
2725 /* This complements the above by providing the appropriate quantization for the
2726 * final value. Normally this would just be quantization to an integral value,
2727 * but in the 8 bit calculation case it's actually quantization to a multiple of
2730 static int output_quantization_factor(const png_modifier
*pm
, int in_depth
,
2733 if (out_depth
== 16 && in_depth
!= 16 &&
2734 pm
->calculations_use_input_precision
)
2739 #endif /* PNG_READ_GAMMA_SUPPORTED */
2741 /* One modification structure must be provided for each chunk to be modified (in
2742 * fact more than one can be provided if multiple separate changes are desired
2743 * for a single chunk.) Modifications include adding a new chunk when a
2744 * suitable chunk does not exist.
2746 * The caller of modify_fn will reset the CRC of the chunk and record 'modified'
2747 * or 'added' as appropriate if the modify_fn returns 1 (true). If the
2748 * modify_fn is NULL the chunk is simply removed.
2750 typedef struct png_modification
2752 struct png_modification
*next
;
2755 /* If the following is NULL all matching chunks will be removed: */
2756 int (*modify_fn
)(struct png_modifier
*pm
,
2757 struct png_modification
*me
, int add
);
2759 /* If the following is set to PLTE, IDAT or IEND and the chunk has not been
2760 * found and modified (and there is a modify_fn) the modify_fn will be called
2761 * to add the chunk before the relevant chunk.
2764 unsigned int modified
:1; /* Chunk was modified */
2765 unsigned int added
:1; /* Chunk was added */
2766 unsigned int removed
:1; /* Chunk was removed */
2770 modification_reset(png_modification
*pmm
)
2777 modification_reset(pmm
->next
);
2782 modification_init(png_modification
*pmm
)
2784 memset(pmm
, 0, sizeof *pmm
);
2787 pmm
->modify_fn
= NULL
;
2789 modification_reset(pmm
);
2792 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
2794 modifier_current_encoding(const png_modifier
*pm
, color_encoding
*ce
)
2796 if (pm
->current_encoding
!= 0)
2797 *ce
= *pm
->current_encoding
;
2800 memset(ce
, 0, sizeof *ce
);
2802 ce
->gamma
= pm
->current_gamma
;
2806 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
2808 safecat_current_encoding(char *buffer
, size_t bufsize
, size_t pos
,
2809 const png_modifier
*pm
)
2811 pos
= safecat_color_encoding(buffer
, bufsize
, pos
, pm
->current_encoding
,
2814 if (pm
->encoding_ignored
)
2815 pos
= safecat(buffer
, bufsize
, pos
, "[overridden]");
2821 /* Iterate through the usefully testable color encodings. An encoding is one
2824 * 1) Nothing (no color space, no gamma).
2825 * 2) Just a gamma value from the gamma array (including 1.0)
2826 * 3) A color space from the encodings array with the corresponding gamma.
2827 * 4) The same, but with gamma 1.0 (only really useful with 16 bit calculations)
2829 * The iterator selects these in turn, the randomizer selects one at random,
2830 * which is used depends on the setting of the 'test_exhaustive' flag. Notice
2831 * that this function changes the colour space encoding so it must only be
2832 * called on completion of the previous test. This is what 'modifier_reset'
2835 * After the function has been called the 'repeat' flag will still be set; the
2836 * caller of modifier_reset must reset it at the start of each run of the test!
2839 modifier_total_encodings(const png_modifier
*pm
)
2841 return 1 + /* (1) nothing */
2842 pm
->ngammas
+ /* (2) gamma values to test */
2843 pm
->nencodings
+ /* (3) total number of encodings */
2844 /* The following test only works after the first time through the
2845 * png_modifier code because 'bit_depth' is set when the IHDR is read.
2846 * modifier_reset, below, preserves the setting until after it has called
2847 * the iterate function (also below.)
2849 * For this reason do not rely on this function outside a call to
2852 ((pm
->bit_depth
== 16 || pm
->assume_16_bit_calculations
) ?
2853 pm
->nencodings
: 0); /* (4) encodings with gamma == 1.0 */
2857 modifier_encoding_iterate(png_modifier
*pm
)
2859 if (!pm
->repeat
&& /* Else something needs the current encoding again. */
2860 pm
->test_uses_encoding
) /* Some transform is encoding dependent */
2862 if (pm
->test_exhaustive
)
2864 if (++pm
->encoding_counter
>= modifier_total_encodings(pm
))
2865 pm
->encoding_counter
= 0; /* This will stop the repeat */
2870 /* Not exhaustive - choose an encoding at random; generate a number in
2871 * the range 1..(max-1), so the result is always non-zero:
2873 if (pm
->encoding_counter
== 0)
2874 pm
->encoding_counter
= random_mod(modifier_total_encodings(pm
)-1)+1;
2876 pm
->encoding_counter
= 0;
2879 if (pm
->encoding_counter
> 0)
2883 else if (!pm
->repeat
)
2884 pm
->encoding_counter
= 0;
2888 modifier_reset(png_modifier
*pm
)
2890 store_read_reset(&pm
->this);
2892 pm
->pending_len
= pm
->pending_chunk
= 0;
2893 pm
->flush
= pm
->buffer_count
= pm
->buffer_position
= 0;
2894 pm
->modifications
= NULL
;
2895 pm
->state
= modifier_start
;
2896 modifier_encoding_iterate(pm
);
2897 /* The following must be set in the next run. In particular
2898 * test_uses_encodings must be set in the _ini function of each transform
2899 * that looks at the encodings. (Not the 'add' function!)
2901 pm
->test_uses_encoding
= 0;
2902 pm
->current_gamma
= 0;
2903 pm
->current_encoding
= 0;
2904 pm
->encoding_ignored
= 0;
2905 /* These only become value after IHDR is read: */
2906 pm
->bit_depth
= pm
->colour_type
= 0;
2909 /* The following must be called before anything else to get the encoding set up
2910 * on the modifier. In particular it must be called before the transform init
2911 * functions are called.
2914 modifier_set_encoding(png_modifier
*pm
)
2916 /* Set the encoding to the one specified by the current encoding counter,
2917 * first clear out all the settings - this corresponds to an encoding_counter
2920 pm
->current_gamma
= 0;
2921 pm
->current_encoding
= 0;
2922 pm
->encoding_ignored
= 0; /* not ignored yet - happens in _ini functions. */
2924 /* Now, if required, set the gamma and encoding fields. */
2925 if (pm
->encoding_counter
> 0)
2927 /* The gammas[] array is an array of screen gammas, not encoding gammas,
2928 * so we need the inverse:
2930 if (pm
->encoding_counter
<= pm
->ngammas
)
2931 pm
->current_gamma
= 1/pm
->gammas
[pm
->encoding_counter
-1];
2935 unsigned int i
= pm
->encoding_counter
- pm
->ngammas
;
2937 if (i
>= pm
->nencodings
)
2939 i
%= pm
->nencodings
;
2940 pm
->current_gamma
= 1; /* Linear, only in the 16 bit case */
2944 pm
->current_gamma
= pm
->encodings
[i
].gamma
;
2946 pm
->current_encoding
= pm
->encodings
+ i
;
2951 /* Enquiry functions to find out what is set. Notice that there is an implicit
2952 * assumption below that the first encoding in the list is the one for sRGB.
2955 modifier_color_encoding_is_sRGB(const png_modifier
*pm
)
2957 return pm
->current_encoding
!= 0 && pm
->current_encoding
== pm
->encodings
&&
2958 pm
->current_encoding
->gamma
== pm
->current_gamma
;
2962 modifier_color_encoding_is_set(const png_modifier
*pm
)
2964 return pm
->current_gamma
!= 0;
2967 /* The guts of modification are performed during a read. */
2969 modifier_crc(png_bytep buffer
)
2971 /* Recalculate the chunk CRC - a complete chunk must be in
2972 * the buffer, at the start.
2974 uInt datalen
= png_get_uint_32(buffer
);
2975 uLong crc
= crc32(0, buffer
+4, datalen
+4);
2976 /* The cast to png_uint_32 is safe because a crc32 is always a 32 bit value.
2978 png_save_uint_32(buffer
+datalen
+8, (png_uint_32
)crc
);
2982 modifier_setbuffer(png_modifier
*pm
)
2984 modifier_crc(pm
->buffer
);
2985 pm
->buffer_count
= png_get_uint_32(pm
->buffer
)+12;
2986 pm
->buffer_position
= 0;
2989 /* Separate the callback into the actual implementation (which is passed the
2990 * png_modifier explicitly) and the callback, which gets the modifier from the
2994 modifier_read_imp(png_modifier
*pm
, png_bytep pb
, size_t st
)
2999 png_uint_32 len
, chunk
;
3000 png_modification
*mod
;
3002 if (pm
->buffer_position
>= pm
->buffer_count
) switch (pm
->state
)
3004 static png_byte sign
[8] = { 137, 80, 78, 71, 13, 10, 26, 10 };
3005 case modifier_start
:
3006 store_read_chunk(&pm
->this, pm
->buffer
, 8, 8); /* signature. */
3007 pm
->buffer_count
= 8;
3008 pm
->buffer_position
= 0;
3010 if (memcmp(pm
->buffer
, sign
, 8) != 0)
3011 png_error(pm
->this.pread
, "invalid PNG file signature");
3012 pm
->state
= modifier_signature
;
3015 case modifier_signature
:
3016 store_read_chunk(&pm
->this, pm
->buffer
, 13+12, 13+12); /* IHDR */
3017 pm
->buffer_count
= 13+12;
3018 pm
->buffer_position
= 0;
3020 if (png_get_uint_32(pm
->buffer
) != 13 ||
3021 png_get_uint_32(pm
->buffer
+4) != CHUNK_IHDR
)
3022 png_error(pm
->this.pread
, "invalid IHDR");
3024 /* Check the list of modifiers for modifications to the IHDR. */
3025 mod
= pm
->modifications
;
3028 if (mod
->chunk
== CHUNK_IHDR
&& mod
->modify_fn
&&
3029 (*mod
->modify_fn
)(pm
, mod
, 0))
3032 modifier_setbuffer(pm
);
3035 /* Ignore removal or add if IHDR! */
3039 /* Cache information from the IHDR (the modified one.) */
3040 pm
->bit_depth
= pm
->buffer
[8+8];
3041 pm
->colour_type
= pm
->buffer
[8+8+1];
3043 pm
->state
= modifier_IHDR
;
3049 /* Read a new chunk and process it until we see PLTE, IDAT or
3050 * IEND. 'flush' indicates that there is still some data to
3051 * output from the preceding chunk.
3053 if ((cb
= pm
->flush
) > 0)
3055 if (cb
> st
) cb
= st
;
3057 store_read_chunk(&pm
->this, pb
, cb
, cb
);
3060 if (st
== 0) return;
3063 /* No more bytes to flush, read a header, or handle a pending
3066 if (pm
->pending_chunk
!= 0)
3068 png_save_uint_32(pm
->buffer
, pm
->pending_len
);
3069 png_save_uint_32(pm
->buffer
+4, pm
->pending_chunk
);
3070 pm
->pending_len
= 0;
3071 pm
->pending_chunk
= 0;
3074 store_read_chunk(&pm
->this, pm
->buffer
, 8, 8);
3076 pm
->buffer_count
= 8;
3077 pm
->buffer_position
= 0;
3079 /* Check for something to modify or a terminator chunk. */
3080 len
= png_get_uint_32(pm
->buffer
);
3081 chunk
= png_get_uint_32(pm
->buffer
+4);
3083 /* Terminators first, they may have to be delayed for added
3086 if (chunk
== CHUNK_PLTE
|| chunk
== CHUNK_IDAT
||
3087 chunk
== CHUNK_IEND
)
3089 mod
= pm
->modifications
;
3093 if ((mod
->add
== chunk
||
3094 (mod
->add
== CHUNK_PLTE
&& chunk
== CHUNK_IDAT
)) &&
3095 mod
->modify_fn
!= NULL
&& !mod
->modified
&& !mod
->added
)
3097 /* Regardless of what the modify function does do not run
3102 if ((*mod
->modify_fn
)(pm
, mod
, 1 /*add*/))
3104 /* Reset the CRC on a new chunk */
3105 if (pm
->buffer_count
> 0)
3106 modifier_setbuffer(pm
);
3110 pm
->buffer_position
= 0;
3114 /* The buffer has been filled with something (we assume)
3115 * so output this. Pend the current chunk.
3117 pm
->pending_len
= len
;
3118 pm
->pending_chunk
= chunk
;
3119 break; /* out of while */
3126 /* Don't do any further processing if the buffer was modified -
3127 * otherwise the code will end up modifying a chunk that was
3131 break; /* out of switch */
3134 /* If we get to here then this chunk may need to be modified. To
3135 * do this it must be less than 1024 bytes in total size, otherwise
3136 * it just gets flushed.
3138 if (len
+12 <= sizeof pm
->buffer
)
3140 size_t s
= len
+12-pm
->buffer_count
;
3141 store_read_chunk(&pm
->this, pm
->buffer
+pm
->buffer_count
, s
, s
);
3142 pm
->buffer_count
= len
+12;
3144 /* Check for a modification, else leave it be. */
3145 mod
= pm
->modifications
;
3148 if (mod
->chunk
== chunk
)
3150 if (mod
->modify_fn
== NULL
)
3152 /* Remove this chunk */
3153 pm
->buffer_count
= pm
->buffer_position
= 0;
3155 break; /* Terminate the while loop */
3158 else if ((*mod
->modify_fn
)(pm
, mod
, 0))
3161 /* The chunk may have been removed: */
3162 if (pm
->buffer_count
== 0)
3164 pm
->buffer_position
= 0;
3167 modifier_setbuffer(pm
);
3176 pm
->flush
= len
+12 - pm
->buffer_count
; /* data + crc */
3178 /* Take the data from the buffer (if there is any). */
3182 /* Here to read from the modifier buffer (not directly from
3183 * the store, as in the flush case above.)
3185 cb
= pm
->buffer_count
- pm
->buffer_position
;
3190 memcpy(pb
, pm
->buffer
+ pm
->buffer_position
, cb
);
3193 pm
->buffer_position
+= cb
;
3198 static void PNGCBAPI
3199 modifier_read(png_structp ppIn
, png_bytep pb
, size_t st
)
3201 png_const_structp pp
= ppIn
;
3202 png_modifier
*pm
= voidcast(png_modifier
*, png_get_io_ptr(pp
));
3204 if (pm
== NULL
|| pm
->this.pread
!= pp
)
3205 png_error(pp
, "bad modifier_read call");
3207 modifier_read_imp(pm
, pb
, st
);
3210 /* Like store_progressive_read but the data is getting changed as we go so we
3211 * need a local buffer.
3214 modifier_progressive_read(png_modifier
*pm
, png_structp pp
, png_infop pi
)
3216 if (pm
->this.pread
!= pp
|| pm
->this.current
== NULL
||
3217 pm
->this.next
== NULL
)
3218 png_error(pp
, "store state damaged (progressive)");
3220 /* This is another Horowitz and Hill random noise generator. In this case
3221 * the aim is to stress the progressive reader with truly horrible variable
3222 * buffer sizes in the range 1..500, so a sequence of 9 bit random numbers
3223 * is generated. We could probably just count from 1 to 32767 and get as
3228 static png_uint_32 noise
= 1;
3230 png_byte buffer
[512];
3232 /* Generate 15 more bits of stuff: */
3233 noise
= (noise
<< 9) | ((noise
^ (noise
>> (9-5))) & 0x1ff);
3236 /* Check that this number of bytes are available (in the current buffer.)
3237 * (This doesn't quite work - the modifier might delete a chunk; unlikely
3238 * but possible, it doesn't happen at present because the modifier only
3239 * adds chunks to standard images.)
3241 cbAvail
= store_read_buffer_avail(&pm
->this);
3242 if (pm
->buffer_count
> pm
->buffer_position
)
3243 cbAvail
+= pm
->buffer_count
- pm
->buffer_position
;
3247 /* Check for EOF: */
3254 modifier_read_imp(pm
, buffer
, cb
);
3255 png_process_data(pp
, pi
, buffer
, cb
);
3258 /* Check the invariants at the end (if this fails it's a problem in this
3261 if (pm
->buffer_count
> pm
->buffer_position
||
3262 pm
->this.next
!= &pm
->this.current
->data
||
3263 pm
->this.readpos
< pm
->this.current
->datacount
)
3264 png_error(pp
, "progressive read implementation error");
3267 /* Set up a modifier. */
3269 set_modifier_for_read(png_modifier
*pm
, png_infopp ppi
, png_uint_32 id
,
3272 /* Do this first so that the modifier fields are cleared even if an error
3273 * happens allocating the png_struct. No allocation is done here so no
3274 * cleanup is required.
3276 pm
->state
= modifier_start
;
3278 pm
->colour_type
= 255;
3280 pm
->pending_len
= 0;
3281 pm
->pending_chunk
= 0;
3283 pm
->buffer_count
= 0;
3284 pm
->buffer_position
= 0;
3286 return set_store_for_read(&pm
->this, ppi
, id
, name
);
3290 /******************************** MODIFICATIONS *******************************/
3291 /* Standard modifications to add chunks. These do not require the _SUPPORTED
3292 * macros because the chunks can be there regardless of whether this specific
3293 * libpng supports them.
3295 typedef struct gama_modification
3297 png_modification
this;
3298 png_fixed_point gamma
;
3299 } gama_modification
;
3302 gama_modify(png_modifier
*pm
, png_modification
*me
, int add
)
3305 /* This simply dumps the given gamma value into the buffer. */
3306 png_save_uint_32(pm
->buffer
, 4);
3307 png_save_uint_32(pm
->buffer
+4, CHUNK_gAMA
);
3308 png_save_uint_32(pm
->buffer
+8, ((gama_modification
*)me
)->gamma
);
3313 gama_modification_init(gama_modification
*me
, png_modifier
*pm
, double gammad
)
3317 modification_init(&me
->this);
3318 me
->this.chunk
= CHUNK_gAMA
;
3319 me
->this.modify_fn
= gama_modify
;
3320 me
->this.add
= CHUNK_PLTE
;
3322 me
->gamma
= (png_fixed_point
)g
;
3323 me
->this.next
= pm
->modifications
;
3324 pm
->modifications
= &me
->this;
3327 typedef struct chrm_modification
3329 png_modification
this;
3330 const color_encoding
*encoding
;
3331 png_fixed_point wx
, wy
, rx
, ry
, gx
, gy
, bx
, by
;
3332 } chrm_modification
;
3335 chrm_modify(png_modifier
*pm
, png_modification
*me
, int add
)
3338 /* As with gAMA this just adds the required cHRM chunk to the buffer. */
3339 png_save_uint_32(pm
->buffer
, 32);
3340 png_save_uint_32(pm
->buffer
+ 4, CHUNK_cHRM
);
3341 png_save_uint_32(pm
->buffer
+ 8, ((chrm_modification
*)me
)->wx
);
3342 png_save_uint_32(pm
->buffer
+12, ((chrm_modification
*)me
)->wy
);
3343 png_save_uint_32(pm
->buffer
+16, ((chrm_modification
*)me
)->rx
);
3344 png_save_uint_32(pm
->buffer
+20, ((chrm_modification
*)me
)->ry
);
3345 png_save_uint_32(pm
->buffer
+24, ((chrm_modification
*)me
)->gx
);
3346 png_save_uint_32(pm
->buffer
+28, ((chrm_modification
*)me
)->gy
);
3347 png_save_uint_32(pm
->buffer
+32, ((chrm_modification
*)me
)->bx
);
3348 png_save_uint_32(pm
->buffer
+36, ((chrm_modification
*)me
)->by
);
3353 chrm_modification_init(chrm_modification
*me
, png_modifier
*pm
,
3354 const color_encoding
*encoding
)
3356 CIE_color white
= white_point(encoding
);
3358 /* Original end points: */
3359 me
->encoding
= encoding
;
3361 /* Chromaticities (in fixed point): */
3362 me
->wx
= fix(chromaticity_x(white
));
3363 me
->wy
= fix(chromaticity_y(white
));
3365 me
->rx
= fix(chromaticity_x(encoding
->red
));
3366 me
->ry
= fix(chromaticity_y(encoding
->red
));
3367 me
->gx
= fix(chromaticity_x(encoding
->green
));
3368 me
->gy
= fix(chromaticity_y(encoding
->green
));
3369 me
->bx
= fix(chromaticity_x(encoding
->blue
));
3370 me
->by
= fix(chromaticity_y(encoding
->blue
));
3372 modification_init(&me
->this);
3373 me
->this.chunk
= CHUNK_cHRM
;
3374 me
->this.modify_fn
= chrm_modify
;
3375 me
->this.add
= CHUNK_PLTE
;
3376 me
->this.next
= pm
->modifications
;
3377 pm
->modifications
= &me
->this;
3380 typedef struct srgb_modification
3382 png_modification
this;
3384 } srgb_modification
;
3387 srgb_modify(png_modifier
*pm
, png_modification
*me
, int add
)
3390 /* As above, ignore add and just make a new chunk */
3391 png_save_uint_32(pm
->buffer
, 1);
3392 png_save_uint_32(pm
->buffer
+4, CHUNK_sRGB
);
3393 pm
->buffer
[8] = ((srgb_modification
*)me
)->intent
;
3398 srgb_modification_init(srgb_modification
*me
, png_modifier
*pm
, png_byte intent
)
3400 modification_init(&me
->this);
3401 me
->this.chunk
= CHUNK_sBIT
;
3403 if (intent
<= 3) /* if valid, else *delete* sRGB chunks */
3405 me
->this.modify_fn
= srgb_modify
;
3406 me
->this.add
= CHUNK_PLTE
;
3407 me
->intent
= intent
;
3412 me
->this.modify_fn
= 0;
3417 me
->this.next
= pm
->modifications
;
3418 pm
->modifications
= &me
->this;
3421 #ifdef PNG_READ_GAMMA_SUPPORTED
3422 typedef struct sbit_modification
3424 png_modification
this;
3426 } sbit_modification
;
3429 sbit_modify(png_modifier
*pm
, png_modification
*me
, int add
)
3431 png_byte sbit
= ((sbit_modification
*)me
)->sbit
;
3432 if (pm
->bit_depth
> sbit
)
3435 switch (pm
->colour_type
)
3455 png_error(pm
->this.pread
,
3456 "unexpected colour type in sBIT modification");
3459 png_save_uint_32(pm
->buffer
, cb
);
3460 png_save_uint_32(pm
->buffer
+4, CHUNK_sBIT
);
3463 (pm
->buffer
+8)[--cb
] = sbit
;
3469 /* Remove the sBIT chunk */
3470 pm
->buffer_count
= pm
->buffer_position
= 0;
3474 return 0; /* do nothing */
3478 sbit_modification_init(sbit_modification
*me
, png_modifier
*pm
, png_byte sbit
)
3480 modification_init(&me
->this);
3481 me
->this.chunk
= CHUNK_sBIT
;
3482 me
->this.modify_fn
= sbit_modify
;
3483 me
->this.add
= CHUNK_PLTE
;
3485 me
->this.next
= pm
->modifications
;
3486 pm
->modifications
= &me
->this;
3488 #endif /* PNG_READ_GAMMA_SUPPORTED */
3489 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
3491 /***************************** STANDARD PNG FILES *****************************/
3492 /* Standard files - write and save standard files. */
3493 /* There are two basic forms of standard images. Those which attempt to have
3494 * all the possible pixel values (not possible for 16bpp images, but a range of
3495 * values are produced) and those which have a range of image sizes. The former
3496 * are used for testing transforms, in particular gamma correction and bit
3497 * reduction and increase. The latter are reserved for testing the behavior of
3498 * libpng with respect to 'odd' image sizes - particularly small images where
3499 * rows become 1 byte and interlace passes disappear.
3501 * The first, most useful, set are the 'transform' images, the second set of
3502 * small images are the 'size' images.
3504 * The transform files are constructed with rows which fit into a 1024 byte row
3505 * buffer. This makes allocation easier below. Further regardless of the file
3506 * format every row has 128 pixels (giving 1024 bytes for 64bpp formats).
3508 * Files are stored with no gAMA or sBIT chunks, with a PLTE only when needed
3509 * and with an ID derived from the colour type, bit depth and interlace type
3510 * as above (FILEID). The width (128) and height (variable) are not stored in
3511 * the FILEID - instead the fields are set to 0, indicating a transform file.
3513 * The size files ar constructed with rows a maximum of 128 bytes wide, allowing
3514 * a maximum width of 16 pixels (for the 64bpp case.) They also have a maximum
3515 * height of 16 rows. The width and height are stored in the FILEID and, being
3516 * non-zero, indicate a size file.
3518 * Because the PNG filter code is typically the largest CPU consumer within
3519 * libpng itself there is a tendency to attempt to optimize it. This results in
3520 * special case code which needs to be validated. To cause this to happen the
3521 * 'size' images are made to use each possible filter, in so far as this is
3522 * possible for smaller images.
3524 * For palette image (colour type 3) multiple transform images are stored with
3525 * the same bit depth to allow testing of more colour combinations -
3526 * particularly important for testing the gamma code because libpng uses a
3527 * different code path for palette images. For size images a single palette is
3531 /* Make a 'standard' palette. Because there are only 256 entries in a palette
3532 * (maximum) this actually makes a random palette in the hope that enough tests
3533 * will catch enough errors. (Note that the same palette isn't produced every
3534 * time for the same test - it depends on what previous tests have been run -
3535 * but a given set of arguments to pngvalid will always produce the same palette
3536 * at the same test! This is why pseudo-random number generators are useful for
3539 * The store must be open for write when this is called, otherwise an internal
3540 * error will occur. This routine contains its own magic number seed, so the
3541 * palettes generated don't change if there are intervening errors (changing the
3542 * calls to the store_mark seed.)
3544 static store_palette_entry
*
3545 make_standard_palette(png_store
* ps
, int npalette
, int do_tRNS
)
3547 static png_uint_32 palette_seed
[2] = { 0x87654321, 9 };
3550 png_byte values
[256][4];
3552 /* Always put in black and white plus the six primary and secondary colors.
3556 values
[i
][1] = (png_byte
)((i
&1) ? 255U : 0U);
3557 values
[i
][2] = (png_byte
)((i
&2) ? 255U : 0U);
3558 values
[i
][3] = (png_byte
)((i
&4) ? 255U : 0U);
3561 /* Then add 62 grays (one quarter of the remaining 256 slots). */
3564 png_byte random_bytes
[4];
3567 need
[0] = 0; /*got black*/
3568 memset(need
+1, 1, (sizeof need
)-2); /*need these*/
3569 need
[255] = 0; /*but not white*/
3577 make_four_random_bytes(palette_seed
, random_bytes
);
3581 b
= random_bytes
[--j
];
3591 /* Finally add 192 colors at random - don't worry about matches to things we
3592 * already have, chance is less than 1/65536. Don't worry about grays,
3593 * chance is the same, so we get a duplicate or extra gray less than 1 time
3597 make_four_random_bytes(palette_seed
, values
[i
]);
3599 /* Fill in the alpha values in the first byte. Just use all possible values
3600 * (0..255) in an apparently random order:
3603 store_palette_entry
*palette
;
3604 png_byte selector
[4];
3606 make_four_random_bytes(palette_seed
, selector
);
3609 for (i
=0; i
<256; ++i
)
3610 values
[i
][0] = (png_byte
)(i
^ selector
[0]);
3613 for (i
=0; i
<256; ++i
)
3614 values
[i
][0] = 255; /* no transparency/tRNS chunk */
3616 /* 'values' contains 256 ARGB values, but we only need 'npalette'.
3617 * 'npalette' will always be a power of 2: 2, 4, 16 or 256. In the low
3618 * bit depth cases select colors at random, else it is difficult to have
3619 * a set of low bit depth palette test with any chance of a reasonable
3620 * range of colors. Do this by randomly permuting values into the low
3621 * 'npalette' entries using an XOR mask generated here. This also
3622 * permutes the npalette == 256 case in a potentially useful way (there is
3623 * no relationship between palette index and the color value therein!)
3625 palette
= store_write_palette(ps
, npalette
);
3627 for (i
=0; i
<npalette
; ++i
)
3629 palette
[i
].alpha
= values
[i
^ selector
[1]][0];
3630 palette
[i
].red
= values
[i
^ selector
[1]][1];
3631 palette
[i
].green
= values
[i
^ selector
[1]][2];
3632 palette
[i
].blue
= values
[i
^ selector
[1]][3];
3639 /* Initialize a standard palette on a write stream. The 'do_tRNS' argument
3640 * indicates whether or not to also set the tRNS chunk.
3642 /* TODO: the png_structp here can probably be 'const' in the future */
3644 init_standard_palette(png_store
*ps
, png_structp pp
, png_infop pi
, int npalette
,
3647 store_palette_entry
*ppal
= make_standard_palette(ps
, npalette
, do_tRNS
);
3651 png_color palette
[256];
3653 /* Set all entries to detect overread errors. */
3654 for (i
=0; i
<npalette
; ++i
)
3656 palette
[i
].red
= ppal
[i
].red
;
3657 palette
[i
].green
= ppal
[i
].green
;
3658 palette
[i
].blue
= ppal
[i
].blue
;
3661 /* Just in case fill in the rest with detectable values: */
3663 palette
[i
].red
= palette
[i
].green
= palette
[i
].blue
= 42;
3665 png_set_PLTE(pp
, pi
, palette
, npalette
);
3673 /* Set all the entries, but skip trailing opaque entries */
3674 for (i
=j
=0; i
<npalette
; ++i
)
3675 if ((tRNS
[i
] = ppal
[i
].alpha
) < 255)
3678 /* Fill in the remainder with a detectable value: */
3682 #ifdef PNG_WRITE_tRNS_SUPPORTED
3684 png_set_tRNS(pp
, pi
, tRNS
, j
, 0/*color*/);
3689 #ifdef PNG_WRITE_tRNS_SUPPORTED
3691 set_random_tRNS(png_structp pp
, png_infop pi
, png_byte colour_type
,
3694 /* To make this useful the tRNS color needs to match at least one pixel.
3695 * Random values are fine for gray, including the 16-bit case where we know
3696 * that the test image contains all the gray values. For RGB we need more
3697 * method as only 65536 different RGB values are generated.
3700 png_uint_16 mask
= (png_uint_16
)((1U << bit_depth
)-1);
3702 R8(tRNS
); /* makes unset fields random */
3704 if (colour_type
& 2/*RGB*/)
3708 tRNS
.red
= random_u16();
3709 tRNS
.green
= random_u16();
3710 tRNS
.blue
= tRNS
.red
^ tRNS
.green
;
3716 else /* bit_depth == 16 */
3718 tRNS
.red
= random_u16();
3719 tRNS
.green
= (png_uint_16
)(tRNS
.red
* 257);
3720 tRNS
.blue
= (png_uint_16
)(tRNS
.green
* 17);
3726 tRNS
.gray
= random_u16();
3730 png_set_tRNS(pp
, pi
, NULL
, 0, &tRNS
);
3734 /* The number of passes is related to the interlace type. There was no libpng
3735 * API to determine this prior to 1.5, so we need an inquiry function:
3738 npasses_from_interlace_type(png_const_structp pp
, int interlace_type
)
3740 switch (interlace_type
)
3743 png_error(pp
, "invalid interlace type");
3745 case PNG_INTERLACE_NONE
:
3748 case PNG_INTERLACE_ADAM7
:
3749 return PNG_INTERLACE_ADAM7_PASSES
;
3754 bit_size(png_const_structp pp
, png_byte colour_type
, png_byte bit_depth
)
3756 switch (colour_type
)
3758 default: png_error(pp
, "invalid color type");
3760 case 0: return bit_depth
;
3762 case 2: return 3*bit_depth
;
3764 case 3: return bit_depth
;
3766 case 4: return 2*bit_depth
;
3768 case 6: return 4*bit_depth
;
3772 #define TRANSFORM_WIDTH 128U
3773 #define TRANSFORM_ROWMAX (TRANSFORM_WIDTH*8U)
3774 #define SIZE_ROWMAX (16*8U) /* 16 pixels, max 8 bytes each - 128 bytes */
3775 #define STANDARD_ROWMAX TRANSFORM_ROWMAX /* The larger of the two */
3776 #define SIZE_HEIGHTMAX 16 /* Maximum range of size images */
3779 transform_rowsize(png_const_structp pp
, png_byte colour_type
,
3782 return (TRANSFORM_WIDTH
* bit_size(pp
, colour_type
, bit_depth
)) / 8;
3785 /* transform_width(pp, colour_type, bit_depth) current returns the same number
3786 * every time, so just use a macro:
3788 #define transform_width(pp, colour_type, bit_depth) TRANSFORM_WIDTH
3791 transform_height(png_const_structp pp
, png_byte colour_type
, png_byte bit_depth
)
3793 switch (bit_size(pp
, colour_type
, bit_depth
))
3798 return 1; /* Total of 128 pixels */
3801 return 2; /* Total of 256 pixels/bytes */
3804 return 512; /* Total of 65536 pixels */
3808 return 512; /* 65536 pixels */
3812 return 2048;/* 4 x 65536 pixels. */
3813 # define TRANSFORM_HEIGHTMAX 2048
3816 return 0; /* Error, will be caught later */
3820 #ifdef PNG_READ_SUPPORTED
3821 /* The following can only be defined here, now we have the definitions
3822 * of the transform image sizes.
3825 standard_width(png_const_structp pp
, png_uint_32 id
)
3827 png_uint_32 width
= WIDTH_FROM_ID(id
);
3831 width
= transform_width(pp
, COL_FROM_ID(id
), DEPTH_FROM_ID(id
));
3837 standard_height(png_const_structp pp
, png_uint_32 id
)
3839 png_uint_32 height
= HEIGHT_FROM_ID(id
);
3842 height
= transform_height(pp
, COL_FROM_ID(id
), DEPTH_FROM_ID(id
));
3848 standard_rowsize(png_const_structp pp
, png_uint_32 id
)
3850 png_uint_32 width
= standard_width(pp
, id
);
3852 /* This won't overflow: */
3853 width
*= bit_size(pp
, COL_FROM_ID(id
), DEPTH_FROM_ID(id
));
3854 return (width
+ 7) / 8;
3856 #endif /* PNG_READ_SUPPORTED */
3859 transform_row(png_const_structp pp
, png_byte buffer
[TRANSFORM_ROWMAX
],
3860 png_byte colour_type
, png_byte bit_depth
, png_uint_32 y
)
3862 png_uint_32 v
= y
<< 7;
3865 switch (bit_size(pp
, colour_type
, bit_depth
))
3868 while (i
<128/8) buffer
[i
] = (png_byte
)(v
& 0xff), v
+= 17, ++i
;
3872 while (i
<128/4) buffer
[i
] = (png_byte
)(v
& 0xff), v
+= 33, ++i
;
3876 while (i
<128/2) buffer
[i
] = (png_byte
)(v
& 0xff), v
+= 65, ++i
;
3880 /* 256 bytes total, 128 bytes in each row set as follows: */
3881 while (i
<128) buffer
[i
] = (png_byte
)(v
& 0xff), ++v
, ++i
;
3885 /* Generate all 65536 pixel values in order, which includes the 8 bit
3886 * GA case as well as the 16 bit G case.
3890 buffer
[2*i
] = (png_byte
)((v
>>8) & 0xff);
3891 buffer
[2*i
+1] = (png_byte
)(v
& 0xff);
3899 /* 65535 pixels, but rotate the values. */
3902 /* Three bytes per pixel, r, g, b, make b by r^g */
3903 buffer
[3*i
+0] = (png_byte
)((v
>> 8) & 0xff);
3904 buffer
[3*i
+1] = (png_byte
)(v
& 0xff);
3905 buffer
[3*i
+2] = (png_byte
)(((v
>> 8) ^ v
) & 0xff);
3913 /* 65535 pixels, r, g, b, a; just replicate */
3916 buffer
[4*i
+0] = (png_byte
)((v
>> 8) & 0xff);
3917 buffer
[4*i
+1] = (png_byte
)(v
& 0xff);
3918 buffer
[4*i
+2] = (png_byte
)((v
>> 8) & 0xff);
3919 buffer
[4*i
+3] = (png_byte
)(v
& 0xff);
3927 /* y is maximum 2047, giving 4x65536 pixels, make 'r' increase by 1 at
3928 * each pixel, g increase by 257 (0x101) and 'b' by 0x1111:
3932 png_uint_32 t
= v
++;
3933 buffer
[6*i
+0] = (png_byte
)((t
>> 8) & 0xff);
3934 buffer
[6*i
+1] = (png_byte
)(t
& 0xff);
3936 buffer
[6*i
+2] = (png_byte
)((t
>> 8) & 0xff);
3937 buffer
[6*i
+3] = (png_byte
)(t
& 0xff);
3939 buffer
[6*i
+4] = (png_byte
)((t
>> 8) & 0xff);
3940 buffer
[6*i
+5] = (png_byte
)(t
& 0xff);
3947 /* As above in the 32 bit case. */
3950 png_uint_32 t
= v
++;
3951 buffer
[8*i
+0] = (png_byte
)((t
>> 8) & 0xff);
3952 buffer
[8*i
+1] = (png_byte
)(t
& 0xff);
3953 buffer
[8*i
+4] = (png_byte
)((t
>> 8) & 0xff);
3954 buffer
[8*i
+5] = (png_byte
)(t
& 0xff);
3956 buffer
[8*i
+2] = (png_byte
)((t
>> 8) & 0xff);
3957 buffer
[8*i
+3] = (png_byte
)(t
& 0xff);
3958 buffer
[8*i
+6] = (png_byte
)((t
>> 8) & 0xff);
3959 buffer
[8*i
+7] = (png_byte
)(t
& 0xff);
3968 png_error(pp
, "internal error");
3971 /* This is just to do the right cast - could be changed to a function to check
3972 * 'bd' but there isn't much point.
3974 #define DEPTH(bd) ((png_byte)(1U << (bd)))
3976 /* This is just a helper for compiling on minimal systems with no write
3977 * interlacing support. If there is no write interlacing we can't generate test
3978 * cases with interlace:
3980 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
3981 # define INTERLACE_LAST PNG_INTERLACE_LAST
3982 # define check_interlace_type(type) ((void)(type))
3983 # define set_write_interlace_handling(pp,type) png_set_interlace_handling(pp)
3984 # define do_own_interlace 0
3985 #elif PNG_LIBPNG_VER < 10700
3986 # define set_write_interlace_handling(pp,type) (1)
3988 check_interlace_type(int const interlace_type
)
3990 /* Prior to 1.7.0 libpng does not support the write of an interlaced image
3991 * unless PNG_WRITE_INTERLACING_SUPPORTED, even with do_interlace so the
3992 * code here does the pixel interlace itself, so:
3994 if (interlace_type
!= PNG_INTERLACE_NONE
)
3996 /* This is an internal error - --interlace tests should be skipped, not
3999 fprintf(stderr
, "pngvalid: no interlace support\n");
4003 # define INTERLACE_LAST (PNG_INTERLACE_NONE+1)
4004 # define do_own_interlace 0
4005 #else /* libpng 1.7+ */
4006 # define set_write_interlace_handling(pp,type)\
4007 npasses_from_interlace_type(pp,type)
4008 # define check_interlace_type(type) ((void)(type))
4009 # define INTERLACE_LAST PNG_INTERLACE_LAST
4010 # define do_own_interlace 1
4011 #endif /* WRITE_INTERLACING tests */
4013 #if PNG_LIBPNG_VER >= 10700 || defined PNG_WRITE_INTERLACING_SUPPORTED
4014 # define CAN_WRITE_INTERLACE 1
4016 # define CAN_WRITE_INTERLACE 0
4019 /* Do the same thing for read interlacing; this controls whether read tests do
4020 * their own de-interlace or use libpng.
4022 #ifdef PNG_READ_INTERLACING_SUPPORTED
4023 # define do_read_interlace 0
4024 #else /* no libpng read interlace support */
4025 # define do_read_interlace 1
4027 /* The following two routines use the PNG interlace support macros from
4028 * png.h to interlace or deinterlace rows.
4031 interlace_row(png_bytep buffer
, png_const_bytep imageRow
,
4032 unsigned int pixel_size
, png_uint_32 w
, int pass
, int littleendian
)
4034 png_uint_32 xin
, xout
, xstep
;
4036 /* Note that this can, trivially, be optimized to a memcpy on pass 7, the
4037 * code is presented this way to make it easier to understand. In practice
4038 * consult the code in the libpng source to see other ways of doing this.
4040 * It is OK for buffer and imageRow to be identical, because 'xin' moves
4041 * faster than 'xout' and we copy up.
4043 xin
= PNG_PASS_START_COL(pass
);
4044 xstep
= 1U<<PNG_PASS_COL_SHIFT(pass
);
4046 for (xout
=0; xin
<w
; xin
+=xstep
)
4048 pixel_copy(buffer
, xout
, imageRow
, xin
, pixel_size
, littleendian
);
4053 #ifdef PNG_READ_SUPPORTED
4055 deinterlace_row(png_bytep buffer
, png_const_bytep row
,
4056 unsigned int pixel_size
, png_uint_32 w
, int pass
, int littleendian
)
4058 /* The inverse of the above, 'row' is part of row 'y' of the output image,
4059 * in 'buffer'. The image is 'w' wide and this is pass 'pass', distribute
4060 * the pixels of row into buffer and return the number written (to allow
4061 * this to be checked).
4063 png_uint_32 xin
, xout
, xstep
;
4065 xout
= PNG_PASS_START_COL(pass
);
4066 xstep
= 1U<<PNG_PASS_COL_SHIFT(pass
);
4068 for (xin
=0; xout
<w
; xout
+=xstep
)
4070 pixel_copy(buffer
, xout
, row
, xin
, pixel_size
, littleendian
);
4074 #endif /* PNG_READ_SUPPORTED */
4076 /* Make a standardized image given an image colour type, bit depth and
4077 * interlace type. The standard images have a very restricted range of
4078 * rows and heights and are used for testing transforms rather than image
4079 * layout details. See make_size_images below for a way to make images
4080 * that test odd sizes along with the libpng interlace handling.
4082 #ifdef PNG_WRITE_FILTER_SUPPORTED
4084 choose_random_filter(png_structp pp
, int start
)
4086 /* Choose filters randomly except that on the very first row ensure that
4087 * there is at least one previous row filter.
4089 int filters
= PNG_ALL_FILTERS
& random_mod(256U);
4091 /* There may be no filters; skip the setting. */
4094 if (start
&& filters
< PNG_FILTER_UP
)
4095 filters
|= PNG_FILTER_UP
;
4097 png_set_filter(pp
, 0/*method*/, filters
);
4100 #else /* !WRITE_FILTER */
4101 # define choose_random_filter(pp, start) ((void)0)
4102 #endif /* !WRITE_FILTER */
4105 make_transform_image(png_store
* const ps
, png_byte
const colour_type
,
4106 png_byte
const bit_depth
, unsigned int palette_number
,
4107 int interlace_type
, png_const_charp name
)
4111 check_interlace_type(interlace_type
);
4116 png_structp pp
= set_store_for_write(ps
, &pi
, name
);
4119 /* In the event of a problem return control to the Catch statement below
4120 * to do the clean up - it is not possible to 'return' directly from a Try
4126 w
= transform_width(pp
, colour_type
, bit_depth
);
4127 h
= transform_height(pp
, colour_type
, bit_depth
);
4129 png_set_IHDR(pp
, pi
, w
, h
, bit_depth
, colour_type
, interlace_type
,
4130 PNG_COMPRESSION_TYPE_BASE
, PNG_FILTER_TYPE_BASE
);
4132 #ifdef PNG_TEXT_SUPPORTED
4133 # if defined(PNG_READ_zTXt_SUPPORTED) && defined(PNG_WRITE_zTXt_SUPPORTED)
4134 # define TEXT_COMPRESSION PNG_TEXT_COMPRESSION_zTXt
4136 # define TEXT_COMPRESSION PNG_TEXT_COMPRESSION_NONE
4139 static char key
[] = "image name"; /* must be writeable */
4142 char copy
[FILE_NAME_SIZE
];
4144 /* Use a compressed text string to test the correct interaction of text
4145 * compression and IDAT compression.
4147 text
.compression
= TEXT_COMPRESSION
;
4149 /* Yuck: the text must be writable! */
4150 pos
= safecat(copy
, sizeof copy
, 0, ps
->wname
);
4152 text
.text_length
= pos
;
4153 text
.itxt_length
= 0;
4157 png_set_text(pp
, pi
, &text
, 1);
4161 if (colour_type
== 3) /* palette */
4162 init_standard_palette(ps
, pp
, pi
, 1U << bit_depth
, 1/*do tRNS*/);
4164 # ifdef PNG_WRITE_tRNS_SUPPORTED
4165 else if (palette_number
)
4166 set_random_tRNS(pp
, pi
, colour_type
, bit_depth
);
4169 png_write_info(pp
, pi
);
4171 if (png_get_rowbytes(pp
, pi
) !=
4172 transform_rowsize(pp
, colour_type
, bit_depth
))
4173 png_error(pp
, "transform row size incorrect");
4177 /* Somewhat confusingly this must be called *after* png_write_info
4178 * because if it is called before, the information in *pp has not been
4179 * updated to reflect the interlaced image.
4181 int npasses
= set_write_interlace_handling(pp
, interlace_type
);
4184 if (npasses
!= npasses_from_interlace_type(pp
, interlace_type
))
4185 png_error(pp
, "write: png_set_interlace_handling failed");
4187 for (pass
=0; pass
<npasses
; ++pass
)
4191 /* do_own_interlace is a pre-defined boolean (a #define) which is
4192 * set if we have to work out the interlaced rows here.
4196 png_byte buffer
[TRANSFORM_ROWMAX
];
4198 transform_row(pp
, buffer
, colour_type
, bit_depth
, y
);
4200 # if do_own_interlace
4201 /* If do_own_interlace *and* the image is interlaced we need a
4202 * reduced interlace row; this may be reduced to empty.
4204 if (interlace_type
== PNG_INTERLACE_ADAM7
)
4206 /* The row must not be written if it doesn't exist, notice
4207 * that there are two conditions here, either the row isn't
4208 * ever in the pass or the row would be but isn't wide
4209 * enough to contribute any pixels. In fact the wPass test
4210 * can be used to skip the whole y loop in this case.
4212 if (PNG_ROW_IN_INTERLACE_PASS(y
, pass
) &&
4213 PNG_PASS_COLS(w
, pass
) > 0)
4214 interlace_row(buffer
, buffer
,
4215 bit_size(pp
, colour_type
, bit_depth
), w
, pass
,
4216 0/*data always bigendian*/);
4220 # endif /* do_own_interlace */
4222 choose_random_filter(pp
, pass
== 0 && y
== 0);
4223 png_write_row(pp
, buffer
);
4228 #ifdef PNG_TEXT_SUPPORTED
4230 static char key
[] = "end marker";
4231 static char comment
[] = "end";
4234 /* Use a compressed text string to test the correct interaction of text
4235 * compression and IDAT compression.
4237 text
.compression
= TEXT_COMPRESSION
;
4239 text
.text
= comment
;
4240 text
.text_length
= (sizeof comment
)-1;
4241 text
.itxt_length
= 0;
4245 png_set_text(pp
, pi
, &text
, 1);
4249 png_write_end(pp
, pi
);
4251 /* And store this under the appropriate id, then clean up. */
4252 store_storefile(ps
, FILEID(colour_type
, bit_depth
, palette_number
,
4253 interlace_type
, 0, 0, 0));
4255 store_write_reset(ps
);
4260 /* Use the png_store returned by the exception. This may help the compiler
4261 * because 'ps' is not used in this branch of the setjmp. Note that fault
4262 * and ps will always be the same value.
4264 store_write_reset(fault
);
4269 make_transform_images(png_modifier
*pm
)
4271 png_byte colour_type
= 0;
4272 png_byte bit_depth
= 0;
4273 unsigned int palette_number
= 0;
4275 /* This is in case of errors. */
4276 safecat(pm
->this.test
, sizeof pm
->this.test
, 0, "make standard images");
4278 /* Use next_format to enumerate all the combinations we test, including
4279 * generating multiple low bit depth palette images. Non-A images (palette
4280 * and direct) are created with and without tRNS chunks.
4282 while (next_format(&colour_type
, &bit_depth
, &palette_number
, 1, 1))
4286 for (interlace_type
= PNG_INTERLACE_NONE
;
4287 interlace_type
< INTERLACE_LAST
; ++interlace_type
)
4289 char name
[FILE_NAME_SIZE
];
4291 standard_name(name
, sizeof name
, 0, colour_type
, bit_depth
,
4292 palette_number
, interlace_type
, 0, 0, do_own_interlace
);
4293 make_transform_image(&pm
->this, colour_type
, bit_depth
, palette_number
,
4294 interlace_type
, name
);
4299 /* Build a single row for the 'size' test images; this fills in only the
4300 * first bit_width bits of the sample row.
4303 size_row(png_byte buffer
[SIZE_ROWMAX
], png_uint_32 bit_width
, png_uint_32 y
)
4305 /* height is in the range 1 to 16, so: */
4306 y
= ((y
& 1) << 7) + ((y
& 2) << 6) + ((y
& 4) << 5) + ((y
& 8) << 4);
4307 /* the following ensures bits are set in small images: */
4310 while (bit_width
>= 8)
4311 *buffer
++ = (png_byte
)y
++, bit_width
-= 8;
4313 /* There may be up to 7 remaining bits, these go in the most significant
4318 png_uint_32 mask
= (1U<<(8-bit_width
))-1;
4319 *buffer
= (png_byte
)((*buffer
& mask
) | (y
& ~mask
));
4324 make_size_image(png_store
* const ps
, png_byte
const colour_type
,
4325 png_byte
const bit_depth
, int const interlace_type
,
4326 png_uint_32
const w
, png_uint_32
const h
,
4327 int const do_interlace
)
4331 check_interlace_type(interlace_type
);
4337 unsigned int pixel_size
;
4339 /* Make a name and get an appropriate id for the store: */
4340 char name
[FILE_NAME_SIZE
];
4341 png_uint_32 id
= FILEID(colour_type
, bit_depth
, 0/*palette*/,
4342 interlace_type
, w
, h
, do_interlace
);
4344 standard_name_from_id(name
, sizeof name
, 0, id
);
4345 pp
= set_store_for_write(ps
, &pi
, name
);
4347 /* In the event of a problem return control to the Catch statement below
4348 * to do the clean up - it is not possible to 'return' directly from a Try
4354 png_set_IHDR(pp
, pi
, w
, h
, bit_depth
, colour_type
, interlace_type
,
4355 PNG_COMPRESSION_TYPE_BASE
, PNG_FILTER_TYPE_BASE
);
4357 #ifdef PNG_TEXT_SUPPORTED
4359 static char key
[] = "image name"; /* must be writeable */
4362 char copy
[FILE_NAME_SIZE
];
4364 /* Use a compressed text string to test the correct interaction of text
4365 * compression and IDAT compression.
4367 text
.compression
= TEXT_COMPRESSION
;
4369 /* Yuck: the text must be writable! */
4370 pos
= safecat(copy
, sizeof copy
, 0, ps
->wname
);
4372 text
.text_length
= pos
;
4373 text
.itxt_length
= 0;
4377 png_set_text(pp
, pi
, &text
, 1);
4381 if (colour_type
== 3) /* palette */
4382 init_standard_palette(ps
, pp
, pi
, 1U << bit_depth
, 0/*do tRNS*/);
4384 png_write_info(pp
, pi
);
4386 /* Calculate the bit size, divide by 8 to get the byte size - this won't
4387 * overflow because we know the w values are all small enough even for
4388 * a system where 'unsigned int' is only 16 bits.
4390 pixel_size
= bit_size(pp
, colour_type
, bit_depth
);
4391 if (png_get_rowbytes(pp
, pi
) != ((w
* pixel_size
) + 7) / 8)
4392 png_error(pp
, "size row size incorrect");
4396 int npasses
= npasses_from_interlace_type(pp
, interlace_type
);
4399 png_byte image
[16][SIZE_ROWMAX
];
4401 /* To help consistent error detection make the parts of this buffer
4402 * that aren't set below all '1':
4404 memset(image
, 0xff, sizeof image
);
4406 if (!do_interlace
&&
4407 npasses
!= set_write_interlace_handling(pp
, interlace_type
))
4408 png_error(pp
, "write: png_set_interlace_handling failed");
4410 /* Prepare the whole image first to avoid making it 7 times: */
4412 size_row(image
[y
], w
* pixel_size
, y
);
4414 for (pass
=0; pass
<npasses
; ++pass
)
4416 /* The following two are for checking the macros: */
4417 png_uint_32 wPass
= PNG_PASS_COLS(w
, pass
);
4419 /* If do_interlace is set we don't call png_write_row for every
4420 * row because some of them are empty. In fact, for a 1x1 image,
4421 * most of them are empty!
4425 png_const_bytep row
= image
[y
];
4426 png_byte tempRow
[SIZE_ROWMAX
];
4428 /* If do_interlace *and* the image is interlaced we
4429 * need a reduced interlace row; this may be reduced
4432 if (do_interlace
&& interlace_type
== PNG_INTERLACE_ADAM7
)
4434 /* The row must not be written if it doesn't exist, notice
4435 * that there are two conditions here, either the row isn't
4436 * ever in the pass or the row would be but isn't wide
4437 * enough to contribute any pixels. In fact the wPass test
4438 * can be used to skip the whole y loop in this case.
4440 if (PNG_ROW_IN_INTERLACE_PASS(y
, pass
) && wPass
> 0)
4442 /* Set to all 1's for error detection (libpng tends to
4443 * set unset things to 0).
4445 memset(tempRow
, 0xff, sizeof tempRow
);
4446 interlace_row(tempRow
, row
, pixel_size
, w
, pass
,
4447 0/*data always bigendian*/);
4454 # ifdef PNG_WRITE_FILTER_SUPPORTED
4455 /* Only get to here if the row has some pixels in it, set the
4456 * filters to 'all' for the very first row and thereafter to a
4457 * single filter. It isn't well documented, but png_set_filter
4458 * does accept a filter number (per the spec) as well as a bit
4461 * The code now uses filters at random, except that on the first
4462 * row of an image it ensures that a previous row filter is in
4463 * the set so that libpng allocates the row buffer.
4466 int filters
= 8 << random_mod(PNG_FILTER_VALUE_LAST
);
4468 if (pass
== 0 && y
== 0 &&
4469 (filters
< PNG_FILTER_UP
|| w
== 1U))
4470 filters
|= PNG_FILTER_UP
;
4472 png_set_filter(pp
, 0/*method*/, filters
);
4476 png_write_row(pp
, row
);
4481 #ifdef PNG_TEXT_SUPPORTED
4483 static char key
[] = "end marker";
4484 static char comment
[] = "end";
4487 /* Use a compressed text string to test the correct interaction of text
4488 * compression and IDAT compression.
4490 text
.compression
= TEXT_COMPRESSION
;
4492 text
.text
= comment
;
4493 text
.text_length
= (sizeof comment
)-1;
4494 text
.itxt_length
= 0;
4498 png_set_text(pp
, pi
, &text
, 1);
4502 png_write_end(pp
, pi
);
4504 /* And store this under the appropriate id, then clean up. */
4505 store_storefile(ps
, id
);
4507 store_write_reset(ps
);
4512 /* Use the png_store returned by the exception. This may help the compiler
4513 * because 'ps' is not used in this branch of the setjmp. Note that fault
4514 * and ps will always be the same value.
4516 store_write_reset(fault
);
4521 make_size(png_store
* const ps
, png_byte
const colour_type
, int bdlo
,
4524 for (; bdlo
<= bdhi
; ++bdlo
)
4528 for (width
= 1; width
<= 16; ++width
)
4532 for (height
= 1; height
<= 16; ++height
)
4534 /* The four combinations of DIY interlace and interlace or not -
4535 * no interlace + DIY should be identical to no interlace with
4538 make_size_image(ps
, colour_type
, DEPTH(bdlo
), PNG_INTERLACE_NONE
,
4540 make_size_image(ps
, colour_type
, DEPTH(bdlo
), PNG_INTERLACE_NONE
,
4542 # ifdef PNG_WRITE_INTERLACING_SUPPORTED
4543 make_size_image(ps
, colour_type
, DEPTH(bdlo
), PNG_INTERLACE_ADAM7
,
4546 # if CAN_WRITE_INTERLACE
4547 /* 1.7.0 removes the hack that prevented app write of an interlaced
4548 * image if WRITE_INTERLACE was not supported
4550 make_size_image(ps
, colour_type
, DEPTH(bdlo
), PNG_INTERLACE_ADAM7
,
4559 make_size_images(png_store
*ps
)
4561 /* This is in case of errors. */
4562 safecat(ps
->test
, sizeof ps
->test
, 0, "make size images");
4564 /* Arguments are colour_type, low bit depth, high bit depth
4566 make_size(ps
, 0, 0, WRITE_BDHI
);
4567 make_size(ps
, 2, 3, WRITE_BDHI
);
4568 make_size(ps
, 3, 0, 3 /*palette: max 8 bits*/);
4569 make_size(ps
, 4, 3, WRITE_BDHI
);
4570 make_size(ps
, 6, 3, WRITE_BDHI
);
4573 #ifdef PNG_READ_SUPPORTED
4574 /* Return a row based on image id and 'y' for checking: */
4576 standard_row(png_const_structp pp
, png_byte std
[STANDARD_ROWMAX
],
4577 png_uint_32 id
, png_uint_32 y
)
4579 if (WIDTH_FROM_ID(id
) == 0)
4580 transform_row(pp
, std
, COL_FROM_ID(id
), DEPTH_FROM_ID(id
), y
);
4582 size_row(std
, WIDTH_FROM_ID(id
) * bit_size(pp
, COL_FROM_ID(id
),
4583 DEPTH_FROM_ID(id
)), y
);
4585 #endif /* PNG_READ_SUPPORTED */
4587 /* Tests - individual test cases */
4588 /* Like 'make_standard' but errors are deliberately introduced into the calls
4589 * to ensure that they get detected - it should not be possible to write an
4590 * invalid image with libpng!
4592 /* TODO: the 'set' functions can probably all be made to take a
4593 * png_const_structp rather than a modifiable one.
4595 #ifdef PNG_WARNINGS_SUPPORTED
4597 sBIT0_error_fn(png_structp pp
, png_infop pi
)
4599 /* 0 is invalid... */
4601 bad
.red
= bad
.green
= bad
.blue
= bad
.gray
= bad
.alpha
= 0;
4602 png_set_sBIT(pp
, pi
, &bad
);
4606 sBIT_error_fn(png_structp pp
, png_infop pi
)
4611 if (png_get_color_type(pp
, pi
) == PNG_COLOR_TYPE_PALETTE
)
4615 bit_depth
= png_get_bit_depth(pp
, pi
);
4617 /* Now we know the bit depth we can easily generate an invalid sBIT entry */
4618 bad
.red
= bad
.green
= bad
.blue
= bad
.gray
= bad
.alpha
=
4619 (png_byte
)(bit_depth
+1);
4620 png_set_sBIT(pp
, pi
, &bad
);
4625 void (*fn
)(png_structp
, png_infop
);
4627 unsigned int warning
:1; /* the error is a warning... */
4630 /* no warnings makes these errors undetectable prior to 1.7.0 */
4631 { sBIT0_error_fn
, "sBIT(0): failed to detect error",
4632 PNG_LIBPNG_VER
< 10700 },
4634 { sBIT_error_fn
, "sBIT(too big): failed to detect error",
4635 PNG_LIBPNG_VER
< 10700 },
4639 make_error(png_store
* const ps
, png_byte
const colour_type
,
4640 png_byte bit_depth
, int interlace_type
, int test
, png_const_charp name
)
4644 check_interlace_type(interlace_type
);
4649 png_structp pp
= set_store_for_write(ps
, &pi
, name
);
4656 w
= transform_width(pp
, colour_type
, bit_depth
);
4658 h
= transform_height(pp
, colour_type
, bit_depth
);
4660 png_set_IHDR(pp
, pi
, w
, h
, bit_depth
, colour_type
, interlace_type
,
4661 PNG_COMPRESSION_TYPE_BASE
, PNG_FILTER_TYPE_BASE
);
4663 if (colour_type
== 3) /* palette */
4664 init_standard_palette(ps
, pp
, pi
, 1U << bit_depth
, 0/*do tRNS*/);
4666 /* Time for a few errors; these are in various optional chunks, the
4667 * standard tests test the standard chunks pretty well.
4669 # define exception__prev exception_prev_1
4670 # define exception__env exception_env_1
4673 gnu_volatile(exception__prev
)
4675 /* Expect this to throw: */
4676 ps
->expect_error
= !error_test
[test
].warning
;
4677 ps
->expect_warning
= error_test
[test
].warning
;
4678 ps
->saw_warning
= 0;
4679 error_test
[test
].fn(pp
, pi
);
4681 /* Normally the error is only detected here: */
4682 png_write_info(pp
, pi
);
4684 /* And handle the case where it was only a warning: */
4685 if (ps
->expect_warning
&& ps
->saw_warning
)
4688 /* If we get here there is a problem, we have success - no error or
4689 * no warning - when we shouldn't have success. Log an error.
4691 store_log(ps
, pp
, error_test
[test
].msg
, 1 /*error*/);
4695 { /* expected exit */
4697 #undef exception__prev
4698 #undef exception__env
4700 /* And clear these flags */
4701 ps
->expect_warning
= 0;
4703 if (ps
->expect_error
)
4704 ps
->expect_error
= 0;
4708 /* Now write the whole image, just to make sure that the detected, or
4709 * undetected, error has not created problems inside libpng. This
4710 * doesn't work if there was a png_error in png_write_info because that
4711 * can abort before PLTE was written.
4713 if (png_get_rowbytes(pp
, pi
) !=
4714 transform_rowsize(pp
, colour_type
, bit_depth
))
4715 png_error(pp
, "row size incorrect");
4719 int npasses
= set_write_interlace_handling(pp
, interlace_type
);
4722 if (npasses
!= npasses_from_interlace_type(pp
, interlace_type
))
4723 png_error(pp
, "write: png_set_interlace_handling failed");
4725 for (pass
=0; pass
<npasses
; ++pass
)
4731 png_byte buffer
[TRANSFORM_ROWMAX
];
4733 transform_row(pp
, buffer
, colour_type
, bit_depth
, y
);
4735 # if do_own_interlace
4736 /* If do_own_interlace *and* the image is interlaced we
4737 * need a reduced interlace row; this may be reduced to
4740 if (interlace_type
== PNG_INTERLACE_ADAM7
)
4742 /* The row must not be written if it doesn't exist,
4743 * notice that there are two conditions here, either the
4744 * row isn't ever in the pass or the row would be but
4745 * isn't wide enough to contribute any pixels. In fact
4746 * the wPass test can be used to skip the whole y loop
4749 if (PNG_ROW_IN_INTERLACE_PASS(y
, pass
) &&
4750 PNG_PASS_COLS(w
, pass
) > 0)
4751 interlace_row(buffer
, buffer
,
4752 bit_size(pp
, colour_type
, bit_depth
), w
, pass
,
4753 0/*data always bigendian*/);
4757 # endif /* do_own_interlace */
4759 png_write_row(pp
, buffer
);
4762 } /* image writing */
4764 png_write_end(pp
, pi
);
4767 /* The following deletes the file that was just written. */
4768 store_write_reset(ps
);
4773 store_write_reset(fault
);
4778 make_errors(png_modifier
* const pm
, png_byte
const colour_type
,
4779 int bdlo
, int const bdhi
)
4781 for (; bdlo
<= bdhi
; ++bdlo
)
4785 for (interlace_type
= PNG_INTERLACE_NONE
;
4786 interlace_type
< INTERLACE_LAST
; ++interlace_type
)
4789 char name
[FILE_NAME_SIZE
];
4791 standard_name(name
, sizeof name
, 0, colour_type
, 1<<bdlo
, 0,
4792 interlace_type
, 0, 0, do_own_interlace
);
4794 for (test
=0; test
<ARRAY_SIZE(error_test
); ++test
)
4796 make_error(&pm
->this, colour_type
, DEPTH(bdlo
), interlace_type
,
4805 return 1; /* keep going */
4807 #endif /* PNG_WARNINGS_SUPPORTED */
4810 perform_error_test(png_modifier
*pm
)
4812 #ifdef PNG_WARNINGS_SUPPORTED /* else there are no cases that work! */
4813 /* Need to do this here because we just write in this test. */
4814 safecat(pm
->this.test
, sizeof pm
->this.test
, 0, "error test");
4816 if (!make_errors(pm
, 0, 0, WRITE_BDHI
))
4819 if (!make_errors(pm
, 2, 3, WRITE_BDHI
))
4822 if (!make_errors(pm
, 3, 0, 3))
4825 if (!make_errors(pm
, 4, 3, WRITE_BDHI
))
4828 if (!make_errors(pm
, 6, 3, WRITE_BDHI
))
4835 /* This is just to validate the internal PNG formatting code - if this fails
4836 * then the warning messages the library outputs will probably be garbage.
4839 perform_formatting_test(png_store
*ps
)
4841 #ifdef PNG_TIME_RFC1123_SUPPORTED
4842 /* The handle into the formatting code is the RFC1123 support; this test does
4843 * nothing if that is compiled out.
4849 png_const_charp correct
= "29 Aug 2079 13:53:60 +0000";
4850 png_const_charp result
;
4851 # if PNG_LIBPNG_VER >= 10600
4852 char timestring
[29];
4857 pp
= set_store_for_write(ps
, NULL
, "libpng formatting test");
4863 /* Arbitrary settings: */
4869 pt
.second
= 60; /* a leap second */
4871 # if PNG_LIBPNG_VER < 10600
4872 result
= png_convert_to_rfc1123(pp
, &pt
);
4874 if (png_convert_to_rfc1123_buffer(timestring
, &pt
))
4875 result
= timestring
;
4882 png_error(pp
, "png_convert_to_rfc1123 failed");
4884 if (strcmp(result
, correct
) != 0)
4889 pos
= safecat(msg
, sizeof msg
, pos
, "png_convert_to_rfc1123(");
4890 pos
= safecat(msg
, sizeof msg
, pos
, correct
);
4891 pos
= safecat(msg
, sizeof msg
, pos
, ") returned: '");
4892 pos
= safecat(msg
, sizeof msg
, pos
, result
);
4893 pos
= safecat(msg
, sizeof msg
, pos
, "'");
4898 store_write_reset(ps
);
4903 store_write_reset(fault
);
4910 #ifdef PNG_READ_SUPPORTED
4911 /* Because we want to use the same code in both the progressive reader and the
4912 * sequential reader it is necessary to deal with the fact that the progressive
4913 * reader callbacks only have one parameter (png_get_progressive_ptr()), so this
4914 * must contain all the test parameters and all the local variables directly
4915 * accessible to the sequential reader implementation.
4917 * The technique adopted is to reinvent part of what Dijkstra termed a
4918 * 'display'; an array of pointers to the stack frames of enclosing functions so
4919 * that a nested function definition can access the local (C auto) variables of
4920 * the functions that contain its definition. In fact C provides the first
4921 * pointer (the local variables - the stack frame pointer) and the last (the
4922 * global variables - the BCPL global vector typically implemented as global
4923 * addresses), this code requires one more pointer to make the display - the
4924 * local variables (and function call parameters) of the function that actually
4925 * invokes either the progressive or sequential reader.
4927 * Perhaps confusingly this technique is confounded with classes - the
4928 * 'standard_display' defined here is sub-classed as the 'gamma_display' below.
4929 * A gamma_display is a standard_display, taking advantage of the ANSI-C
4930 * requirement that the pointer to the first member of a structure must be the
4931 * same as the pointer to the structure. This allows us to reuse standard_
4932 * functions in the gamma test code; something that could not be done with
4935 typedef struct standard_display
4937 png_store
* ps
; /* Test parameters (passed to the function) */
4938 png_byte colour_type
;
4940 png_byte red_sBIT
; /* Input data sBIT values. */
4941 png_byte green_sBIT
;
4943 png_byte alpha_sBIT
;
4944 png_byte interlace_type
;
4945 png_byte filler
; /* Output has a filler */
4946 png_uint_32 id
; /* Calculated file ID */
4947 png_uint_32 w
; /* Width of image */
4948 png_uint_32 h
; /* Height of image */
4949 int npasses
; /* Number of interlaced passes */
4950 png_uint_32 pixel_size
; /* Width of one pixel in bits */
4951 png_uint_32 bit_width
; /* Width of output row in bits */
4952 size_t cbRow
; /* Bytes in a row of the output image */
4953 int do_interlace
; /* Do interlacing internally */
4954 int littleendian
; /* App (row) data is little endian */
4955 int is_transparent
; /* Transparency information was present. */
4956 int has_tRNS
; /* color type GRAY or RGB with a tRNS chunk. */
4957 int speed
; /* Doing a speed test */
4958 int use_update_info
;/* Call update_info, not start_image */
4964 } transparent
; /* The transparent color, if set. */
4965 int npalette
; /* Number of entries in the palette. */
4971 standard_display_init(standard_display
*dp
, png_store
* ps
, png_uint_32 id
,
4972 int do_interlace
, int use_update_info
)
4974 memset(dp
, 0, sizeof *dp
);
4977 dp
->colour_type
= COL_FROM_ID(id
);
4978 dp
->bit_depth
= DEPTH_FROM_ID(id
);
4979 if (dp
->bit_depth
< 1 || dp
->bit_depth
> 16)
4980 internal_error(ps
, "internal: bad bit depth");
4981 if (dp
->colour_type
== 3)
4982 dp
->red_sBIT
= dp
->blue_sBIT
= dp
->green_sBIT
= dp
->alpha_sBIT
= 8;
4984 dp
->red_sBIT
= dp
->blue_sBIT
= dp
->green_sBIT
= dp
->alpha_sBIT
=
4986 dp
->interlace_type
= INTERLACE_FROM_ID(id
);
4987 check_interlace_type(dp
->interlace_type
);
4989 /* All the rest are filled in after the read_info: */
4996 dp
->do_interlace
= do_interlace
;
4997 dp
->littleendian
= 0;
4998 dp
->is_transparent
= 0;
4999 dp
->speed
= ps
->speed
;
5000 dp
->use_update_info
= use_update_info
;
5002 /* Preset the transparent color to black: */
5003 memset(&dp
->transparent
, 0, sizeof dp
->transparent
);
5004 /* Preset the palette to full intensity/opaque throughout: */
5005 memset(dp
->palette
, 0xff, sizeof dp
->palette
);
5008 /* Initialize the palette fields - this must be done later because the palette
5009 * comes from the particular png_store_file that is selected.
5012 standard_palette_init(standard_display
*dp
)
5014 store_palette_entry
*palette
= store_current_palette(dp
->ps
, &dp
->npalette
);
5016 /* The remaining entries remain white/opaque. */
5017 if (dp
->npalette
> 0)
5019 int i
= dp
->npalette
;
5020 memcpy(dp
->palette
, palette
, i
* sizeof *palette
);
5022 /* Check for a non-opaque palette entry: */
5024 if (palette
[i
].alpha
< 255)
5028 /* GCC can't handle the more obviously optimizable version. */
5030 dp
->is_transparent
= 1;
5032 dp
->is_transparent
= 0;
5034 dp
->is_transparent
= (i
>= 0);
5039 /* Utility to read the palette from the PNG file and convert it into
5040 * store_palette format. This returns 1 if there is any transparency in the
5041 * palette (it does not check for a transparent colour in the non-palette case.)
5044 read_palette(store_palette palette
, int *npalette
, png_const_structp pp
,
5048 png_bytep trans_alpha
;
5054 if (png_get_PLTE(pp
, pi
, &pal
, npalette
) & PNG_INFO_PLTE
)
5058 if (i
<= 0 || i
> 256)
5059 png_error(pp
, "validate: invalid PLTE count");
5063 palette
[i
].red
= pal
[i
].red
;
5064 palette
[i
].green
= pal
[i
].green
;
5065 palette
[i
].blue
= pal
[i
].blue
;
5068 /* Mark the remainder of the entries with a flag value (other than
5069 * white/opaque which is the flag value stored above.)
5071 memset(palette
+ *npalette
, 126, (256-*npalette
) * sizeof *palette
);
5074 else /* !png_get_PLTE */
5076 if (*npalette
!= (-1))
5077 png_error(pp
, "validate: invalid PLTE result");
5078 /* But there is no palette, so record this: */
5080 memset(palette
, 113, sizeof (store_palette
));
5084 num
= 2; /* force error below */
5085 if ((png_get_tRNS(pp
, pi
, &trans_alpha
, &num
, 0) & PNG_INFO_tRNS
) != 0 &&
5086 (trans_alpha
!= NULL
|| num
!= 1/*returns 1 for a transparent color*/) &&
5087 /* Oops, if a palette tRNS gets expanded png_read_update_info (at least so
5088 * far as 1.5.4) does not remove the trans_alpha pointer, only num_trans,
5089 * so in the above call we get a success, we get a pointer (who knows what
5090 * to) and we get num_trans == 0:
5092 !(trans_alpha
!= NULL
&& num
== 0)) /* TODO: fix this in libpng. */
5096 /* Any of these are crash-worthy - given the implementation of
5097 * png_get_tRNS up to 1.5 an app won't crash if it just checks the
5098 * result above and fails to check that the variables it passed have
5099 * actually been filled in! Note that if the app were to pass the
5100 * last, png_color_16p, variable too it couldn't rely on this.
5102 if (trans_alpha
== NULL
|| num
<= 0 || num
> 256 || num
> *npalette
)
5103 png_error(pp
, "validate: unexpected png_get_tRNS (palette) result");
5105 for (i
=0; i
<num
; ++i
)
5106 palette
[i
].alpha
= trans_alpha
[i
];
5108 for (num
=*npalette
; i
<num
; ++i
)
5109 palette
[i
].alpha
= 255;
5112 palette
[i
].alpha
= 33; /* flag value */
5114 return 1; /* transparency */
5119 /* No palette transparency - just set the alpha channel to opaque. */
5122 for (i
=0, num
=*npalette
; i
<num
; ++i
)
5123 palette
[i
].alpha
= 255;
5126 palette
[i
].alpha
= 55; /* flag value */
5128 return 0; /* no transparency */
5132 /* Utility to validate the palette if it should not have changed (the
5133 * non-transform case).
5136 standard_palette_validate(standard_display
*dp
, png_const_structp pp
,
5140 store_palette palette
;
5142 if (read_palette(palette
, &npalette
, pp
, pi
) != dp
->is_transparent
)
5143 png_error(pp
, "validate: palette transparency changed");
5145 if (npalette
!= dp
->npalette
)
5150 pos
= safecat(msg
, sizeof msg
, pos
, "validate: palette size changed: ");
5151 pos
= safecatn(msg
, sizeof msg
, pos
, dp
->npalette
);
5152 pos
= safecat(msg
, sizeof msg
, pos
, " -> ");
5153 pos
= safecatn(msg
, sizeof msg
, pos
, npalette
);
5158 int i
= npalette
; /* npalette is aliased */
5161 if (palette
[i
].red
!= dp
->palette
[i
].red
||
5162 palette
[i
].green
!= dp
->palette
[i
].green
||
5163 palette
[i
].blue
!= dp
->palette
[i
].blue
||
5164 palette
[i
].alpha
!= dp
->palette
[i
].alpha
)
5165 png_error(pp
, "validate: PLTE or tRNS chunk changed");
5169 /* By passing a 'standard_display' the progressive callbacks can be used
5170 * directly by the sequential code, the functions suffixed "_imp" are the
5171 * implementations, the functions without the suffix are the callbacks.
5173 * The code for the info callback is split into two because this callback calls
5174 * png_read_update_info or png_start_read_image and what gets called depends on
5175 * whether the info needs updating (we want to test both calls in pngvalid.)
5178 standard_info_part1(standard_display
*dp
, png_structp pp
, png_infop pi
)
5180 if (png_get_bit_depth(pp
, pi
) != dp
->bit_depth
)
5181 png_error(pp
, "validate: bit depth changed");
5183 if (png_get_color_type(pp
, pi
) != dp
->colour_type
)
5184 png_error(pp
, "validate: color type changed");
5186 if (png_get_filter_type(pp
, pi
) != PNG_FILTER_TYPE_BASE
)
5187 png_error(pp
, "validate: filter type changed");
5189 if (png_get_interlace_type(pp
, pi
) != dp
->interlace_type
)
5190 png_error(pp
, "validate: interlacing changed");
5192 if (png_get_compression_type(pp
, pi
) != PNG_COMPRESSION_TYPE_BASE
)
5193 png_error(pp
, "validate: compression type changed");
5195 dp
->w
= png_get_image_width(pp
, pi
);
5197 if (dp
->w
!= standard_width(pp
, dp
->id
))
5198 png_error(pp
, "validate: image width changed");
5200 dp
->h
= png_get_image_height(pp
, pi
);
5202 if (dp
->h
!= standard_height(pp
, dp
->id
))
5203 png_error(pp
, "validate: image height changed");
5205 /* Record (but don't check at present) the input sBIT according to the colour
5209 png_color_8p sBIT
= 0;
5211 if (png_get_sBIT(pp
, pi
, &sBIT
) & PNG_INFO_sBIT
)
5213 int sBIT_invalid
= 0;
5216 png_error(pp
, "validate: unexpected png_get_sBIT result");
5218 if (dp
->colour_type
& PNG_COLOR_MASK_COLOR
)
5220 if (sBIT
->red
== 0 || sBIT
->red
> dp
->bit_depth
)
5223 dp
->red_sBIT
= sBIT
->red
;
5225 if (sBIT
->green
== 0 || sBIT
->green
> dp
->bit_depth
)
5228 dp
->green_sBIT
= sBIT
->green
;
5230 if (sBIT
->blue
== 0 || sBIT
->blue
> dp
->bit_depth
)
5233 dp
->blue_sBIT
= sBIT
->blue
;
5238 if (sBIT
->gray
== 0 || sBIT
->gray
> dp
->bit_depth
)
5241 dp
->blue_sBIT
= dp
->green_sBIT
= dp
->red_sBIT
= sBIT
->gray
;
5244 /* All 8 bits in tRNS for a palette image are significant - see the
5247 if (dp
->colour_type
& PNG_COLOR_MASK_ALPHA
)
5249 if (sBIT
->alpha
== 0 || sBIT
->alpha
> dp
->bit_depth
)
5252 dp
->alpha_sBIT
= sBIT
->alpha
;
5256 png_error(pp
, "validate: sBIT value out of range");
5260 /* Important: this is validating the value *before* any transforms have been
5261 * put in place. It doesn't matter for the standard tests, where there are
5262 * no transforms, but it does for other tests where rowbytes may change after
5263 * png_read_update_info.
5265 if (png_get_rowbytes(pp
, pi
) != standard_rowsize(pp
, dp
->id
))
5266 png_error(pp
, "validate: row size changed");
5268 /* Validate the colour type 3 palette (this can be present on other color
5271 standard_palette_validate(dp
, pp
, pi
);
5273 /* In any case always check for a transparent color (notice that the
5274 * colour type 3 case must not give a successful return on the get_tRNS call
5275 * with these arguments!)
5278 png_color_16p trans_color
= 0;
5280 if (png_get_tRNS(pp
, pi
, 0, 0, &trans_color
) & PNG_INFO_tRNS
)
5282 if (trans_color
== 0)
5283 png_error(pp
, "validate: unexpected png_get_tRNS (color) result");
5285 switch (dp
->colour_type
)
5288 dp
->transparent
.red
= dp
->transparent
.green
= dp
->transparent
.blue
=
5294 dp
->transparent
.red
= trans_color
->red
;
5295 dp
->transparent
.green
= trans_color
->green
;
5296 dp
->transparent
.blue
= trans_color
->blue
;
5301 /* Not expected because it should result in the array case
5304 png_error(pp
, "validate: unexpected png_get_tRNS result");
5308 png_error(pp
, "validate: invalid tRNS chunk with alpha image");
5313 /* Read the number of passes - expected to match the value used when
5314 * creating the image (interlaced or not). This has the side effect of
5315 * turning on interlace handling (if do_interlace is not set.)
5317 dp
->npasses
= npasses_from_interlace_type(pp
, dp
->interlace_type
);
5318 if (!dp
->do_interlace
)
5320 # ifdef PNG_READ_INTERLACING_SUPPORTED
5321 if (dp
->npasses
!= png_set_interlace_handling(pp
))
5322 png_error(pp
, "validate: file changed interlace type");
5323 # else /* !READ_INTERLACING */
5324 /* This should never happen: the relevant tests (!do_interlace) should
5327 if (dp
->npasses
> 1)
5328 png_error(pp
, "validate: no libpng interlace support");
5329 # endif /* !READ_INTERLACING */
5332 /* Caller calls png_read_update_info or png_start_read_image now, then calls
5337 /* This must be called *after* the png_read_update_info call to get the correct
5338 * 'rowbytes' value, otherwise png_get_rowbytes will refer to the untransformed
5342 standard_info_part2(standard_display
*dp
, png_const_structp pp
,
5343 png_const_infop pi
, int nImages
)
5345 /* Record cbRow now that it can be found. */
5347 png_byte ct
= png_get_color_type(pp
, pi
);
5348 png_byte bd
= png_get_bit_depth(pp
, pi
);
5350 if (bd
>= 8 && (ct
== PNG_COLOR_TYPE_RGB
|| ct
== PNG_COLOR_TYPE_GRAY
) &&
5352 ct
|= 4; /* handle filler as faked alpha channel */
5354 dp
->pixel_size
= bit_size(pp
, ct
, bd
);
5356 dp
->bit_width
= png_get_image_width(pp
, pi
) * dp
->pixel_size
;
5357 dp
->cbRow
= png_get_rowbytes(pp
, pi
);
5359 /* Validate the rowbytes here again. */
5360 if (dp
->cbRow
!= (dp
->bit_width
+7)/8)
5361 png_error(pp
, "bad png_get_rowbytes calculation");
5363 /* Then ensure there is enough space for the output image(s). */
5364 store_ensure_image(dp
->ps
, pp
, nImages
, dp
->cbRow
, dp
->h
);
5368 standard_info_imp(standard_display
*dp
, png_structp pp
, png_infop pi
,
5371 /* Note that the validation routine has the side effect of turning on
5372 * interlace handling in the subsequent code.
5374 standard_info_part1(dp
, pp
, pi
);
5376 /* And the info callback has to call this (or png_read_update_info - see
5377 * below in the png_modifier code for that variant.
5379 if (dp
->use_update_info
)
5381 /* For debugging the effect of multiple calls: */
5382 int i
= dp
->use_update_info
;
5384 png_read_update_info(pp
, pi
);
5388 png_start_read_image(pp
);
5390 /* Validate the height, width and rowbytes plus ensure that sufficient buffer
5391 * exists for decoding the image.
5393 standard_info_part2(dp
, pp
, pi
, nImages
);
5396 static void PNGCBAPI
5397 standard_info(png_structp pp
, png_infop pi
)
5399 standard_display
*dp
= voidcast(standard_display
*,
5400 png_get_progressive_ptr(pp
));
5402 /* Call with nImages==1 because the progressive reader can only produce one
5405 standard_info_imp(dp
, pp
, pi
, 1 /*only one image*/);
5408 static void PNGCBAPI
5409 progressive_row(png_structp ppIn
, png_bytep new_row
, png_uint_32 y
, int pass
)
5411 png_const_structp pp
= ppIn
;
5412 const standard_display
*dp
= voidcast(standard_display
*,
5413 png_get_progressive_ptr(pp
));
5415 /* When handling interlacing some rows will be absent in each pass, the
5416 * callback still gets called, but with a NULL pointer. This is checked
5417 * in the 'else' clause below. We need our own 'cbRow', but we can't call
5418 * png_get_rowbytes because we got no info structure.
5420 if (new_row
!= NULL
)
5424 /* In the case where the reader doesn't do the interlace it gives
5425 * us the y in the sub-image:
5427 if (dp
->do_interlace
&& dp
->interlace_type
== PNG_INTERLACE_ADAM7
)
5429 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
5430 /* Use this opportunity to validate the png 'current' APIs: */
5431 if (y
!= png_get_current_row_number(pp
))
5432 png_error(pp
, "png_get_current_row_number is broken");
5434 if (pass
!= png_get_current_pass_number(pp
))
5435 png_error(pp
, "png_get_current_pass_number is broken");
5436 #endif /* USER_TRANSFORM_INFO */
5438 y
= PNG_ROW_FROM_PASS_ROW(y
, pass
);
5441 /* Validate this just in case. */
5443 png_error(pp
, "invalid y to progressive row callback");
5445 row
= store_image_row(dp
->ps
, pp
, 0, y
);
5447 /* Combine the new row into the old: */
5448 #ifdef PNG_READ_INTERLACING_SUPPORTED
5449 if (dp
->do_interlace
)
5450 #endif /* READ_INTERLACING */
5452 if (dp
->interlace_type
== PNG_INTERLACE_ADAM7
)
5453 deinterlace_row(row
, new_row
, dp
->pixel_size
, dp
->w
, pass
,
5456 row_copy(row
, new_row
, dp
->pixel_size
* dp
->w
, dp
->littleendian
);
5458 #ifdef PNG_READ_INTERLACING_SUPPORTED
5460 png_progressive_combine_row(pp
, row
, new_row
);
5461 #endif /* PNG_READ_INTERLACING_SUPPORTED */
5464 else if (dp
->interlace_type
== PNG_INTERLACE_ADAM7
&&
5465 PNG_ROW_IN_INTERLACE_PASS(y
, pass
) &&
5466 PNG_PASS_COLS(dp
->w
, pass
) > 0)
5467 png_error(pp
, "missing row in progressive de-interlacing");
5471 sequential_row(standard_display
*dp
, png_structp pp
, png_infop pi
,
5472 int iImage
, int iDisplay
)
5474 int npasses
= dp
->npasses
;
5475 int do_interlace
= dp
->do_interlace
&&
5476 dp
->interlace_type
== PNG_INTERLACE_ADAM7
;
5477 png_uint_32 height
= standard_height(pp
, dp
->id
);
5478 png_uint_32 width
= standard_width(pp
, dp
->id
);
5479 const png_store
* ps
= dp
->ps
;
5482 for (pass
=0; pass
<npasses
; ++pass
)
5485 png_uint_32 wPass
= PNG_PASS_COLS(width
, pass
);
5487 for (y
=0; y
<height
; ++y
)
5491 /* wPass may be zero or this row may not be in this pass.
5492 * png_read_row must not be called in either case.
5494 if (wPass
> 0 && PNG_ROW_IN_INTERLACE_PASS(y
, pass
))
5496 /* Read the row into a pair of temporary buffers, then do the
5497 * merge here into the output rows.
5499 png_byte row
[STANDARD_ROWMAX
], display
[STANDARD_ROWMAX
];
5501 /* The following aids (to some extent) error detection - we can
5502 * see where png_read_row wrote. Use opposite values in row and
5503 * display to make this easier. Don't use 0xff (which is used in
5504 * the image write code to fill unused bits) or 0 (which is a
5505 * likely value to overwrite unused bits with).
5507 memset(row
, 0xc5, sizeof row
);
5508 memset(display
, 0x5c, sizeof display
);
5510 png_read_row(pp
, row
, display
);
5513 deinterlace_row(store_image_row(ps
, pp
, iImage
, y
), row
,
5514 dp
->pixel_size
, dp
->w
, pass
, dp
->littleendian
);
5517 deinterlace_row(store_image_row(ps
, pp
, iDisplay
, y
), display
,
5518 dp
->pixel_size
, dp
->w
, pass
, dp
->littleendian
);
5523 iImage
>= 0 ? store_image_row(ps
, pp
, iImage
, y
) : NULL
,
5524 iDisplay
>= 0 ? store_image_row(ps
, pp
, iDisplay
, y
) : NULL
);
5528 /* And finish the read operation (only really necessary if the caller wants
5529 * to find additional data in png_info from chunks after the last IDAT.)
5531 png_read_end(pp
, pi
);
5534 #ifdef PNG_TEXT_SUPPORTED
5536 standard_check_text(png_const_structp pp
, png_const_textp tp
,
5537 png_const_charp keyword
, png_const_charp text
)
5540 size_t pos
= safecat(msg
, sizeof msg
, 0, "text: ");
5543 pos
= safecat(msg
, sizeof msg
, pos
, keyword
);
5544 pos
= safecat(msg
, sizeof msg
, pos
, ": ");
5547 if (tp
->compression
!= TEXT_COMPRESSION
)
5551 sprintf(buf
, "compression [%d->%d], ", TEXT_COMPRESSION
,
5553 pos
= safecat(msg
, sizeof msg
, pos
, buf
);
5556 if (tp
->key
== NULL
|| strcmp(tp
->key
, keyword
) != 0)
5558 pos
= safecat(msg
, sizeof msg
, pos
, "keyword \"");
5559 if (tp
->key
!= NULL
)
5561 pos
= safecat(msg
, sizeof msg
, pos
, tp
->key
);
5562 pos
= safecat(msg
, sizeof msg
, pos
, "\", ");
5566 pos
= safecat(msg
, sizeof msg
, pos
, "null, ");
5569 if (tp
->text
== NULL
)
5570 pos
= safecat(msg
, sizeof msg
, pos
, "text lost, ");
5574 if (tp
->text_length
!= strlen(text
))
5577 sprintf(buf
, "text length changed[%lu->%lu], ",
5578 (unsigned long)strlen(text
), (unsigned long)tp
->text_length
);
5579 pos
= safecat(msg
, sizeof msg
, pos
, buf
);
5582 if (strcmp(tp
->text
, text
) != 0)
5584 pos
= safecat(msg
, sizeof msg
, pos
, "text becomes \"");
5585 pos
= safecat(msg
, sizeof msg
, pos
, tp
->text
);
5586 pos
= safecat(msg
, sizeof msg
, pos
, "\" (was \"");
5587 pos
= safecat(msg
, sizeof msg
, pos
, text
);
5588 pos
= safecat(msg
, sizeof msg
, pos
, "\"), ");
5592 if (tp
->itxt_length
!= 0)
5593 pos
= safecat(msg
, sizeof msg
, pos
, "iTXt length set, ");
5595 if (tp
->lang
!= NULL
)
5597 pos
= safecat(msg
, sizeof msg
, pos
, "iTXt language \"");
5598 pos
= safecat(msg
, sizeof msg
, pos
, tp
->lang
);
5599 pos
= safecat(msg
, sizeof msg
, pos
, "\", ");
5602 if (tp
->lang_key
!= NULL
)
5604 pos
= safecat(msg
, sizeof msg
, pos
, "iTXt keyword \"");
5605 pos
= safecat(msg
, sizeof msg
, pos
, tp
->lang_key
);
5606 pos
= safecat(msg
, sizeof msg
, pos
, "\", ");
5611 msg
[pos
-2] = '\0'; /* Remove the ", " at the end */
5617 standard_text_validate(standard_display
*dp
, png_const_structp pp
,
5618 png_infop pi
, int check_end
)
5620 png_textp tp
= NULL
;
5621 png_uint_32 num_text
= png_get_text(pp
, pi
, &tp
, NULL
);
5623 if (num_text
== 2 && tp
!= NULL
)
5625 standard_check_text(pp
, tp
, "image name", dp
->ps
->current
->name
);
5627 /* This exists because prior to 1.5.18 the progressive reader left the
5628 * png_struct z_stream unreset at the end of the image, so subsequent
5629 * attempts to use it simply returns Z_STREAM_END.
5632 standard_check_text(pp
, tp
+1, "end marker", "end");
5639 sprintf(msg
, "expected two text items, got %lu",
5640 (unsigned long)num_text
);
5645 # define standard_text_validate(dp,pp,pi,check_end) ((void)0)
5649 standard_row_validate(standard_display
*dp
, png_const_structp pp
,
5650 int iImage
, int iDisplay
, png_uint_32 y
)
5653 png_byte std
[STANDARD_ROWMAX
];
5655 /* The row must be pre-initialized to the magic number here for the size
5658 memset(std
, 178, sizeof std
);
5659 standard_row(pp
, std
, dp
->id
, y
);
5661 /* At the end both the 'row' and 'display' arrays should end up identical.
5662 * In earlier passes 'row' will be partially filled in, with only the pixels
5663 * that have been read so far, but 'display' will have those pixels
5664 * replicated to fill the unread pixels while reading an interlaced image.
5667 (where
= pixel_cmp(std
, store_image_row(dp
->ps
, pp
, iImage
, y
),
5668 dp
->bit_width
)) != 0)
5671 sprintf(msg
, "PNG image row[%lu][%d] changed from %.2x to %.2x",
5672 (unsigned long)y
, where
-1, std
[where
-1],
5673 store_image_row(dp
->ps
, pp
, iImage
, y
)[where
-1]);
5677 if (iDisplay
>= 0 &&
5678 (where
= pixel_cmp(std
, store_image_row(dp
->ps
, pp
, iDisplay
, y
),
5679 dp
->bit_width
)) != 0)
5682 sprintf(msg
, "display row[%lu][%d] changed from %.2x to %.2x",
5683 (unsigned long)y
, where
-1, std
[where
-1],
5684 store_image_row(dp
->ps
, pp
, iDisplay
, y
)[where
-1]);
5690 standard_image_validate(standard_display
*dp
, png_const_structp pp
, int iImage
,
5696 store_image_check(dp
->ps
, pp
, iImage
);
5699 store_image_check(dp
->ps
, pp
, iDisplay
);
5701 for (y
=0; y
<dp
->h
; ++y
)
5702 standard_row_validate(dp
, pp
, iImage
, iDisplay
, y
);
5704 /* This avoids false positives if the validation code is never called! */
5705 dp
->ps
->validated
= 1;
5708 static void PNGCBAPI
5709 standard_end(png_structp ppIn
, png_infop pi
)
5711 png_const_structp pp
= ppIn
;
5712 standard_display
*dp
= voidcast(standard_display
*,
5713 png_get_progressive_ptr(pp
));
5717 /* Validate the image - progressive reading only produces one variant for
5718 * interlaced images.
5720 standard_text_validate(dp
, pp
, pi
,
5721 PNG_LIBPNG_VER
>= 10518/*check_end: see comments above*/);
5722 standard_image_validate(dp
, pp
, 0, -1);
5725 /* A single test run checking the standard image to ensure it is not damaged. */
5727 standard_test(png_store
* const psIn
, png_uint_32
const id
,
5728 int do_interlace
, int use_update_info
)
5731 context(psIn
, fault
);
5733 /* Set up the display (stack frame) variables from the arguments to the
5734 * function and initialize the locals that are filled in later.
5736 standard_display_init(&d
, psIn
, id
, do_interlace
, use_update_info
);
5738 /* Everything is protected by a Try/Catch. The functions called also
5739 * typically have local Try/Catch blocks.
5746 /* Get a png_struct for reading the image. This will throw an error if it
5747 * fails, so we don't need to check the result.
5749 pp
= set_store_for_read(d
.ps
, &pi
, d
.id
,
5750 d
.do_interlace
? (d
.ps
->progressive
?
5751 "pngvalid progressive deinterlacer" :
5752 "pngvalid sequential deinterlacer") : (d
.ps
->progressive
?
5753 "progressive reader" : "sequential reader"));
5755 /* Initialize the palette correctly from the png_store_file. */
5756 standard_palette_init(&d
);
5758 /* Introduce the correct read function. */
5759 if (d
.ps
->progressive
)
5761 png_set_progressive_read_fn(pp
, &d
, standard_info
, progressive_row
,
5764 /* Now feed data into the reader until we reach the end: */
5765 store_progressive_read(d
.ps
, pp
, pi
);
5769 /* Note that this takes the store, not the display. */
5770 png_set_read_fn(pp
, d
.ps
, store_read
);
5772 /* Check the header values: */
5773 png_read_info(pp
, pi
);
5775 /* The code tests both versions of the images that the sequential
5776 * reader can produce.
5778 standard_info_imp(&d
, pp
, pi
, 2 /*images*/);
5780 /* Need the total bytes in the image below; we can't get to this point
5781 * unless the PNG file values have been checked against the expected
5785 sequential_row(&d
, pp
, pi
, 0, 1);
5787 /* After the last pass loop over the rows again to check that the
5792 standard_text_validate(&d
, pp
, pi
, 1/*check_end*/);
5793 standard_image_validate(&d
, pp
, 0, 1);
5796 d
.ps
->validated
= 1;
5800 /* Check for validation. */
5801 if (!d
.ps
->validated
)
5802 png_error(pp
, "image read failed silently");
5804 /* Successful completion. */
5808 d
.ps
= fault
; /* make sure this hasn't been clobbered. */
5810 /* In either case clean up the store. */
5811 store_read_reset(d
.ps
);
5815 test_standard(png_modifier
* const pm
, png_byte
const colour_type
,
5816 int bdlo
, int const bdhi
)
5818 for (; bdlo
<= bdhi
; ++bdlo
)
5822 for (interlace_type
= PNG_INTERLACE_NONE
;
5823 interlace_type
< INTERLACE_LAST
; ++interlace_type
)
5825 standard_test(&pm
->this, FILEID(colour_type
, DEPTH(bdlo
), 0/*palette*/,
5826 interlace_type
, 0, 0, 0), do_read_interlace
, pm
->use_update_info
);
5833 return 1; /* keep going */
5837 perform_standard_test(png_modifier
*pm
)
5839 /* Test each colour type over the valid range of bit depths (expressed as
5840 * log2(bit_depth) in turn, stop as soon as any error is detected.
5842 if (!test_standard(pm
, 0, 0, READ_BDHI
))
5845 if (!test_standard(pm
, 2, 3, READ_BDHI
))
5848 if (!test_standard(pm
, 3, 0, 3))
5851 if (!test_standard(pm
, 4, 3, READ_BDHI
))
5854 if (!test_standard(pm
, 6, 3, READ_BDHI
))
5859 /********************************** SIZE TESTS ********************************/
5861 test_size(png_modifier
* const pm
, png_byte
const colour_type
,
5862 int bdlo
, int const bdhi
)
5864 /* Run the tests on each combination.
5866 * NOTE: on my 32 bit x86 each of the following blocks takes
5867 * a total of 3.5 seconds if done across every combo of bit depth
5868 * width and height. This is a waste of time in practice, hence the
5869 * hinc and winc stuff:
5871 static const png_byte hinc
[] = {1, 3, 11, 1, 5};
5872 static const png_byte winc
[] = {1, 9, 5, 7, 1};
5873 int save_bdlo
= bdlo
;
5875 for (; bdlo
<= bdhi
; ++bdlo
)
5879 for (h
=1; h
<=16; h
+=hinc
[bdlo
]) for (w
=1; w
<=16; w
+=winc
[bdlo
])
5881 /* First test all the 'size' images against the sequential
5882 * reader using libpng to deinterlace (where required.) This
5883 * validates the write side of libpng. There are four possibilities
5886 standard_test(&pm
->this, FILEID(colour_type
, DEPTH(bdlo
), 0/*palette*/,
5887 PNG_INTERLACE_NONE
, w
, h
, 0), 0/*do_interlace*/,
5888 pm
->use_update_info
);
5893 standard_test(&pm
->this, FILEID(colour_type
, DEPTH(bdlo
), 0/*palette*/,
5894 PNG_INTERLACE_NONE
, w
, h
, 1), 0/*do_interlace*/,
5895 pm
->use_update_info
);
5900 /* Now validate the interlaced read side - do_interlace true,
5901 * in the progressive case this does actually make a difference
5902 * to the code used in the non-interlaced case too.
5904 standard_test(&pm
->this, FILEID(colour_type
, DEPTH(bdlo
), 0/*palette*/,
5905 PNG_INTERLACE_NONE
, w
, h
, 0), 1/*do_interlace*/,
5906 pm
->use_update_info
);
5911 # if CAN_WRITE_INTERLACE
5912 /* Validate the pngvalid code itself: */
5913 standard_test(&pm
->this, FILEID(colour_type
, DEPTH(bdlo
), 0/*palette*/,
5914 PNG_INTERLACE_ADAM7
, w
, h
, 1), 1/*do_interlace*/,
5915 pm
->use_update_info
);
5923 /* Now do the tests of libpng interlace handling, after we have made sure
5924 * that the pngvalid version works:
5926 for (bdlo
= save_bdlo
; bdlo
<= bdhi
; ++bdlo
)
5930 for (h
=1; h
<=16; h
+=hinc
[bdlo
]) for (w
=1; w
<=16; w
+=winc
[bdlo
])
5932 # ifdef PNG_READ_INTERLACING_SUPPORTED
5933 /* Test with pngvalid generated interlaced images first; we have
5934 * already verify these are ok (unless pngvalid has self-consistent
5935 * read/write errors, which is unlikely), so this detects errors in the
5938 # if CAN_WRITE_INTERLACE
5939 standard_test(&pm
->this, FILEID(colour_type
, DEPTH(bdlo
), 0/*palette*/,
5940 PNG_INTERLACE_ADAM7
, w
, h
, 1), 0/*do_interlace*/,
5941 pm
->use_update_info
);
5946 # endif /* READ_INTERLACING */
5948 # ifdef PNG_WRITE_INTERLACING_SUPPORTED
5949 /* Test the libpng write side against the pngvalid read side: */
5950 standard_test(&pm
->this, FILEID(colour_type
, DEPTH(bdlo
), 0/*palette*/,
5951 PNG_INTERLACE_ADAM7
, w
, h
, 0), 1/*do_interlace*/,
5952 pm
->use_update_info
);
5958 # ifdef PNG_READ_INTERLACING_SUPPORTED
5959 # ifdef PNG_WRITE_INTERLACING_SUPPORTED
5960 /* Test both together: */
5961 standard_test(&pm
->this, FILEID(colour_type
, DEPTH(bdlo
), 0/*palette*/,
5962 PNG_INTERLACE_ADAM7
, w
, h
, 0), 0/*do_interlace*/,
5963 pm
->use_update_info
);
5968 # endif /* READ_INTERLACING */
5972 return 1; /* keep going */
5976 perform_size_test(png_modifier
*pm
)
5978 /* Test each colour type over the valid range of bit depths (expressed as
5979 * log2(bit_depth) in turn, stop as soon as any error is detected.
5981 if (!test_size(pm
, 0, 0, READ_BDHI
))
5984 if (!test_size(pm
, 2, 3, READ_BDHI
))
5987 /* For the moment don't do the palette test - it's a waste of time when
5988 * compared to the grayscale test.
5991 if (!test_size(pm
, 3, 0, 3))
5995 if (!test_size(pm
, 4, 3, READ_BDHI
))
5998 if (!test_size(pm
, 6, 3, READ_BDHI
))
6003 /******************************* TRANSFORM TESTS ******************************/
6004 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
6005 /* A set of tests to validate libpng image transforms. The possibilities here
6006 * are legion because the transforms can be combined in a combinatorial
6007 * fashion. To deal with this some measure of restraint is required, otherwise
6008 * the tests would take forever.
6010 typedef struct image_pixel
6012 /* A local (pngvalid) representation of a PNG pixel, in all its
6015 unsigned int red
, green
, blue
, alpha
; /* For non-palette images. */
6016 unsigned int palette_index
; /* For a palette image. */
6017 png_byte colour_type
; /* As in the spec. */
6018 png_byte bit_depth
; /* Defines bit size in row */
6019 png_byte sample_depth
; /* Scale of samples */
6020 unsigned int have_tRNS
:1; /* tRNS chunk may need processing */
6021 unsigned int swap_rgb
:1; /* RGB swapped to BGR */
6022 unsigned int alpha_first
:1; /* Alpha at start, not end */
6023 unsigned int alpha_inverted
:1; /* Alpha channel inverted */
6024 unsigned int mono_inverted
:1; /* Gray channel inverted */
6025 unsigned int swap16
:1; /* Byte swap 16-bit components */
6026 unsigned int littleendian
:1; /* High bits on right */
6027 unsigned int sig_bits
:1; /* Pixel shifted (sig bits only) */
6029 /* For checking the code calculates double precision floating point values
6030 * along with an error value, accumulated from the transforms. Because an
6031 * sBIT setting allows larger error bounds (indeed, by the spec, apparently
6032 * up to just less than +/-1 in the scaled value) the *lowest* sBIT for each
6033 * channel is stored. This sBIT value is folded in to the stored error value
6034 * at the end of the application of the transforms to the pixel.
6036 * If sig_bits is set above the red, green, blue and alpha values have been
6037 * scaled so they only contain the significant bits of the component values.
6039 double redf
, greenf
, bluef
, alphaf
;
6040 double rede
, greene
, bluee
, alphae
;
6041 png_byte red_sBIT
, green_sBIT
, blue_sBIT
, alpha_sBIT
;
6044 /* Shared utility function, see below. */
6046 image_pixel_setf(image_pixel
*this, unsigned int rMax
, unsigned int gMax
,
6047 unsigned int bMax
, unsigned int aMax
)
6049 this->redf
= this->red
/ (double)rMax
;
6050 this->greenf
= this->green
/ (double)gMax
;
6051 this->bluef
= this->blue
/ (double)bMax
;
6052 this->alphaf
= this->alpha
/ (double)aMax
;
6054 if (this->red
< rMax
)
6055 this->rede
= this->redf
* DBL_EPSILON
;
6058 if (this->green
< gMax
)
6059 this->greene
= this->greenf
* DBL_EPSILON
;
6062 if (this->blue
< bMax
)
6063 this->bluee
= this->bluef
* DBL_EPSILON
;
6066 if (this->alpha
< aMax
)
6067 this->alphae
= this->alphaf
* DBL_EPSILON
;
6072 /* Initialize the structure for the next pixel - call this before doing any
6073 * transforms and call it for each pixel since all the fields may need to be
6077 image_pixel_init(image_pixel
*this, png_const_bytep row
, png_byte colour_type
,
6078 png_byte bit_depth
, png_uint_32 x
, store_palette palette
,
6079 const image_pixel
*format
/*from pngvalid transform of input*/)
6081 png_byte sample_depth
=
6082 (png_byte
)(colour_type
== PNG_COLOR_TYPE_PALETTE
? 8 : bit_depth
);
6083 unsigned int max
= (1U<<sample_depth
)-1;
6084 int swap16
= (format
!= 0 && format
->swap16
);
6085 int littleendian
= (format
!= 0 && format
->littleendian
);
6086 int sig_bits
= (format
!= 0 && format
->sig_bits
);
6088 /* Initially just set everything to the same number and the alpha to opaque.
6089 * Note that this currently assumes a simple palette where entry x has colour
6092 this->palette_index
= this->red
= this->green
= this->blue
=
6093 sample(row
, colour_type
, bit_depth
, x
, 0, swap16
, littleendian
);
6095 this->red_sBIT
= this->green_sBIT
= this->blue_sBIT
= this->alpha_sBIT
=
6098 /* Then override as appropriate: */
6099 if (colour_type
== 3) /* palette */
6101 /* This permits the caller to default to the sample value. */
6104 unsigned int i
= this->palette_index
;
6106 this->red
= palette
[i
].red
;
6107 this->green
= palette
[i
].green
;
6108 this->blue
= palette
[i
].blue
;
6109 this->alpha
= palette
[i
].alpha
;
6113 else /* not palette */
6117 if ((colour_type
& 4) != 0 && format
!= 0 && format
->alpha_first
)
6119 this->alpha
= this->red
;
6120 /* This handles the gray case for 'AG' pixels */
6121 this->palette_index
= this->red
= this->green
= this->blue
=
6122 sample(row
, colour_type
, bit_depth
, x
, 1, swap16
, littleendian
);
6126 if (colour_type
& 2)
6128 /* Green is second for both BGR and RGB: */
6129 this->green
= sample(row
, colour_type
, bit_depth
, x
, ++i
, swap16
,
6132 if (format
!= 0 && format
->swap_rgb
) /* BGR */
6133 this->red
= sample(row
, colour_type
, bit_depth
, x
, ++i
, swap16
,
6136 this->blue
= sample(row
, colour_type
, bit_depth
, x
, ++i
, swap16
,
6140 else /* grayscale */ if (format
!= 0 && format
->mono_inverted
)
6141 this->red
= this->green
= this->blue
= this->red
^ max
;
6143 if ((colour_type
& 4) != 0) /* alpha */
6145 if (format
== 0 || !format
->alpha_first
)
6146 this->alpha
= sample(row
, colour_type
, bit_depth
, x
, ++i
, swap16
,
6149 if (format
!= 0 && format
->alpha_inverted
)
6154 /* Calculate the scaled values, these are simply the values divided by
6155 * 'max' and the error is initialized to the double precision epsilon value
6156 * from the header file.
6158 image_pixel_setf(this,
6159 sig_bits
? (1U << format
->red_sBIT
)-1 : max
,
6160 sig_bits
? (1U << format
->green_sBIT
)-1 : max
,
6161 sig_bits
? (1U << format
->blue_sBIT
)-1 : max
,
6162 sig_bits
? (1U << format
->alpha_sBIT
)-1 : max
);
6164 /* Store the input information for use in the transforms - these will
6165 * modify the information.
6167 this->colour_type
= colour_type
;
6168 this->bit_depth
= bit_depth
;
6169 this->sample_depth
= sample_depth
;
6170 this->have_tRNS
= 0;
6172 this->alpha_first
= 0;
6173 this->alpha_inverted
= 0;
6174 this->mono_inverted
= 0;
6176 this->littleendian
= 0;
6180 #if defined PNG_READ_EXPAND_SUPPORTED || defined PNG_READ_GRAY_TO_RGB_SUPPORTED\
6181 || defined PNG_READ_EXPAND_SUPPORTED || defined PNG_READ_EXPAND_16_SUPPORTED\
6182 || defined PNG_READ_BACKGROUND_SUPPORTED
6183 /* Convert a palette image to an rgb image. This necessarily converts the tRNS
6184 * chunk at the same time, because the tRNS will be in palette form. The way
6185 * palette validation works means that the original palette is never updated,
6186 * instead the image_pixel value from the row contains the RGB of the
6187 * corresponding palette entry and *this* is updated. Consequently this routine
6188 * only needs to change the colour type information.
6191 image_pixel_convert_PLTE(image_pixel
*this)
6193 if (this->colour_type
== PNG_COLOR_TYPE_PALETTE
)
6195 if (this->have_tRNS
)
6197 this->colour_type
= PNG_COLOR_TYPE_RGB_ALPHA
;
6198 this->have_tRNS
= 0;
6201 this->colour_type
= PNG_COLOR_TYPE_RGB
;
6203 /* The bit depth of the row changes at this point too (notice that this is
6204 * the row format, not the sample depth, which is separate.)
6206 this->bit_depth
= 8;
6210 /* Add an alpha channel; this will import the tRNS information because tRNS is
6211 * not valid in an alpha image. The bit depth will invariably be set to at
6212 * least 8 prior to 1.7.0. Palette images will be converted to alpha (using
6213 * the above API). With png_set_background the alpha channel is never expanded
6214 * but this routine is used by pngvalid to simplify code; 'for_background'
6218 image_pixel_add_alpha(image_pixel
*this, const standard_display
*display
,
6221 if (this->colour_type
== PNG_COLOR_TYPE_PALETTE
)
6222 image_pixel_convert_PLTE(this);
6224 if ((this->colour_type
& PNG_COLOR_MASK_ALPHA
) == 0)
6226 if (this->colour_type
== PNG_COLOR_TYPE_GRAY
)
6228 # if PNG_LIBPNG_VER < 10700
6229 if (!for_background
&& this->bit_depth
< 8)
6230 this->bit_depth
= this->sample_depth
= 8;
6233 if (this->have_tRNS
)
6235 /* After 1.7 the expansion of bit depth only happens if there is a
6236 * tRNS chunk to expand at this point.
6238 # if PNG_LIBPNG_VER >= 10700
6239 if (!for_background
&& this->bit_depth
< 8)
6240 this->bit_depth
= this->sample_depth
= 8;
6243 this->have_tRNS
= 0;
6245 /* Check the input, original, channel value here against the
6246 * original tRNS gray chunk valie.
6248 if (this->red
== display
->transparent
.red
)
6256 this->colour_type
= PNG_COLOR_TYPE_GRAY_ALPHA
;
6259 else if (this->colour_type
== PNG_COLOR_TYPE_RGB
)
6261 if (this->have_tRNS
)
6263 this->have_tRNS
= 0;
6265 /* Again, check the exact input values, not the current transformed
6268 if (this->red
== display
->transparent
.red
&&
6269 this->green
== display
->transparent
.green
&&
6270 this->blue
== display
->transparent
.blue
)
6278 this->colour_type
= PNG_COLOR_TYPE_RGB_ALPHA
;
6281 /* The error in the alpha is zero and the sBIT value comes from the
6282 * original sBIT data (actually it will always be the original bit depth).
6285 this->alpha_sBIT
= display
->alpha_sBIT
;
6288 #endif /* transforms that need image_pixel_add_alpha */
6290 struct transform_display
;
6291 typedef struct image_transform
6293 /* The name of this transform: a string. */
6296 /* Each transform can be disabled from the command line: */
6299 /* The global list of transforms; read only. */
6300 struct image_transform
*const list
;
6302 /* The global count of the number of times this transform has been set on an
6305 unsigned int global_use
;
6307 /* The local count of the number of times this transform has been set. */
6308 unsigned int local_use
;
6310 /* The next transform in the list, each transform must call its own next
6311 * transform after it has processed the pixel successfully.
6313 const struct image_transform
*next
;
6315 /* A single transform for the image, expressed as a series of function
6316 * callbacks and some space for values.
6318 * First a callback to add any required modifications to the png_modifier;
6319 * this gets called just before the modifier is set up for read.
6321 void (*ini
)(const struct image_transform
*this,
6322 struct transform_display
*that
);
6324 /* And a callback to set the transform on the current png_read_struct:
6326 void (*set
)(const struct image_transform
*this,
6327 struct transform_display
*that
, png_structp pp
, png_infop pi
);
6329 /* Then a transform that takes an input pixel in one PNG format or another
6330 * and modifies it by a pngvalid implementation of the transform (thus
6331 * duplicating the libpng intent without, we hope, duplicating the bugs
6332 * in the libpng implementation!) The png_structp is solely to allow error
6333 * reporting via png_error and png_warning.
6335 void (*mod
)(const struct image_transform
*this, image_pixel
*that
,
6336 png_const_structp pp
, const struct transform_display
*display
);
6338 /* Add this transform to the list and return true if the transform is
6339 * meaningful for this colour type and bit depth - if false then the
6340 * transform should have no effect on the image so there's not a lot of
6343 int (*add
)(struct image_transform
*this,
6344 const struct image_transform
**that
, png_byte colour_type
,
6345 png_byte bit_depth
);
6348 typedef struct transform_display
6350 standard_display
this;
6354 const image_transform
* transform_list
;
6355 unsigned int max_gamma_8
;
6357 /* Local variables */
6358 png_byte output_colour_type
;
6359 png_byte output_bit_depth
;
6362 /* Modifications (not necessarily used.) */
6363 gama_modification gama_mod
;
6364 chrm_modification chrm_mod
;
6365 srgb_modification srgb_mod
;
6366 } transform_display
;
6368 /* Set sRGB, cHRM and gAMA transforms as required by the current encoding. */
6370 transform_set_encoding(transform_display
*this)
6372 /* Set up the png_modifier '_current' fields then use these to determine how
6373 * to add appropriate chunks.
6375 png_modifier
*pm
= this->pm
;
6377 modifier_set_encoding(pm
);
6379 if (modifier_color_encoding_is_set(pm
))
6381 if (modifier_color_encoding_is_sRGB(pm
))
6382 srgb_modification_init(&this->srgb_mod
, pm
, PNG_sRGB_INTENT_ABSOLUTE
);
6386 /* Set gAMA and cHRM separately. */
6387 gama_modification_init(&this->gama_mod
, pm
, pm
->current_gamma
);
6389 if (pm
->current_encoding
!= 0)
6390 chrm_modification_init(&this->chrm_mod
, pm
, pm
->current_encoding
);
6395 /* Three functions to end the list: */
6397 image_transform_ini_end(const image_transform
*this,
6398 transform_display
*that
)
6405 image_transform_set_end(const image_transform
*this,
6406 transform_display
*that
, png_structp pp
, png_infop pi
)
6414 /* At the end of the list recalculate the output image pixel value from the
6415 * double precision values set up by the preceding 'mod' calls:
6418 sample_scale(double sample_value
, unsigned int scale
)
6420 sample_value
= floor(sample_value
* scale
+ .5);
6422 /* Return NaN as 0: */
6423 if (!(sample_value
> 0))
6425 else if (sample_value
> scale
)
6426 sample_value
= scale
;
6428 return (unsigned int)sample_value
;
6432 image_transform_mod_end(const image_transform
*this, image_pixel
*that
,
6433 png_const_structp pp
, const transform_display
*display
)
6435 unsigned int scale
= (1U<<that
->sample_depth
)-1;
6436 int sig_bits
= that
->sig_bits
;
6442 /* At the end recalculate the digitized red green and blue values according
6443 * to the current sample_depth of the pixel.
6445 * The sample value is simply scaled to the maximum, checking for over
6446 * and underflow (which can both happen for some image transforms,
6447 * including simple size scaling, though libpng doesn't do that at present.
6449 that
->red
= sample_scale(that
->redf
, scale
);
6451 /* This is a bit bogus; really the above calculation should use the red_sBIT
6452 * value, not sample_depth, but because libpng does png_set_shift by just
6453 * shifting the bits we get errors if we don't do it the same way.
6455 if (sig_bits
&& that
->red_sBIT
< that
->sample_depth
)
6456 that
->red
>>= that
->sample_depth
- that
->red_sBIT
;
6458 /* The error value is increased, at the end, according to the lowest sBIT
6459 * value seen. Common sense tells us that the intermediate integer
6460 * representations are no more accurate than +/- 0.5 in the integral values,
6461 * the sBIT allows the implementation to be worse than this. In addition the
6462 * PNG specification actually permits any error within the range (-1..+1),
6463 * but that is ignored here. Instead the final digitized value is compared,
6464 * below to the digitized value of the error limits - this has the net effect
6465 * of allowing (almost) +/-1 in the output value. It's difficult to see how
6466 * any algorithm that digitizes intermediate results can be more accurate.
6468 that
->rede
+= 1./(2*((1U<<that
->red_sBIT
)-1));
6470 if (that
->colour_type
& PNG_COLOR_MASK_COLOR
)
6472 that
->green
= sample_scale(that
->greenf
, scale
);
6473 if (sig_bits
&& that
->green_sBIT
< that
->sample_depth
)
6474 that
->green
>>= that
->sample_depth
- that
->green_sBIT
;
6476 that
->blue
= sample_scale(that
->bluef
, scale
);
6477 if (sig_bits
&& that
->blue_sBIT
< that
->sample_depth
)
6478 that
->blue
>>= that
->sample_depth
- that
->blue_sBIT
;
6480 that
->greene
+= 1./(2*((1U<<that
->green_sBIT
)-1));
6481 that
->bluee
+= 1./(2*((1U<<that
->blue_sBIT
)-1));
6485 that
->blue
= that
->green
= that
->red
;
6486 that
->bluef
= that
->greenf
= that
->redf
;
6487 that
->bluee
= that
->greene
= that
->rede
;
6490 if ((that
->colour_type
& PNG_COLOR_MASK_ALPHA
) ||
6491 that
->colour_type
== PNG_COLOR_TYPE_PALETTE
)
6493 that
->alpha
= sample_scale(that
->alphaf
, scale
);
6494 that
->alphae
+= 1./(2*((1U<<that
->alpha_sBIT
)-1));
6498 that
->alpha
= scale
; /* opaque */
6499 that
->alphaf
= 1; /* Override this. */
6500 that
->alphae
= 0; /* It's exact ;-) */
6503 if (sig_bits
&& that
->alpha_sBIT
< that
->sample_depth
)
6504 that
->alpha
>>= that
->sample_depth
- that
->alpha_sBIT
;
6507 /* Static 'end' structure: */
6508 static image_transform image_transform_end
=
6516 image_transform_ini_end
,
6517 image_transform_set_end
,
6518 image_transform_mod_end
,
6519 0 /* never called, I want it to crash if it is! */
6522 /* Reader callbacks and implementations, where they differ from the standard
6526 transform_display_init(transform_display
*dp
, png_modifier
*pm
, png_uint_32 id
,
6527 const image_transform
*transform_list
)
6529 memset(dp
, 0, sizeof *dp
);
6531 /* Standard fields */
6532 standard_display_init(&dp
->this, &pm
->this, id
, do_read_interlace
,
6533 pm
->use_update_info
);
6535 /* Parameter fields */
6537 dp
->transform_list
= transform_list
;
6538 dp
->max_gamma_8
= 16;
6540 /* Local variable fields */
6541 dp
->output_colour_type
= 255; /* invalid */
6542 dp
->output_bit_depth
= 255; /* invalid */
6543 dp
->unpacked
= 0; /* not unpacked */
6547 transform_info_imp(transform_display
*dp
, png_structp pp
, png_infop pi
)
6549 /* Reuse the standard stuff as appropriate. */
6550 standard_info_part1(&dp
->this, pp
, pi
);
6552 /* Now set the list of transforms. */
6553 dp
->transform_list
->set(dp
->transform_list
, dp
, pp
, pi
);
6555 /* Update the info structure for these transforms: */
6557 int i
= dp
->this.use_update_info
;
6558 /* Always do one call, even if use_update_info is 0. */
6560 png_read_update_info(pp
, pi
);
6564 /* And get the output information into the standard_display */
6565 standard_info_part2(&dp
->this, pp
, pi
, 1/*images*/);
6567 /* Plus the extra stuff we need for the transform tests: */
6568 dp
->output_colour_type
= png_get_color_type(pp
, pi
);
6569 dp
->output_bit_depth
= png_get_bit_depth(pp
, pi
);
6571 /* If png_set_filler is in action then fake the output color type to include
6572 * an alpha channel where appropriate.
6574 if (dp
->output_bit_depth
>= 8 &&
6575 (dp
->output_colour_type
== PNG_COLOR_TYPE_RGB
||
6576 dp
->output_colour_type
== PNG_COLOR_TYPE_GRAY
) && dp
->this.filler
)
6577 dp
->output_colour_type
|= 4;
6579 /* Validate the combination of colour type and bit depth that we are getting
6580 * out of libpng; the semantics of something not in the PNG spec are, at
6583 switch (dp
->output_colour_type
)
6585 case PNG_COLOR_TYPE_PALETTE
:
6586 if (dp
->output_bit_depth
> 8) goto error
;
6588 case PNG_COLOR_TYPE_GRAY
:
6589 if (dp
->output_bit_depth
== 1 || dp
->output_bit_depth
== 2 ||
6590 dp
->output_bit_depth
== 4)
6594 if (dp
->output_bit_depth
== 8 || dp
->output_bit_depth
== 16)
6602 pos
= safecat(message
, sizeof message
, 0,
6603 "invalid final bit depth: colour type(");
6604 pos
= safecatn(message
, sizeof message
, pos
, dp
->output_colour_type
);
6605 pos
= safecat(message
, sizeof message
, pos
, ") with bit depth: ");
6606 pos
= safecatn(message
, sizeof message
, pos
, dp
->output_bit_depth
);
6608 png_error(pp
, message
);
6612 /* Use a test pixel to check that the output agrees with what we expect -
6613 * this avoids running the whole test if the output is unexpected. This also
6614 * checks for internal errors.
6617 image_pixel test_pixel
;
6619 memset(&test_pixel
, 0, sizeof test_pixel
);
6620 test_pixel
.colour_type
= dp
->this.colour_type
; /* input */
6621 test_pixel
.bit_depth
= dp
->this.bit_depth
;
6622 if (test_pixel
.colour_type
== PNG_COLOR_TYPE_PALETTE
)
6623 test_pixel
.sample_depth
= 8;
6625 test_pixel
.sample_depth
= test_pixel
.bit_depth
;
6626 /* Don't need sBIT here, but it must be set to non-zero to avoid
6627 * arithmetic overflows.
6629 test_pixel
.have_tRNS
= dp
->this.is_transparent
!= 0;
6630 test_pixel
.red_sBIT
= test_pixel
.green_sBIT
= test_pixel
.blue_sBIT
=
6631 test_pixel
.alpha_sBIT
= test_pixel
.sample_depth
;
6633 dp
->transform_list
->mod(dp
->transform_list
, &test_pixel
, pp
, dp
);
6635 if (test_pixel
.colour_type
!= dp
->output_colour_type
)
6638 size_t pos
= safecat(message
, sizeof message
, 0, "colour type ");
6640 pos
= safecatn(message
, sizeof message
, pos
, dp
->output_colour_type
);
6641 pos
= safecat(message
, sizeof message
, pos
, " expected ");
6642 pos
= safecatn(message
, sizeof message
, pos
, test_pixel
.colour_type
);
6644 png_error(pp
, message
);
6647 if (test_pixel
.bit_depth
!= dp
->output_bit_depth
)
6650 size_t pos
= safecat(message
, sizeof message
, 0, "bit depth ");
6652 pos
= safecatn(message
, sizeof message
, pos
, dp
->output_bit_depth
);
6653 pos
= safecat(message
, sizeof message
, pos
, " expected ");
6654 pos
= safecatn(message
, sizeof message
, pos
, test_pixel
.bit_depth
);
6656 png_error(pp
, message
);
6659 /* If both bit depth and colour type are correct check the sample depth.
6661 if (test_pixel
.colour_type
== PNG_COLOR_TYPE_PALETTE
&&
6662 test_pixel
.sample_depth
!= 8) /* oops - internal error! */
6663 png_error(pp
, "pngvalid: internal: palette sample depth not 8");
6664 else if (dp
->unpacked
&& test_pixel
.bit_depth
!= 8)
6665 png_error(pp
, "pngvalid: internal: bad unpacked pixel depth");
6666 else if (!dp
->unpacked
&& test_pixel
.colour_type
!= PNG_COLOR_TYPE_PALETTE
6667 && test_pixel
.bit_depth
!= test_pixel
.sample_depth
)
6670 size_t pos
= safecat(message
, sizeof message
, 0,
6671 "internal: sample depth ");
6673 /* Because unless something has set 'unpacked' or the image is palette
6674 * mapped we expect the transform to keep sample depth and bit depth
6677 pos
= safecatn(message
, sizeof message
, pos
, test_pixel
.sample_depth
);
6678 pos
= safecat(message
, sizeof message
, pos
, " expected ");
6679 pos
= safecatn(message
, sizeof message
, pos
, test_pixel
.bit_depth
);
6681 png_error(pp
, message
);
6683 else if (test_pixel
.bit_depth
!= dp
->output_bit_depth
)
6685 /* This could be a libpng error too; libpng has not produced what we
6686 * expect for the output bit depth.
6689 size_t pos
= safecat(message
, sizeof message
, 0,
6690 "internal: bit depth ");
6692 pos
= safecatn(message
, sizeof message
, pos
, dp
->output_bit_depth
);
6693 pos
= safecat(message
, sizeof message
, pos
, " expected ");
6694 pos
= safecatn(message
, sizeof message
, pos
, test_pixel
.bit_depth
);
6696 png_error(pp
, message
);
6701 static void PNGCBAPI
6702 transform_info(png_structp pp
, png_infop pi
)
6704 transform_info_imp(voidcast(transform_display
*, png_get_progressive_ptr(pp
)),
6709 transform_range_check(png_const_structp pp
, unsigned int r
, unsigned int g
,
6710 unsigned int b
, unsigned int a
, unsigned int in_digitized
, double in
,
6711 unsigned int out
, png_byte sample_depth
, double err
, double limit
,
6712 const char *name
, double digitization_error
)
6714 /* Compare the scaled, digitzed, values of our local calculation (in+-err)
6715 * with the digitized values libpng produced; 'sample_depth' is the actual
6716 * digitization depth of the libpng output colors (the bit depth except for
6717 * palette images where it is always 8.) The check on 'err' is to detect
6718 * internal errors in pngvalid itself.
6720 unsigned int max
= (1U<<sample_depth
)-1;
6721 double in_min
= ceil((in
-err
)*max
- digitization_error
);
6722 double in_max
= floor((in
+err
)*max
+ digitization_error
);
6723 if (debugonly(err
> limit
||) !(out
>= in_min
&& out
<= in_max
))
6728 pos
= safecat(message
, sizeof message
, 0, name
);
6729 pos
= safecat(message
, sizeof message
, pos
, " output value error: rgba(");
6730 pos
= safecatn(message
, sizeof message
, pos
, r
);
6731 pos
= safecat(message
, sizeof message
, pos
, ",");
6732 pos
= safecatn(message
, sizeof message
, pos
, g
);
6733 pos
= safecat(message
, sizeof message
, pos
, ",");
6734 pos
= safecatn(message
, sizeof message
, pos
, b
);
6735 pos
= safecat(message
, sizeof message
, pos
, ",");
6736 pos
= safecatn(message
, sizeof message
, pos
, a
);
6737 pos
= safecat(message
, sizeof message
, pos
, "): ");
6738 pos
= safecatn(message
, sizeof message
, pos
, out
);
6739 pos
= safecat(message
, sizeof message
, pos
, " expected: ");
6740 pos
= safecatn(message
, sizeof message
, pos
, in_digitized
);
6741 pos
= safecat(message
, sizeof message
, pos
, " (");
6742 pos
= safecatd(message
, sizeof message
, pos
, (in
-err
)*max
, 3);
6743 pos
= safecat(message
, sizeof message
, pos
, "..");
6744 pos
= safecatd(message
, sizeof message
, pos
, (in
+err
)*max
, 3);
6745 pos
= safecat(message
, sizeof message
, pos
, ")");
6747 png_error(pp
, message
);
6754 transform_image_validate(transform_display
*dp
, png_const_structp pp
,
6757 /* Constants for the loop below: */
6758 const png_store
* const ps
= dp
->this.ps
;
6759 png_byte in_ct
= dp
->this.colour_type
;
6760 png_byte in_bd
= dp
->this.bit_depth
;
6761 png_uint_32 w
= dp
->this.w
;
6762 png_uint_32 h
= dp
->this.h
;
6763 png_byte out_ct
= dp
->output_colour_type
;
6764 png_byte out_bd
= dp
->output_bit_depth
;
6765 png_byte sample_depth
=
6766 (png_byte
)(out_ct
== PNG_COLOR_TYPE_PALETTE
? 8 : out_bd
);
6767 png_byte red_sBIT
= dp
->this.red_sBIT
;
6768 png_byte green_sBIT
= dp
->this.green_sBIT
;
6769 png_byte blue_sBIT
= dp
->this.blue_sBIT
;
6770 png_byte alpha_sBIT
= dp
->this.alpha_sBIT
;
6771 int have_tRNS
= dp
->this.is_transparent
;
6772 double digitization_error
;
6774 store_palette out_palette
;
6779 /* Check for row overwrite errors */
6780 store_image_check(dp
->this.ps
, pp
, 0);
6782 /* Read the palette corresponding to the output if the output colour type
6783 * indicates a palette, otherwise set out_palette to garbage.
6785 if (out_ct
== PNG_COLOR_TYPE_PALETTE
)
6787 /* Validate that the palette count itself has not changed - this is not
6790 int npalette
= (-1);
6792 (void)read_palette(out_palette
, &npalette
, pp
, pi
);
6793 if (npalette
!= dp
->this.npalette
)
6794 png_error(pp
, "unexpected change in palette size");
6796 digitization_error
= .5;
6800 png_byte in_sample_depth
;
6802 memset(out_palette
, 0x5e, sizeof out_palette
);
6804 /* use-input-precision means assume that if the input has 8 bit (or less)
6805 * samples and the output has 16 bit samples the calculations will be done
6806 * with 8 bit precision, not 16.
6808 if (in_ct
== PNG_COLOR_TYPE_PALETTE
|| in_bd
< 16)
6809 in_sample_depth
= 8;
6811 in_sample_depth
= in_bd
;
6813 if (sample_depth
!= 16 || in_sample_depth
> 8 ||
6814 !dp
->pm
->calculations_use_input_precision
)
6815 digitization_error
= .5;
6817 /* Else calculations are at 8 bit precision, and the output actually
6818 * consists of scaled 8-bit values, so scale .5 in 8 bits to the 16 bits:
6821 digitization_error
= .5 * 257;
6826 png_const_bytep
const pRow
= store_image_row(ps
, pp
, 0, y
);
6829 /* The original, standard, row pre-transforms. */
6830 png_byte std
[STANDARD_ROWMAX
];
6832 transform_row(pp
, std
, in_ct
, in_bd
, y
);
6834 /* Go through each original pixel transforming it and comparing with what
6835 * libpng did to the same pixel.
6839 image_pixel in_pixel
, out_pixel
;
6840 unsigned int r
, g
, b
, a
;
6842 /* Find out what we think the pixel should be: */
6843 image_pixel_init(&in_pixel
, std
, in_ct
, in_bd
, x
, dp
->this.palette
,
6846 in_pixel
.red_sBIT
= red_sBIT
;
6847 in_pixel
.green_sBIT
= green_sBIT
;
6848 in_pixel
.blue_sBIT
= blue_sBIT
;
6849 in_pixel
.alpha_sBIT
= alpha_sBIT
;
6850 in_pixel
.have_tRNS
= have_tRNS
!= 0;
6852 /* For error detection, below. */
6858 /* This applies the transforms to the input data, including output
6859 * format operations which must be used when reading the output
6860 * pixel that libpng produces.
6862 dp
->transform_list
->mod(dp
->transform_list
, &in_pixel
, pp
, dp
);
6864 /* Read the output pixel and compare it to what we got, we don't
6865 * use the error field here, so no need to update sBIT. in_pixel
6866 * says whether we expect libpng to change the output format.
6868 image_pixel_init(&out_pixel
, pRow
, out_ct
, out_bd
, x
, out_palette
,
6871 /* We don't expect changes to the index here even if the bit depth is
6874 if (in_ct
== PNG_COLOR_TYPE_PALETTE
&&
6875 out_ct
== PNG_COLOR_TYPE_PALETTE
)
6877 if (in_pixel
.palette_index
!= out_pixel
.palette_index
)
6878 png_error(pp
, "unexpected transformed palette index");
6881 /* Check the colours for palette images too - in fact the palette could
6882 * be separately verified itself in most cases.
6884 if (in_pixel
.red
!= out_pixel
.red
)
6885 transform_range_check(pp
, r
, g
, b
, a
, in_pixel
.red
, in_pixel
.redf
,
6886 out_pixel
.red
, sample_depth
, in_pixel
.rede
,
6887 dp
->pm
->limit
+ 1./(2*((1U<<in_pixel
.red_sBIT
)-1)), "red/gray",
6888 digitization_error
);
6890 if ((out_ct
& PNG_COLOR_MASK_COLOR
) != 0 &&
6891 in_pixel
.green
!= out_pixel
.green
)
6892 transform_range_check(pp
, r
, g
, b
, a
, in_pixel
.green
,
6893 in_pixel
.greenf
, out_pixel
.green
, sample_depth
, in_pixel
.greene
,
6894 dp
->pm
->limit
+ 1./(2*((1U<<in_pixel
.green_sBIT
)-1)), "green",
6895 digitization_error
);
6897 if ((out_ct
& PNG_COLOR_MASK_COLOR
) != 0 &&
6898 in_pixel
.blue
!= out_pixel
.blue
)
6899 transform_range_check(pp
, r
, g
, b
, a
, in_pixel
.blue
, in_pixel
.bluef
,
6900 out_pixel
.blue
, sample_depth
, in_pixel
.bluee
,
6901 dp
->pm
->limit
+ 1./(2*((1U<<in_pixel
.blue_sBIT
)-1)), "blue",
6902 digitization_error
);
6904 if ((out_ct
& PNG_COLOR_MASK_ALPHA
) != 0 &&
6905 in_pixel
.alpha
!= out_pixel
.alpha
)
6906 transform_range_check(pp
, r
, g
, b
, a
, in_pixel
.alpha
,
6907 in_pixel
.alphaf
, out_pixel
.alpha
, sample_depth
, in_pixel
.alphae
,
6908 dp
->pm
->limit
+ 1./(2*((1U<<in_pixel
.alpha_sBIT
)-1)), "alpha",
6909 digitization_error
);
6910 } /* pixel (x) loop */
6911 } /* row (y) loop */
6913 /* Record that something was actually checked to avoid a false positive. */
6914 dp
->this.ps
->validated
= 1;
6917 static void PNGCBAPI
6918 transform_end(png_structp ppIn
, png_infop pi
)
6920 png_const_structp pp
= ppIn
;
6921 transform_display
*dp
= voidcast(transform_display
*,
6922 png_get_progressive_ptr(pp
));
6924 if (!dp
->this.speed
)
6925 transform_image_validate(dp
, pp
, pi
);
6927 dp
->this.ps
->validated
= 1;
6930 /* A single test run. */
6932 transform_test(png_modifier
*pmIn
, png_uint_32 idIn
,
6933 const image_transform
* transform_listIn
, const char * const name
)
6935 transform_display d
;
6936 context(&pmIn
->this, fault
);
6938 transform_display_init(&d
, pmIn
, idIn
, transform_listIn
);
6945 char full_name
[256];
6947 /* Make sure the encoding fields are correct and enter the required
6950 transform_set_encoding(&d
);
6952 /* Add any modifications required by the transform list. */
6953 d
.transform_list
->ini(d
.transform_list
, &d
);
6955 /* Add the color space information, if any, to the name. */
6956 pos
= safecat(full_name
, sizeof full_name
, pos
, name
);
6957 pos
= safecat_current_encoding(full_name
, sizeof full_name
, pos
, d
.pm
);
6959 /* Get a png_struct for reading the image. */
6960 pp
= set_modifier_for_read(d
.pm
, &pi
, d
.this.id
, full_name
);
6961 standard_palette_init(&d
.this);
6964 /* Logging (debugging only) */
6968 (void)store_message(&d
.pm
->this, pp
, buffer
, sizeof buffer
, 0,
6971 fprintf(stderr
, "%s\n", buffer
);
6975 /* Introduce the correct read function. */
6976 if (d
.pm
->this.progressive
)
6978 /* Share the row function with the standard implementation. */
6979 png_set_progressive_read_fn(pp
, &d
, transform_info
, progressive_row
,
6982 /* Now feed data into the reader until we reach the end: */
6983 modifier_progressive_read(d
.pm
, pp
, pi
);
6987 /* modifier_read expects a png_modifier* */
6988 png_set_read_fn(pp
, d
.pm
, modifier_read
);
6990 /* Check the header values: */
6991 png_read_info(pp
, pi
);
6993 /* Process the 'info' requirements. Only one image is generated */
6994 transform_info_imp(&d
, pp
, pi
);
6996 sequential_row(&d
.this, pp
, pi
, -1, 0);
6999 transform_image_validate(&d
, pp
, pi
);
7001 d
.this.ps
->validated
= 1;
7004 modifier_reset(d
.pm
);
7009 modifier_reset(voidcast(png_modifier
*,(void*)fault
));
7013 /* The transforms: */
7014 #define ITSTRUCT(name) image_transform_##name
7015 #define ITDATA(name) image_transform_data_##name
7016 #define image_transform_ini image_transform_default_ini
7018 static image_transform ITSTRUCT(name) =\
7026 image_transform_ini,\
7027 image_transform_png_set_##name##_set,\
7028 image_transform_png_set_##name##_mod,\
7029 image_transform_png_set_##name##_add\
7031 #define PT ITSTRUCT(end) /* stores the previous transform */
7034 extern void image_transform_default_ini(const image_transform
*this,
7035 transform_display
*that
); /* silence GCC warnings */
7037 void /* private, but almost always needed */
7038 image_transform_default_ini(const image_transform
*this,
7039 transform_display
*that
)
7041 this->next
->ini(this->next
, that
);
7044 #ifdef PNG_READ_BACKGROUND_SUPPORTED
7046 image_transform_default_add(image_transform
*this,
7047 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7059 #ifdef PNG_READ_EXPAND_SUPPORTED
7060 /* png_set_palette_to_rgb */
7062 image_transform_png_set_palette_to_rgb_set(const image_transform
*this,
7063 transform_display
*that
, png_structp pp
, png_infop pi
)
7065 png_set_palette_to_rgb(pp
);
7066 this->next
->set(this->next
, that
, pp
, pi
);
7070 image_transform_png_set_palette_to_rgb_mod(const image_transform
*this,
7071 image_pixel
*that
, png_const_structp pp
,
7072 const transform_display
*display
)
7074 if (that
->colour_type
== PNG_COLOR_TYPE_PALETTE
)
7075 image_pixel_convert_PLTE(that
);
7077 this->next
->mod(this->next
, that
, pp
, display
);
7081 image_transform_png_set_palette_to_rgb_add(image_transform
*this,
7082 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7089 return colour_type
== PNG_COLOR_TYPE_PALETTE
;
7094 #define PT ITSTRUCT(palette_to_rgb)
7095 #endif /* PNG_READ_EXPAND_SUPPORTED */
7097 #ifdef PNG_READ_EXPAND_SUPPORTED
7098 /* png_set_tRNS_to_alpha */
7100 image_transform_png_set_tRNS_to_alpha_set(const image_transform
*this,
7101 transform_display
*that
, png_structp pp
, png_infop pi
)
7103 png_set_tRNS_to_alpha(pp
);
7105 /* If there was a tRNS chunk that would get expanded and add an alpha
7106 * channel is_transparent must be updated:
7108 if (that
->this.has_tRNS
)
7109 that
->this.is_transparent
= 1;
7111 this->next
->set(this->next
, that
, pp
, pi
);
7115 image_transform_png_set_tRNS_to_alpha_mod(const image_transform
*this,
7116 image_pixel
*that
, png_const_structp pp
,
7117 const transform_display
*display
)
7119 #if PNG_LIBPNG_VER < 10700
7120 /* LIBPNG BUG: this always forces palette images to RGB. */
7121 if (that
->colour_type
== PNG_COLOR_TYPE_PALETTE
)
7122 image_pixel_convert_PLTE(that
);
7125 /* This effectively does an 'expand' only if there is some transparency to
7126 * convert to an alpha channel.
7128 if (that
->have_tRNS
)
7129 # if PNG_LIBPNG_VER >= 10700
7130 if (that
->colour_type
!= PNG_COLOR_TYPE_PALETTE
&&
7131 (that
->colour_type
& PNG_COLOR_MASK_ALPHA
) == 0)
7133 image_pixel_add_alpha(that
, &display
->this, 0/*!for background*/);
7135 #if PNG_LIBPNG_VER < 10700
7136 /* LIBPNG BUG: otherwise libpng still expands to 8 bits! */
7139 if (that
->bit_depth
< 8)
7141 if (that
->sample_depth
< 8)
7142 that
->sample_depth
= 8;
7146 this->next
->mod(this->next
, that
, pp
, display
);
7150 image_transform_png_set_tRNS_to_alpha_add(image_transform
*this,
7151 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7158 /* We don't know yet whether there will be a tRNS chunk, but we know that
7159 * this transformation should do nothing if there already is an alpha
7160 * channel. In addition, after the bug fix in 1.7.0, there is no longer
7161 * any action on a palette image.
7164 # if PNG_LIBPNG_VER >= 10700
7165 colour_type
!= PNG_COLOR_TYPE_PALETTE
&&
7167 (colour_type
& PNG_COLOR_MASK_ALPHA
) == 0;
7172 #define PT ITSTRUCT(tRNS_to_alpha)
7173 #endif /* PNG_READ_EXPAND_SUPPORTED */
7175 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
7176 /* png_set_gray_to_rgb */
7178 image_transform_png_set_gray_to_rgb_set(const image_transform
*this,
7179 transform_display
*that
, png_structp pp
, png_infop pi
)
7181 png_set_gray_to_rgb(pp
);
7182 /* NOTE: this doesn't result in tRNS expansion. */
7183 this->next
->set(this->next
, that
, pp
, pi
);
7187 image_transform_png_set_gray_to_rgb_mod(const image_transform
*this,
7188 image_pixel
*that
, png_const_structp pp
,
7189 const transform_display
*display
)
7191 /* NOTE: we can actually pend the tRNS processing at this point because we
7192 * can correctly recognize the original pixel value even though we have
7193 * mapped the one gray channel to the three RGB ones, but in fact libpng
7194 * doesn't do this, so we don't either.
7196 if ((that
->colour_type
& PNG_COLOR_MASK_COLOR
) == 0 && that
->have_tRNS
)
7197 image_pixel_add_alpha(that
, &display
->this, 0/*!for background*/);
7199 /* Simply expand the bit depth and alter the colour type as required. */
7200 if (that
->colour_type
== PNG_COLOR_TYPE_GRAY
)
7202 /* RGB images have a bit depth at least equal to '8' */
7203 if (that
->bit_depth
< 8)
7204 that
->sample_depth
= that
->bit_depth
= 8;
7206 /* And just changing the colour type works here because the green and blue
7207 * channels are being maintained in lock-step with the red/gray:
7209 that
->colour_type
= PNG_COLOR_TYPE_RGB
;
7212 else if (that
->colour_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
7213 that
->colour_type
= PNG_COLOR_TYPE_RGB_ALPHA
;
7215 this->next
->mod(this->next
, that
, pp
, display
);
7219 image_transform_png_set_gray_to_rgb_add(image_transform
*this,
7220 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7227 return (colour_type
& PNG_COLOR_MASK_COLOR
) == 0;
7232 #define PT ITSTRUCT(gray_to_rgb)
7233 #endif /* PNG_READ_GRAY_TO_RGB_SUPPORTED */
7235 #ifdef PNG_READ_EXPAND_SUPPORTED
7236 /* png_set_expand */
7238 image_transform_png_set_expand_set(const image_transform
*this,
7239 transform_display
*that
, png_structp pp
, png_infop pi
)
7243 if (that
->this.has_tRNS
)
7244 that
->this.is_transparent
= 1;
7246 this->next
->set(this->next
, that
, pp
, pi
);
7250 image_transform_png_set_expand_mod(const image_transform
*this,
7251 image_pixel
*that
, png_const_structp pp
,
7252 const transform_display
*display
)
7254 /* The general expand case depends on what the colour type is: */
7255 if (that
->colour_type
== PNG_COLOR_TYPE_PALETTE
)
7256 image_pixel_convert_PLTE(that
);
7257 else if (that
->bit_depth
< 8) /* grayscale */
7258 that
->sample_depth
= that
->bit_depth
= 8;
7260 if (that
->have_tRNS
)
7261 image_pixel_add_alpha(that
, &display
->this, 0/*!for background*/);
7263 this->next
->mod(this->next
, that
, pp
, display
);
7267 image_transform_png_set_expand_add(image_transform
*this,
7268 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7275 /* 'expand' should do nothing for RGBA or GA input - no tRNS and the bit
7276 * depth is at least 8 already.
7278 return (colour_type
& PNG_COLOR_MASK_ALPHA
) == 0;
7283 #define PT ITSTRUCT(expand)
7284 #endif /* PNG_READ_EXPAND_SUPPORTED */
7286 #ifdef PNG_READ_EXPAND_SUPPORTED
7287 /* png_set_expand_gray_1_2_4_to_8
7288 * Pre 1.7.0 LIBPNG BUG: this just does an 'expand'
7291 image_transform_png_set_expand_gray_1_2_4_to_8_set(
7292 const image_transform
*this, transform_display
*that
, png_structp pp
,
7295 png_set_expand_gray_1_2_4_to_8(pp
);
7296 /* NOTE: don't expect this to expand tRNS */
7297 this->next
->set(this->next
, that
, pp
, pi
);
7301 image_transform_png_set_expand_gray_1_2_4_to_8_mod(
7302 const image_transform
*this, image_pixel
*that
, png_const_structp pp
,
7303 const transform_display
*display
)
7305 #if PNG_LIBPNG_VER < 10700
7306 image_transform_png_set_expand_mod(this, that
, pp
, display
);
7308 /* Only expand grayscale of bit depth less than 8: */
7309 if (that
->colour_type
== PNG_COLOR_TYPE_GRAY
&&
7310 that
->bit_depth
< 8)
7311 that
->sample_depth
= that
->bit_depth
= 8;
7313 this->next
->mod(this->next
, that
, pp
, display
);
7314 #endif /* 1.7 or later */
7318 image_transform_png_set_expand_gray_1_2_4_to_8_add(image_transform
*this,
7319 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7321 #if PNG_LIBPNG_VER < 10700
7322 return image_transform_png_set_expand_add(this, that
, colour_type
,
7330 /* This should do nothing unless the color type is gray and the bit depth is
7333 return colour_type
== PNG_COLOR_TYPE_GRAY
&& bit_depth
< 8;
7334 #endif /* 1.7 or later */
7337 IT(expand_gray_1_2_4_to_8
);
7339 #define PT ITSTRUCT(expand_gray_1_2_4_to_8)
7340 #endif /* PNG_READ_EXPAND_SUPPORTED */
7342 #ifdef PNG_READ_EXPAND_16_SUPPORTED
7343 /* png_set_expand_16 */
7345 image_transform_png_set_expand_16_set(const image_transform
*this,
7346 transform_display
*that
, png_structp pp
, png_infop pi
)
7348 png_set_expand_16(pp
);
7350 /* NOTE: prior to 1.7 libpng does SET_EXPAND as well, so tRNS is expanded. */
7351 # if PNG_LIBPNG_VER < 10700
7352 if (that
->this.has_tRNS
)
7353 that
->this.is_transparent
= 1;
7356 this->next
->set(this->next
, that
, pp
, pi
);
7360 image_transform_png_set_expand_16_mod(const image_transform
*this,
7361 image_pixel
*that
, png_const_structp pp
,
7362 const transform_display
*display
)
7364 /* Expect expand_16 to expand everything to 16 bits as a result of also
7365 * causing 'expand' to happen.
7367 if (that
->colour_type
== PNG_COLOR_TYPE_PALETTE
)
7368 image_pixel_convert_PLTE(that
);
7370 if (that
->have_tRNS
)
7371 image_pixel_add_alpha(that
, &display
->this, 0/*!for background*/);
7373 if (that
->bit_depth
< 16)
7374 that
->sample_depth
= that
->bit_depth
= 16;
7376 this->next
->mod(this->next
, that
, pp
, display
);
7380 image_transform_png_set_expand_16_add(image_transform
*this,
7381 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7388 /* expand_16 does something unless the bit depth is already 16. */
7389 return bit_depth
< 16;
7394 #define PT ITSTRUCT(expand_16)
7395 #endif /* PNG_READ_EXPAND_16_SUPPORTED */
7397 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED /* API added in 1.5.4 */
7398 /* png_set_scale_16 */
7400 image_transform_png_set_scale_16_set(const image_transform
*this,
7401 transform_display
*that
, png_structp pp
, png_infop pi
)
7403 png_set_scale_16(pp
);
7404 # if PNG_LIBPNG_VER < 10700
7405 /* libpng will limit the gamma table size: */
7406 that
->max_gamma_8
= PNG_MAX_GAMMA_8
;
7408 this->next
->set(this->next
, that
, pp
, pi
);
7412 image_transform_png_set_scale_16_mod(const image_transform
*this,
7413 image_pixel
*that
, png_const_structp pp
,
7414 const transform_display
*display
)
7416 if (that
->bit_depth
== 16)
7418 that
->sample_depth
= that
->bit_depth
= 8;
7419 if (that
->red_sBIT
> 8) that
->red_sBIT
= 8;
7420 if (that
->green_sBIT
> 8) that
->green_sBIT
= 8;
7421 if (that
->blue_sBIT
> 8) that
->blue_sBIT
= 8;
7422 if (that
->alpha_sBIT
> 8) that
->alpha_sBIT
= 8;
7425 this->next
->mod(this->next
, that
, pp
, display
);
7429 image_transform_png_set_scale_16_add(image_transform
*this,
7430 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7437 return bit_depth
> 8;
7442 #define PT ITSTRUCT(scale_16)
7443 #endif /* PNG_READ_SCALE_16_TO_8_SUPPORTED (1.5.4 on) */
7445 #ifdef PNG_READ_16_TO_8_SUPPORTED /* the default before 1.5.4 */
7446 /* png_set_strip_16 */
7448 image_transform_png_set_strip_16_set(const image_transform
*this,
7449 transform_display
*that
, png_structp pp
, png_infop pi
)
7451 png_set_strip_16(pp
);
7452 # if PNG_LIBPNG_VER < 10700
7453 /* libpng will limit the gamma table size: */
7454 that
->max_gamma_8
= PNG_MAX_GAMMA_8
;
7456 this->next
->set(this->next
, that
, pp
, pi
);
7460 image_transform_png_set_strip_16_mod(const image_transform
*this,
7461 image_pixel
*that
, png_const_structp pp
,
7462 const transform_display
*display
)
7464 if (that
->bit_depth
== 16)
7466 that
->sample_depth
= that
->bit_depth
= 8;
7467 if (that
->red_sBIT
> 8) that
->red_sBIT
= 8;
7468 if (that
->green_sBIT
> 8) that
->green_sBIT
= 8;
7469 if (that
->blue_sBIT
> 8) that
->blue_sBIT
= 8;
7470 if (that
->alpha_sBIT
> 8) that
->alpha_sBIT
= 8;
7472 /* Prior to 1.5.4 png_set_strip_16 would use an 'accurate' method if this
7473 * configuration option is set. From 1.5.4 the flag is never set and the
7474 * 'scale' API (above) must be used.
7476 # ifdef PNG_READ_ACCURATE_SCALE_SUPPORTED
7477 # if PNG_LIBPNG_VER >= 10504
7478 # error PNG_READ_ACCURATE_SCALE should not be set
7481 /* The strip 16 algorithm drops the low 8 bits rather than calculating
7482 * 1/257, so we need to adjust the permitted errors appropriately:
7483 * Notice that this is only relevant prior to the addition of the
7484 * png_set_scale_16 API in 1.5.4 (but 1.5.4+ always defines the above!)
7487 const double d
= (255-128.5)/65535;
7496 this->next
->mod(this->next
, that
, pp
, display
);
7500 image_transform_png_set_strip_16_add(image_transform
*this,
7501 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7508 return bit_depth
> 8;
7513 #define PT ITSTRUCT(strip_16)
7514 #endif /* PNG_READ_16_TO_8_SUPPORTED */
7516 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
7517 /* png_set_strip_alpha */
7519 image_transform_png_set_strip_alpha_set(const image_transform
*this,
7520 transform_display
*that
, png_structp pp
, png_infop pi
)
7522 png_set_strip_alpha(pp
);
7523 this->next
->set(this->next
, that
, pp
, pi
);
7527 image_transform_png_set_strip_alpha_mod(const image_transform
*this,
7528 image_pixel
*that
, png_const_structp pp
,
7529 const transform_display
*display
)
7531 if (that
->colour_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
7532 that
->colour_type
= PNG_COLOR_TYPE_GRAY
;
7533 else if (that
->colour_type
== PNG_COLOR_TYPE_RGB_ALPHA
)
7534 that
->colour_type
= PNG_COLOR_TYPE_RGB
;
7536 that
->have_tRNS
= 0;
7539 this->next
->mod(this->next
, that
, pp
, display
);
7543 image_transform_png_set_strip_alpha_add(image_transform
*this,
7544 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
7551 return (colour_type
& PNG_COLOR_MASK_ALPHA
) != 0;
7556 #define PT ITSTRUCT(strip_alpha)
7557 #endif /* PNG_READ_STRIP_ALPHA_SUPPORTED */
7559 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
7560 /* png_set_rgb_to_gray(png_structp, int err_action, double red, double green)
7561 * png_set_rgb_to_gray_fixed(png_structp, int err_action, png_fixed_point red,
7562 * png_fixed_point green)
7563 * png_get_rgb_to_gray_status
7565 * The 'default' test here uses values known to be used inside libpng prior to
7572 * These values are being retained for compatibility, along with the somewhat
7573 * broken truncation calculation in the fast-and-inaccurate code path. Older
7574 * versions of libpng will fail the accuracy tests below because they use the
7575 * truncation algorithm everywhere.
7577 #define data ITDATA(rgb_to_gray)
7580 double gamma
; /* File gamma to use in processing */
7582 /* The following are the parameters for png_set_rgb_to_gray: */
7583 # ifdef PNG_FLOATING_POINT_SUPPORTED
7585 double green_to_set
;
7587 png_fixed_point red_to_set
;
7588 png_fixed_point green_to_set
;
7591 /* The actual coefficients: */
7592 double red_coefficient
;
7593 double green_coefficient
;
7594 double blue_coefficient
;
7596 /* Set if the coeefficients have been overridden. */
7597 int coefficients_overridden
;
7600 #undef image_transform_ini
7601 #define image_transform_ini image_transform_png_set_rgb_to_gray_ini
7603 image_transform_png_set_rgb_to_gray_ini(const image_transform
*this,
7604 transform_display
*that
)
7606 png_modifier
*pm
= that
->pm
;
7607 const color_encoding
*e
= pm
->current_encoding
;
7611 /* Since we check the encoding this flag must be set: */
7612 pm
->test_uses_encoding
= 1;
7614 /* If 'e' is not NULL chromaticity information is present and either a cHRM
7615 * or an sRGB chunk will be inserted.
7619 /* Coefficients come from the encoding, but may need to be normalized to a
7620 * white point Y of 1.0
7622 const double whiteY
= e
->red
.Y
+ e
->green
.Y
+ e
->blue
.Y
;
7624 data
.red_coefficient
= e
->red
.Y
;
7625 data
.green_coefficient
= e
->green
.Y
;
7626 data
.blue_coefficient
= e
->blue
.Y
;
7630 data
.red_coefficient
/= whiteY
;
7631 data
.green_coefficient
/= whiteY
;
7632 data
.blue_coefficient
/= whiteY
;
7638 /* The default (built in) coeffcients, as above: */
7639 # if PNG_LIBPNG_VER < 10700
7640 data
.red_coefficient
= 6968 / 32768.;
7641 data
.green_coefficient
= 23434 / 32768.;
7642 data
.blue_coefficient
= 2366 / 32768.;
7644 data
.red_coefficient
= .2126;
7645 data
.green_coefficient
= .7152;
7646 data
.blue_coefficient
= .0722;
7650 data
.gamma
= pm
->current_gamma
;
7652 /* If not set then the calculations assume linear encoding (implicitly): */
7653 if (data
.gamma
== 0)
7656 /* The arguments to png_set_rgb_to_gray can override the coefficients implied
7657 * by the color space encoding. If doing exhaustive checks do the override
7658 * in each case, otherwise do it randomly.
7660 if (pm
->test_exhaustive
)
7662 /* First time in coefficients_overridden is 0, the following sets it to 1,
7663 * so repeat if it is set. If a test fails this may mean we subsequently
7664 * skip a non-override test, ignore that.
7666 data
.coefficients_overridden
= !data
.coefficients_overridden
;
7667 pm
->repeat
= data
.coefficients_overridden
!= 0;
7671 data
.coefficients_overridden
= random_choice();
7673 if (data
.coefficients_overridden
)
7675 /* These values override the color encoding defaults, simply use random
7682 data
.green_coefficient
= total
= (ru
& 0xffff) / 65535.;
7684 data
.red_coefficient
= (1 - total
) * (ru
& 0xffff) / 65535.;
7685 total
+= data
.red_coefficient
;
7686 data
.blue_coefficient
= 1 - total
;
7688 # ifdef PNG_FLOATING_POINT_SUPPORTED
7689 data
.red_to_set
= data
.red_coefficient
;
7690 data
.green_to_set
= data
.green_coefficient
;
7692 data
.red_to_set
= fix(data
.red_coefficient
);
7693 data
.green_to_set
= fix(data
.green_coefficient
);
7696 /* The following just changes the error messages: */
7697 pm
->encoding_ignored
= 1;
7702 data
.red_to_set
= -1;
7703 data
.green_to_set
= -1;
7706 /* Adjust the error limit in the png_modifier because of the larger errors
7707 * produced in the digitization during the gamma handling.
7709 if (data
.gamma
!= 1) /* Use gamma tables */
7711 if (that
->this.bit_depth
== 16 || pm
->assume_16_bit_calculations
)
7713 /* The computations have the form:
7715 * r * rc + g * gc + b * bc
7717 * Each component of which is +/-1/65535 from the gamma_to_1 table
7718 * lookup, resulting in a base error of +/-6. The gamma_from_1
7719 * conversion adds another +/-2 in the 16-bit case and
7720 * +/-(1<<(15-PNG_MAX_GAMMA_8)) in the 8-bit case.
7722 # if PNG_LIBPNG_VER < 10700
7723 if (that
->this.bit_depth
< 16)
7724 that
->max_gamma_8
= PNG_MAX_GAMMA_8
;
7726 that
->pm
->limit
+= pow(
7727 (that
->this.bit_depth
== 16 || that
->max_gamma_8
> 14 ?
7729 6. + (1<<(15-that
->max_gamma_8
))
7730 )/65535, data
.gamma
);
7735 /* Rounding to 8 bits in the linear space causes massive errors which
7736 * will trigger the error check in transform_range_check. Fix that
7737 * here by taking the gamma encoding into account.
7739 * When DIGITIZE is set because a pre-1.7 version of libpng is being
7740 * tested allow a bigger slack.
7742 * NOTE: this number only affects the internal limit check in pngvalid,
7743 * it has no effect on the limits applied to the libpng values.
7746 that
->pm
->limit
+= pow( 2.0/255, data
.gamma
);
7748 that
->pm
->limit
+= pow( 1.0/255, data
.gamma
);
7755 /* With no gamma correction a large error comes from the truncation of the
7756 * calculation in the 8 bit case, allow for that here.
7758 if (that
->this.bit_depth
!= 16 && !pm
->assume_16_bit_calculations
)
7759 that
->pm
->limit
+= 4E-3;
7764 image_transform_png_set_rgb_to_gray_set(const image_transform
*this,
7765 transform_display
*that
, png_structp pp
, png_infop pi
)
7767 int error_action
= 1; /* no error, no defines in png.h */
7769 # ifdef PNG_FLOATING_POINT_SUPPORTED
7770 png_set_rgb_to_gray(pp
, error_action
, data
.red_to_set
, data
.green_to_set
);
7772 png_set_rgb_to_gray_fixed(pp
, error_action
, data
.red_to_set
,
7776 # ifdef PNG_READ_cHRM_SUPPORTED
7777 if (that
->pm
->current_encoding
!= 0)
7779 /* We have an encoding so a cHRM chunk may have been set; if so then
7780 * check that the libpng APIs give the correct (X,Y,Z) values within
7781 * some margin of error for the round trip through the chromaticity
7784 # ifdef PNG_FLOATING_POINT_SUPPORTED
7785 # define API_function png_get_cHRM_XYZ
7786 # define API_form "FP"
7787 # define API_type double
7788 # define API_cvt(x) (x)
7790 # define API_function png_get_cHRM_XYZ_fixed
7791 # define API_form "fixed"
7792 # define API_type png_fixed_point
7793 # define API_cvt(x) ((double)(x)/PNG_FP_1)
7796 API_type rX
, gX
, bX
;
7797 API_type rY
, gY
, bY
;
7798 API_type rZ
, gZ
, bZ
;
7800 if ((API_function(pp
, pi
, &rX
, &rY
, &rZ
, &gX
, &gY
, &gZ
, &bX
, &bY
, &bZ
)
7801 & PNG_INFO_cHRM
) != 0)
7805 color_encoding e
, o
;
7807 /* Expect libpng to return a normalized result, but the original
7808 * color space encoding may not be normalized.
7810 modifier_current_encoding(that
->pm
, &o
);
7811 normalize_color_encoding(&o
);
7813 /* Sanity check the pngvalid code - the coefficients should match
7814 * the normalized Y values of the encoding unless they were
7817 if (data
.red_to_set
== -1 && data
.green_to_set
== -1 &&
7818 (fabs(o
.red
.Y
- data
.red_coefficient
) > DBL_EPSILON
||
7819 fabs(o
.green
.Y
- data
.green_coefficient
) > DBL_EPSILON
||
7820 fabs(o
.blue
.Y
- data
.blue_coefficient
) > DBL_EPSILON
))
7821 png_error(pp
, "internal pngvalid cHRM coefficient error");
7823 /* Generate a colour space encoding. */
7824 e
.gamma
= o
.gamma
; /* not used */
7825 e
.red
.X
= API_cvt(rX
);
7826 e
.red
.Y
= API_cvt(rY
);
7827 e
.red
.Z
= API_cvt(rZ
);
7828 e
.green
.X
= API_cvt(gX
);
7829 e
.green
.Y
= API_cvt(gY
);
7830 e
.green
.Z
= API_cvt(gZ
);
7831 e
.blue
.X
= API_cvt(bX
);
7832 e
.blue
.Y
= API_cvt(bY
);
7833 e
.blue
.Z
= API_cvt(bZ
);
7835 /* This should match the original one from the png_modifier, within
7836 * the range permitted by the libpng fixed point representation.
7839 el
= "-"; /* Set to element name with error */
7841 # define CHECK(col,x)\
7843 double err = fabs(o.col.x - e.col.x);\
7847 el = #col "(" #x ")";\
7861 /* Here in both fixed and floating cases to check the values read
7862 * from the cHRm chunk. PNG uses fixed point in the cHRM chunk, so
7863 * we can't expect better than +/-.5E-5 on the result, allow 1E-5.
7870 pos
= safecat(buffer
, sizeof buffer
, pos
, API_form
);
7871 pos
= safecat(buffer
, sizeof buffer
, pos
, " cHRM ");
7872 pos
= safecat(buffer
, sizeof buffer
, pos
, el
);
7873 pos
= safecat(buffer
, sizeof buffer
, pos
, " error: ");
7874 pos
= safecatd(buffer
, sizeof buffer
, pos
, maxe
, 7);
7875 pos
= safecat(buffer
, sizeof buffer
, pos
, " ");
7876 /* Print the color space without the gamma value: */
7877 pos
= safecat_color_encoding(buffer
, sizeof buffer
, pos
, &o
, 0);
7878 pos
= safecat(buffer
, sizeof buffer
, pos
, " -> ");
7879 pos
= safecat_color_encoding(buffer
, sizeof buffer
, pos
, &e
, 0);
7881 png_error(pp
, buffer
);
7885 # endif /* READ_cHRM */
7887 this->next
->set(this->next
, that
, pp
, pi
);
7891 image_transform_png_set_rgb_to_gray_mod(const image_transform
*this,
7892 image_pixel
*that
, png_const_structp pp
,
7893 const transform_display
*display
)
7895 if ((that
->colour_type
& PNG_COLOR_MASK_COLOR
) != 0)
7899 # if PNG_LIBPNG_VER < 10700
7900 if (that
->colour_type
== PNG_COLOR_TYPE_PALETTE
)
7901 image_pixel_convert_PLTE(that
);
7904 /* Image now has RGB channels... */
7907 png_modifier
*pm
= display
->pm
;
7908 unsigned int sample_depth
= that
->sample_depth
;
7909 unsigned int calc_depth
= (pm
->assume_16_bit_calculations
? 16 :
7911 unsigned int gamma_depth
=
7912 (sample_depth
== 16 ?
7913 display
->max_gamma_8
:
7914 (pm
->assume_16_bit_calculations
?
7915 display
->max_gamma_8
:
7919 double rlo
, rhi
, glo
, ghi
, blo
, bhi
, graylo
, grayhi
;
7921 /* Do this using interval arithmetic, otherwise it is too difficult to
7922 * handle the errors correctly.
7924 * To handle the gamma correction work out the upper and lower bounds
7925 * of the digitized value. Assume rounding here - normally the values
7926 * will be identical after this operation if there is only one
7927 * transform, feel free to delete the png_error checks on this below in
7928 * the future (this is just me trying to ensure it works!)
7930 * Interval arithmetic is exact, but to implement it it must be
7931 * possible to control the floating point implementation rounding mode.
7932 * This cannot be done in ANSI-C, so instead I reduce the 'lo' values
7933 * by DBL_EPSILON and increase the 'hi' values by the same.
7935 # define DD(v,d,r) (digitize(v*(1-DBL_EPSILON), d, r) * (1-DBL_EPSILON))
7936 # define DU(v,d,r) (digitize(v*(1+DBL_EPSILON), d, r) * (1+DBL_EPSILON))
7938 r
= rlo
= rhi
= that
->redf
;
7940 rlo
= DD(rlo
, calc_depth
, 1/*round*/);
7942 rhi
= DU(rhi
, calc_depth
, 1/*round*/);
7944 g
= glo
= ghi
= that
->greenf
;
7945 glo
-= that
->greene
;
7946 glo
= DD(glo
, calc_depth
, 1/*round*/);
7947 ghi
+= that
->greene
;
7948 ghi
= DU(ghi
, calc_depth
, 1/*round*/);
7950 b
= blo
= bhi
= that
->bluef
;
7952 blo
= DD(blo
, calc_depth
, 1/*round*/);
7954 bhi
= DU(bhi
, calc_depth
, 1/*round*/);
7956 isgray
= r
==g
&& g
==b
;
7958 if (data
.gamma
!= 1)
7960 const double power
= 1/data
.gamma
;
7961 const double abse
= .5/(sample_depth
== 16 ? 65535 : 255);
7963 /* If a gamma calculation is done it is done using lookup tables of
7964 * precision gamma_depth, so the already digitized value above may
7965 * need to be further digitized here.
7967 if (gamma_depth
!= calc_depth
)
7969 rlo
= DD(rlo
, gamma_depth
, 0/*truncate*/);
7970 rhi
= DU(rhi
, gamma_depth
, 0/*truncate*/);
7971 glo
= DD(glo
, gamma_depth
, 0/*truncate*/);
7972 ghi
= DU(ghi
, gamma_depth
, 0/*truncate*/);
7973 blo
= DD(blo
, gamma_depth
, 0/*truncate*/);
7974 bhi
= DU(bhi
, gamma_depth
, 0/*truncate*/);
7977 /* 'abse' is the error in the gamma table calculation itself. */
7979 rlo
= DD(pow(rlo
, power
)-abse
, calc_depth
, 1);
7980 rhi
= DU(pow(rhi
, power
)+abse
, calc_depth
, 1);
7983 glo
= DD(pow(glo
, power
)-abse
, calc_depth
, 1);
7984 ghi
= DU(pow(ghi
, power
)+abse
, calc_depth
, 1);
7987 blo
= DD(pow(blo
, power
)-abse
, calc_depth
, 1);
7988 bhi
= DU(pow(bhi
, power
)+abse
, calc_depth
, 1);
7991 /* Now calculate the actual gray values. Although the error in the
7992 * coefficients depends on whether they were specified on the command
7993 * line (in which case truncation to 15 bits happened) or not (rounding
7994 * was used) the maximum error in an individual coefficient is always
7995 * 2/32768, because even in the rounding case the requirement that
7996 * coefficients add up to 32768 can cause a larger rounding error.
7998 * The only time when rounding doesn't occur in 1.5.5 and later is when
7999 * the non-gamma code path is used for less than 16 bit data.
8001 gray
= r
* data
.red_coefficient
+ g
* data
.green_coefficient
+
8002 b
* data
.blue_coefficient
;
8005 int do_round
= data
.gamma
!= 1 || calc_depth
== 16;
8006 const double ce
= 2. / 32768;
8008 graylo
= DD(rlo
* (data
.red_coefficient
-ce
) +
8009 glo
* (data
.green_coefficient
-ce
) +
8010 blo
* (data
.blue_coefficient
-ce
), calc_depth
, do_round
);
8011 if (graylo
> gray
) /* always accept the right answer */
8014 grayhi
= DU(rhi
* (data
.red_coefficient
+ce
) +
8015 ghi
* (data
.green_coefficient
+ce
) +
8016 bhi
* (data
.blue_coefficient
+ce
), calc_depth
, do_round
);
8021 /* And invert the gamma. */
8022 if (data
.gamma
!= 1)
8024 const double power
= data
.gamma
;
8026 /* And this happens yet again, shifting the values once more. */
8027 if (gamma_depth
!= sample_depth
)
8029 rlo
= DD(rlo
, gamma_depth
, 0/*truncate*/);
8030 rhi
= DU(rhi
, gamma_depth
, 0/*truncate*/);
8031 glo
= DD(glo
, gamma_depth
, 0/*truncate*/);
8032 ghi
= DU(ghi
, gamma_depth
, 0/*truncate*/);
8033 blo
= DD(blo
, gamma_depth
, 0/*truncate*/);
8034 bhi
= DU(bhi
, gamma_depth
, 0/*truncate*/);
8037 gray
= pow(gray
, power
);
8038 graylo
= DD(pow(graylo
, power
), sample_depth
, 1);
8039 grayhi
= DU(pow(grayhi
, power
), sample_depth
, 1);
8045 /* Now the error can be calculated.
8047 * If r==g==b because there is no overall gamma correction libpng
8048 * currently preserves the original value.
8051 err
= (that
->rede
+ that
->greene
+ that
->bluee
)/3;
8055 err
= fabs(grayhi
-gray
);
8057 if (fabs(gray
- graylo
) > err
)
8058 err
= fabs(graylo
-gray
);
8061 /* Check that this worked: */
8062 if (err
> pm
->limit
)
8067 pos
= safecat(buffer
, sizeof buffer
, pos
, "rgb_to_gray error ");
8068 pos
= safecatd(buffer
, sizeof buffer
, pos
, err
, 6);
8069 pos
= safecat(buffer
, sizeof buffer
, pos
, " exceeds limit ");
8070 pos
= safecatd(buffer
, sizeof buffer
, pos
, pm
->limit
, 6);
8071 png_warning(pp
, buffer
);
8074 #endif /* !RELEASE_BUILD */
8077 # else /* !DIGITIZE */
8079 double r
= that
->redf
;
8080 double re
= that
->rede
;
8081 double g
= that
->greenf
;
8082 double ge
= that
->greene
;
8083 double b
= that
->bluef
;
8084 double be
= that
->bluee
;
8086 # if PNG_LIBPNG_VER < 10700
8087 /* The true gray case involves no math in earlier versions (not
8088 * true, there was some if gamma correction was happening too.)
8090 if (r
== g
&& r
== b
)
8094 if (err
< ge
) err
= ge
;
8095 if (err
< be
) err
= be
;
8099 # endif /* before 1.7 */
8100 if (data
.gamma
== 1)
8102 /* There is no need to do the conversions to and from linear space,
8103 * so the calculation should be a lot more accurate. There is a
8104 * built in error in the coefficients because they only have 15 bits
8105 * and are adjusted to make sure they add up to 32768. This
8106 * involves a integer calculation with truncation of the form:
8108 * ((int)(coefficient * 100000) * 32768)/100000
8110 * This is done to the red and green coefficients (the ones
8111 * provided to the API) then blue is calculated from them so the
8112 * result adds up to 32768. In the worst case this can result in
8113 * a -1 error in red and green and a +2 error in blue. Consequently
8114 * the worst case in the calculation below is 2/32768 error.
8116 * TODO: consider fixing this in libpng by rounding the calculation
8117 * limiting the error to 1/32768.
8119 * Handling this by adding 2/32768 here avoids needing to increase
8120 * the global error limits to take this into account.)
8122 gray
= r
* data
.red_coefficient
+ g
* data
.green_coefficient
+
8123 b
* data
.blue_coefficient
;
8124 err
= re
* data
.red_coefficient
+ ge
* data
.green_coefficient
+
8125 be
* data
.blue_coefficient
+ 2./32768 + gray
* 5 * DBL_EPSILON
;
8130 /* The calculation happens in linear space, and this produces much
8131 * wider errors in the encoded space. These are handled here by
8132 * factoring the errors in to the calculation. There are two table
8133 * lookups in the calculation and each introduces a quantization
8134 * error defined by the table size.
8136 png_modifier
*pm
= display
->pm
;
8137 double in_qe
= (that
->sample_depth
> 8 ? .5/65535 : .5/255);
8138 double out_qe
= (that
->sample_depth
> 8 ? .5/65535 :
8139 (pm
->assume_16_bit_calculations
? .5/(1<<display
->max_gamma_8
) :
8141 double rhi
, ghi
, bhi
, grayhi
;
8142 double g1
= 1/data
.gamma
;
8144 rhi
= r
+ re
+ in_qe
; if (rhi
> 1) rhi
= 1;
8145 r
-= re
+ in_qe
; if (r
< 0) r
= 0;
8146 ghi
= g
+ ge
+ in_qe
; if (ghi
> 1) ghi
= 1;
8147 g
-= ge
+ in_qe
; if (g
< 0) g
= 0;
8148 bhi
= b
+ be
+ in_qe
; if (bhi
> 1) bhi
= 1;
8149 b
-= be
+ in_qe
; if (b
< 0) b
= 0;
8151 r
= pow(r
, g1
)*(1-DBL_EPSILON
); rhi
= pow(rhi
, g1
)*(1+DBL_EPSILON
);
8152 g
= pow(g
, g1
)*(1-DBL_EPSILON
); ghi
= pow(ghi
, g1
)*(1+DBL_EPSILON
);
8153 b
= pow(b
, g1
)*(1-DBL_EPSILON
); bhi
= pow(bhi
, g1
)*(1+DBL_EPSILON
);
8155 /* Work out the lower and upper bounds for the gray value in the
8156 * encoded space, then work out an average and error. Remove the
8157 * previously added input quantization error at this point.
8159 gray
= r
* data
.red_coefficient
+ g
* data
.green_coefficient
+
8160 b
* data
.blue_coefficient
- 2./32768 - out_qe
;
8165 gray
*= (1 - 6 * DBL_EPSILON
);
8166 gray
= pow(gray
, data
.gamma
) * (1-DBL_EPSILON
);
8169 grayhi
= rhi
* data
.red_coefficient
+ ghi
* data
.green_coefficient
+
8170 bhi
* data
.blue_coefficient
+ 2./32768 + out_qe
;
8171 grayhi
*= (1 + 6 * DBL_EPSILON
);
8175 grayhi
= pow(grayhi
, data
.gamma
) * (1+DBL_EPSILON
);
8177 err
= (grayhi
- gray
) / 2;
8178 gray
= (grayhi
+ gray
) / 2;
8181 err
= gray
* DBL_EPSILON
;
8187 /* Validate that the error is within limits (this has caused
8188 * problems before, it's much easier to detect them here.)
8190 if (err
> pm
->limit
)
8195 pos
= safecat(buffer
, sizeof buffer
, pos
, "rgb_to_gray error ");
8196 pos
= safecatd(buffer
, sizeof buffer
, pos
, err
, 6);
8197 pos
= safecat(buffer
, sizeof buffer
, pos
, " exceeds limit ");
8198 pos
= safecatd(buffer
, sizeof buffer
, pos
, pm
->limit
, 6);
8199 png_warning(pp
, buffer
);
8202 #endif /* !RELEASE_BUILD */
8205 # endif /* !DIGITIZE */
8207 that
->bluef
= that
->greenf
= that
->redf
= gray
;
8208 that
->bluee
= that
->greene
= that
->rede
= err
;
8210 /* The sBIT is the minimum of the three colour channel sBITs. */
8211 if (that
->red_sBIT
> that
->green_sBIT
)
8212 that
->red_sBIT
= that
->green_sBIT
;
8213 if (that
->red_sBIT
> that
->blue_sBIT
)
8214 that
->red_sBIT
= that
->blue_sBIT
;
8215 that
->blue_sBIT
= that
->green_sBIT
= that
->red_sBIT
;
8217 /* And remove the colour bit in the type: */
8218 if (that
->colour_type
== PNG_COLOR_TYPE_RGB
)
8219 that
->colour_type
= PNG_COLOR_TYPE_GRAY
;
8220 else if (that
->colour_type
== PNG_COLOR_TYPE_RGB_ALPHA
)
8221 that
->colour_type
= PNG_COLOR_TYPE_GRAY_ALPHA
;
8224 this->next
->mod(this->next
, that
, pp
, display
);
8228 image_transform_png_set_rgb_to_gray_add(image_transform
*this,
8229 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8236 return (colour_type
& PNG_COLOR_MASK_COLOR
) != 0;
8242 #define PT ITSTRUCT(rgb_to_gray)
8243 #undef image_transform_ini
8244 #define image_transform_ini image_transform_default_ini
8245 #endif /* PNG_READ_RGB_TO_GRAY_SUPPORTED */
8247 #ifdef PNG_READ_BACKGROUND_SUPPORTED
8248 /* png_set_background(png_structp, png_const_color_16p background_color,
8249 * int background_gamma_code, int need_expand, double background_gamma)
8250 * png_set_background_fixed(png_structp, png_const_color_16p background_color,
8251 * int background_gamma_code, int need_expand,
8252 * png_fixed_point background_gamma)
8254 * This ignores the gamma (at present.)
8256 #define data ITDATA(background)
8257 static image_pixel data
;
8260 image_transform_png_set_background_set(const image_transform
*this,
8261 transform_display
*that
, png_structp pp
, png_infop pi
)
8263 png_byte colour_type
, bit_depth
;
8264 png_byte random_bytes
[8]; /* 8 bytes - 64 bits - the biggest pixel */
8268 /* We need a background colour, because we don't know exactly what transforms
8269 * have been set we have to supply the colour in the original file format and
8270 * so we need to know what that is! The background colour is stored in the
8271 * transform_display.
8275 /* Read the random value, for colour type 3 the background colour is actually
8276 * expressed as a 24bit rgb, not an index.
8278 colour_type
= that
->this.colour_type
;
8279 if (colour_type
== 3)
8281 colour_type
= PNG_COLOR_TYPE_RGB
;
8283 expand
= 0; /* passing in an RGB not a pixel index */
8288 if (that
->this.has_tRNS
)
8289 that
->this.is_transparent
= 1;
8291 bit_depth
= that
->this.bit_depth
;
8295 image_pixel_init(&data
, random_bytes
, colour_type
,
8296 bit_depth
, 0/*x*/, 0/*unused: palette*/, NULL
/*format*/);
8298 /* Extract the background colour from this image_pixel, but make sure the
8299 * unused fields of 'back' are garbage.
8303 if (colour_type
& PNG_COLOR_MASK_COLOR
)
8305 back
.red
= (png_uint_16
)data
.red
;
8306 back
.green
= (png_uint_16
)data
.green
;
8307 back
.blue
= (png_uint_16
)data
.blue
;
8311 back
.gray
= (png_uint_16
)data
.red
;
8313 #ifdef PNG_FLOATING_POINT_SUPPORTED
8314 png_set_background(pp
, &back
, PNG_BACKGROUND_GAMMA_FILE
, expand
, 0);
8316 png_set_background_fixed(pp
, &back
, PNG_BACKGROUND_GAMMA_FILE
, expand
, 0);
8319 this->next
->set(this->next
, that
, pp
, pi
);
8323 image_transform_png_set_background_mod(const image_transform
*this,
8324 image_pixel
*that
, png_const_structp pp
,
8325 const transform_display
*display
)
8327 /* Check for tRNS first: */
8328 if (that
->have_tRNS
&& that
->colour_type
!= PNG_COLOR_TYPE_PALETTE
)
8329 image_pixel_add_alpha(that
, &display
->this, 1/*for background*/);
8331 /* This is only necessary if the alpha value is less than 1. */
8332 if (that
->alphaf
< 1)
8334 /* Now we do the background calculation without any gamma correction. */
8335 if (that
->alphaf
<= 0)
8337 that
->redf
= data
.redf
;
8338 that
->greenf
= data
.greenf
;
8339 that
->bluef
= data
.bluef
;
8341 that
->rede
= data
.rede
;
8342 that
->greene
= data
.greene
;
8343 that
->bluee
= data
.bluee
;
8345 that
->red_sBIT
= data
.red_sBIT
;
8346 that
->green_sBIT
= data
.green_sBIT
;
8347 that
->blue_sBIT
= data
.blue_sBIT
;
8350 else /* 0 < alpha < 1 */
8352 double alf
= 1 - that
->alphaf
;
8354 that
->redf
= that
->redf
* that
->alphaf
+ data
.redf
* alf
;
8355 that
->rede
= that
->rede
* that
->alphaf
+ data
.rede
* alf
+
8357 that
->greenf
= that
->greenf
* that
->alphaf
+ data
.greenf
* alf
;
8358 that
->greene
= that
->greene
* that
->alphaf
+ data
.greene
* alf
+
8360 that
->bluef
= that
->bluef
* that
->alphaf
+ data
.bluef
* alf
;
8361 that
->bluee
= that
->bluee
* that
->alphaf
+ data
.bluee
* alf
+
8365 /* Remove the alpha type and set the alpha (not in that order.) */
8370 if (that
->colour_type
== PNG_COLOR_TYPE_RGB_ALPHA
)
8371 that
->colour_type
= PNG_COLOR_TYPE_RGB
;
8372 else if (that
->colour_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
8373 that
->colour_type
= PNG_COLOR_TYPE_GRAY
;
8374 /* PNG_COLOR_TYPE_PALETTE is not changed */
8376 this->next
->mod(this->next
, that
, pp
, display
);
8379 #define image_transform_png_set_background_add image_transform_default_add
8384 #define PT ITSTRUCT(background)
8385 #endif /* PNG_READ_BACKGROUND_SUPPORTED */
8387 /* png_set_quantize(png_structp, png_colorp palette, int num_palette,
8388 * int maximum_colors, png_const_uint_16p histogram, int full_quantize)
8390 * Very difficult to validate this!
8394 /* The data layout transforms are handled by swapping our own channel data,
8395 * necessarily these need to happen at the end of the transform list because the
8396 * semantic of the channels changes after these are executed. Some of these,
8397 * like set_shift and set_packing, can't be done at present because they change
8398 * the layout of the data at the sub-sample level so sample() won't get the
8401 /* png_set_invert_alpha */
8402 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
8403 /* Invert the alpha channel
8405 * png_set_invert_alpha(png_structrp png_ptr)
8408 image_transform_png_set_invert_alpha_set(const image_transform
*this,
8409 transform_display
*that
, png_structp pp
, png_infop pi
)
8411 png_set_invert_alpha(pp
);
8412 this->next
->set(this->next
, that
, pp
, pi
);
8416 image_transform_png_set_invert_alpha_mod(const image_transform
*this,
8417 image_pixel
*that
, png_const_structp pp
,
8418 const transform_display
*display
)
8420 if (that
->colour_type
& 4)
8421 that
->alpha_inverted
= 1;
8423 this->next
->mod(this->next
, that
, pp
, display
);
8427 image_transform_png_set_invert_alpha_add(image_transform
*this,
8428 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8435 /* Only has an effect on pixels with alpha: */
8436 return (colour_type
& 4) != 0;
8441 #define PT ITSTRUCT(invert_alpha)
8443 #endif /* PNG_READ_INVERT_ALPHA_SUPPORTED */
8446 #ifdef PNG_READ_BGR_SUPPORTED
8447 /* Swap R,G,B channels to order B,G,R.
8449 * png_set_bgr(png_structrp png_ptr)
8451 * This only has an effect on RGB and RGBA pixels.
8454 image_transform_png_set_bgr_set(const image_transform
*this,
8455 transform_display
*that
, png_structp pp
, png_infop pi
)
8458 this->next
->set(this->next
, that
, pp
, pi
);
8462 image_transform_png_set_bgr_mod(const image_transform
*this,
8463 image_pixel
*that
, png_const_structp pp
,
8464 const transform_display
*display
)
8466 if (that
->colour_type
== PNG_COLOR_TYPE_RGB
||
8467 that
->colour_type
== PNG_COLOR_TYPE_RGBA
)
8470 this->next
->mod(this->next
, that
, pp
, display
);
8474 image_transform_png_set_bgr_add(image_transform
*this,
8475 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8482 return colour_type
== PNG_COLOR_TYPE_RGB
||
8483 colour_type
== PNG_COLOR_TYPE_RGBA
;
8488 #define PT ITSTRUCT(bgr)
8490 #endif /* PNG_READ_BGR_SUPPORTED */
8492 /* png_set_swap_alpha */
8493 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
8494 /* Put the alpha channel first.
8496 * png_set_swap_alpha(png_structrp png_ptr)
8498 * This only has an effect on GA and RGBA pixels.
8501 image_transform_png_set_swap_alpha_set(const image_transform
*this,
8502 transform_display
*that
, png_structp pp
, png_infop pi
)
8504 png_set_swap_alpha(pp
);
8505 this->next
->set(this->next
, that
, pp
, pi
);
8509 image_transform_png_set_swap_alpha_mod(const image_transform
*this,
8510 image_pixel
*that
, png_const_structp pp
,
8511 const transform_display
*display
)
8513 if (that
->colour_type
== PNG_COLOR_TYPE_GA
||
8514 that
->colour_type
== PNG_COLOR_TYPE_RGBA
)
8515 that
->alpha_first
= 1;
8517 this->next
->mod(this->next
, that
, pp
, display
);
8521 image_transform_png_set_swap_alpha_add(image_transform
*this,
8522 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8529 return colour_type
== PNG_COLOR_TYPE_GA
||
8530 colour_type
== PNG_COLOR_TYPE_RGBA
;
8535 #define PT ITSTRUCT(swap_alpha)
8537 #endif /* PNG_READ_SWAP_ALPHA_SUPPORTED */
8540 #ifdef PNG_READ_SWAP_SUPPORTED
8541 /* Byte swap 16-bit components.
8543 * png_set_swap(png_structrp png_ptr)
8546 image_transform_png_set_swap_set(const image_transform
*this,
8547 transform_display
*that
, png_structp pp
, png_infop pi
)
8550 this->next
->set(this->next
, that
, pp
, pi
);
8554 image_transform_png_set_swap_mod(const image_transform
*this,
8555 image_pixel
*that
, png_const_structp pp
,
8556 const transform_display
*display
)
8558 if (that
->bit_depth
== 16)
8561 this->next
->mod(this->next
, that
, pp
, display
);
8565 image_transform_png_set_swap_add(image_transform
*this,
8566 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8573 return bit_depth
== 16;
8578 #define PT ITSTRUCT(swap)
8580 #endif /* PNG_READ_SWAP_SUPPORTED */
8582 #ifdef PNG_READ_FILLER_SUPPORTED
8583 /* Add a filler byte to 8-bit Gray or 24-bit RGB images.
8585 * png_set_filler, (png_structp png_ptr, png_uint_32 filler, int flags));
8592 #define data ITDATA(filler)
8600 image_transform_png_set_filler_set(const image_transform
*this,
8601 transform_display
*that
, png_structp pp
, png_infop pi
)
8603 /* Need a random choice for 'before' and 'after' as well as for the
8604 * filler. The 'filler' value has all 32 bits set, but only bit_depth
8605 * will be used. At this point we don't know bit_depth.
8607 data
.filler
= random_u32();
8608 data
.flags
= random_choice();
8610 png_set_filler(pp
, data
.filler
, data
.flags
);
8612 /* The standard display handling stuff also needs to know that
8613 * there is a filler, so set that here.
8615 that
->this.filler
= 1;
8617 this->next
->set(this->next
, that
, pp
, pi
);
8621 image_transform_png_set_filler_mod(const image_transform
*this,
8622 image_pixel
*that
, png_const_structp pp
,
8623 const transform_display
*display
)
8625 if (that
->bit_depth
>= 8 &&
8626 (that
->colour_type
== PNG_COLOR_TYPE_RGB
||
8627 that
->colour_type
== PNG_COLOR_TYPE_GRAY
))
8629 unsigned int max
= (1U << that
->bit_depth
)-1;
8630 that
->alpha
= data
.filler
& max
;
8631 that
->alphaf
= ((double)that
->alpha
) / max
;
8634 /* The filler has been stored in the alpha channel, we must record
8635 * that this has been done for the checking later on, the color
8636 * type is faked to have an alpha channel, but libpng won't report
8637 * this; the app has to know the extra channel is there and this
8638 * was recording in standard_display::filler above.
8640 that
->colour_type
|= 4; /* alpha added */
8641 that
->alpha_first
= data
.flags
== PNG_FILLER_BEFORE
;
8644 this->next
->mod(this->next
, that
, pp
, display
);
8648 image_transform_png_set_filler_add(image_transform
*this,
8649 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8654 return bit_depth
>= 8 && (colour_type
== PNG_COLOR_TYPE_RGB
||
8655 colour_type
== PNG_COLOR_TYPE_GRAY
);
8661 #define PT ITSTRUCT(filler)
8663 /* png_set_add_alpha, (png_structp png_ptr, png_uint_32 filler, int flags)); */
8664 /* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */
8665 #define data ITDATA(add_alpha)
8673 image_transform_png_set_add_alpha_set(const image_transform
*this,
8674 transform_display
*that
, png_structp pp
, png_infop pi
)
8676 /* Need a random choice for 'before' and 'after' as well as for the
8677 * filler. The 'filler' value has all 32 bits set, but only bit_depth
8678 * will be used. At this point we don't know bit_depth.
8680 data
.filler
= random_u32();
8681 data
.flags
= random_choice();
8683 png_set_add_alpha(pp
, data
.filler
, data
.flags
);
8684 this->next
->set(this->next
, that
, pp
, pi
);
8688 image_transform_png_set_add_alpha_mod(const image_transform
*this,
8689 image_pixel
*that
, png_const_structp pp
,
8690 const transform_display
*display
)
8692 if (that
->bit_depth
>= 8 &&
8693 (that
->colour_type
== PNG_COLOR_TYPE_RGB
||
8694 that
->colour_type
== PNG_COLOR_TYPE_GRAY
))
8696 unsigned int max
= (1U << that
->bit_depth
)-1;
8697 that
->alpha
= data
.filler
& max
;
8698 that
->alphaf
= ((double)that
->alpha
) / max
;
8701 that
->colour_type
|= 4; /* alpha added */
8702 that
->alpha_first
= data
.flags
== PNG_FILLER_BEFORE
;
8705 this->next
->mod(this->next
, that
, pp
, display
);
8709 image_transform_png_set_add_alpha_add(image_transform
*this,
8710 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8715 return bit_depth
>= 8 && (colour_type
== PNG_COLOR_TYPE_RGB
||
8716 colour_type
== PNG_COLOR_TYPE_GRAY
);
8722 #define PT ITSTRUCT(add_alpha)
8724 #endif /* PNG_READ_FILLER_SUPPORTED */
8726 /* png_set_packing */
8727 #ifdef PNG_READ_PACK_SUPPORTED
8728 /* Use 1 byte per pixel in 1, 2, or 4-bit depth files.
8730 * png_set_packing(png_structrp png_ptr)
8732 * This should only affect grayscale and palette images with less than 8 bits
8736 image_transform_png_set_packing_set(const image_transform
*this,
8737 transform_display
*that
, png_structp pp
, png_infop pi
)
8739 png_set_packing(pp
);
8741 this->next
->set(this->next
, that
, pp
, pi
);
8745 image_transform_png_set_packing_mod(const image_transform
*this,
8746 image_pixel
*that
, png_const_structp pp
,
8747 const transform_display
*display
)
8749 /* The general expand case depends on what the colour type is,
8750 * low bit-depth pixel values are unpacked into bytes without
8751 * scaling, so sample_depth is not changed.
8753 if (that
->bit_depth
< 8) /* grayscale or palette */
8754 that
->bit_depth
= 8;
8756 this->next
->mod(this->next
, that
, pp
, display
);
8760 image_transform_png_set_packing_add(image_transform
*this,
8761 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8768 /* Nothing should happen unless the bit depth is less than 8: */
8769 return bit_depth
< 8;
8774 #define PT ITSTRUCT(packing)
8776 #endif /* PNG_READ_PACK_SUPPORTED */
8778 /* png_set_packswap */
8779 #ifdef PNG_READ_PACKSWAP_SUPPORTED
8780 /* Swap pixels packed into bytes; reverses the order on screen so that
8781 * the high order bits correspond to the rightmost pixels.
8783 * png_set_packswap(png_structrp png_ptr)
8786 image_transform_png_set_packswap_set(const image_transform
*this,
8787 transform_display
*that
, png_structp pp
, png_infop pi
)
8789 png_set_packswap(pp
);
8790 that
->this.littleendian
= 1;
8791 this->next
->set(this->next
, that
, pp
, pi
);
8795 image_transform_png_set_packswap_mod(const image_transform
*this,
8796 image_pixel
*that
, png_const_structp pp
,
8797 const transform_display
*display
)
8799 if (that
->bit_depth
< 8)
8800 that
->littleendian
= 1;
8802 this->next
->mod(this->next
, that
, pp
, display
);
8806 image_transform_png_set_packswap_add(image_transform
*this,
8807 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8814 return bit_depth
< 8;
8819 #define PT ITSTRUCT(packswap)
8821 #endif /* PNG_READ_PACKSWAP_SUPPORTED */
8824 /* png_set_invert_mono */
8825 #ifdef PNG_READ_INVERT_MONO_SUPPORTED
8826 /* Invert the gray channel
8828 * png_set_invert_mono(png_structrp png_ptr)
8831 image_transform_png_set_invert_mono_set(const image_transform
*this,
8832 transform_display
*that
, png_structp pp
, png_infop pi
)
8834 png_set_invert_mono(pp
);
8835 this->next
->set(this->next
, that
, pp
, pi
);
8839 image_transform_png_set_invert_mono_mod(const image_transform
*this,
8840 image_pixel
*that
, png_const_structp pp
,
8841 const transform_display
*display
)
8843 if (that
->colour_type
& 4)
8844 that
->mono_inverted
= 1;
8846 this->next
->mod(this->next
, that
, pp
, display
);
8850 image_transform_png_set_invert_mono_add(image_transform
*this,
8851 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8858 /* Only has an effect on pixels with no colour: */
8859 return (colour_type
& 2) == 0;
8864 #define PT ITSTRUCT(invert_mono)
8866 #endif /* PNG_READ_INVERT_MONO_SUPPORTED */
8868 #ifdef PNG_READ_SHIFT_SUPPORTED
8869 /* png_set_shift(png_structp, png_const_color_8p true_bits)
8871 * The output pixels will be shifted by the given true_bits
8874 #define data ITDATA(shift)
8875 static png_color_8 data
;
8878 image_transform_png_set_shift_set(const image_transform
*this,
8879 transform_display
*that
, png_structp pp
, png_infop pi
)
8881 /* Get a random set of shifts. The shifts need to do something
8882 * to test the transform, so they are limited to the bit depth
8883 * of the input image. Notice that in the following the 'gray'
8884 * field is randomized independently. This acts as a check that
8885 * libpng does use the correct field.
8887 unsigned int depth
= that
->this.bit_depth
;
8889 data
.red
= (png_byte
)/*SAFE*/(random_mod(depth
)+1);
8890 data
.green
= (png_byte
)/*SAFE*/(random_mod(depth
)+1);
8891 data
.blue
= (png_byte
)/*SAFE*/(random_mod(depth
)+1);
8892 data
.gray
= (png_byte
)/*SAFE*/(random_mod(depth
)+1);
8893 data
.alpha
= (png_byte
)/*SAFE*/(random_mod(depth
)+1);
8895 png_set_shift(pp
, &data
);
8896 this->next
->set(this->next
, that
, pp
, pi
);
8900 image_transform_png_set_shift_mod(const image_transform
*this,
8901 image_pixel
*that
, png_const_structp pp
,
8902 const transform_display
*display
)
8904 /* Copy the correct values into the sBIT fields, libpng does not do
8905 * anything to palette data:
8907 if (that
->colour_type
!= PNG_COLOR_TYPE_PALETTE
)
8911 /* The sBIT fields are reset to the values previously sent to
8912 * png_set_shift according to the colour type.
8915 if (that
->colour_type
& 2) /* RGB channels */
8917 that
->red_sBIT
= data
.red
;
8918 that
->green_sBIT
= data
.green
;
8919 that
->blue_sBIT
= data
.blue
;
8922 else /* One grey channel */
8923 that
->red_sBIT
= that
->green_sBIT
= that
->blue_sBIT
= data
.gray
;
8925 that
->alpha_sBIT
= data
.alpha
;
8928 this->next
->mod(this->next
, that
, pp
, display
);
8932 image_transform_png_set_shift_add(image_transform
*this,
8933 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8940 return colour_type
!= PNG_COLOR_TYPE_PALETTE
;
8945 #define PT ITSTRUCT(shift)
8947 #endif /* PNG_READ_SHIFT_SUPPORTED */
8949 #ifdef THIS_IS_THE_PROFORMA
8951 image_transform_png_set_@
_set(const image_transform
*this,
8952 transform_display
*that
, png_structp pp
, png_infop pi
)
8955 this->next
->set(this->next
, that
, pp
, pi
);
8959 image_transform_png_set_@
_mod(const image_transform
*this,
8960 image_pixel
*that
, png_const_structp pp
,
8961 const transform_display
*display
)
8963 this->next
->mod(this->next
, that
, pp
, display
);
8967 image_transform_png_set_@
_add(image_transform
*this,
8968 const image_transform
**that
, png_byte colour_type
, png_byte bit_depth
)
8980 /* This may just be 'end' if all the transforms are disabled! */
8981 static image_transform
*const image_transform_first
= &PT
;
8984 transform_enable(const char *name
)
8986 /* Everything starts out enabled, so if we see an 'enable' disabled
8987 * everything else the first time round.
8989 static int all_disabled
= 0;
8991 image_transform
*list
= image_transform_first
;
8993 while (list
!= &image_transform_end
)
8995 if (strcmp(list
->name
, name
) == 0)
9000 else if (!all_disabled
)
9010 fprintf(stderr
, "pngvalid: --transform-enable=%s: unknown transform\n",
9017 transform_disable(const char *name
)
9019 image_transform
*list
= image_transform_first
;
9021 while (list
!= &image_transform_end
)
9023 if (strcmp(list
->name
, name
) == 0)
9032 fprintf(stderr
, "pngvalid: --transform-disable=%s: unknown transform\n",
9038 image_transform_reset_count(void)
9040 image_transform
*next
= image_transform_first
;
9043 while (next
!= &image_transform_end
)
9045 next
->local_use
= 0;
9051 /* This can only happen if we every have more than 32 transforms (excluding
9052 * the end) in the list.
9054 if (count
> 32) abort();
9058 image_transform_test_counter(png_uint_32 counter
, unsigned int max
)
9060 /* Test the list to see if there is any point contining, given a current
9061 * counter and a 'max' value.
9063 image_transform
*next
= image_transform_first
;
9065 while (next
!= &image_transform_end
)
9067 /* For max 0 or 1 continue until the counter overflows: */
9070 /* Continue if any entry hasn't reacked the max. */
9071 if (max
> 1 && next
->local_use
< max
)
9076 return max
<= 1 && counter
== 0;
9080 image_transform_add(const image_transform
**this, unsigned int max
,
9081 png_uint_32 counter
, char *name
, size_t sizeof_name
, size_t *pos
,
9082 png_byte colour_type
, png_byte bit_depth
)
9084 for (;;) /* until we manage to add something */
9087 image_transform
*list
;
9089 /* Find the next counter value, if the counter is zero this is the start
9090 * of the list. This routine always returns the current counter (not the
9091 * next) so it returns 0 at the end and expects 0 at the beginning.
9093 if (counter
== 0) /* first time */
9095 image_transform_reset_count();
9099 counter
= random_32();
9101 else /* advance the counter */
9105 case 0: ++counter
; break;
9106 case 1: counter
<<= 1; break;
9107 default: counter
= random_32(); break;
9111 /* Now add all these items, if possible */
9112 *this = &image_transform_end
;
9113 list
= image_transform_first
;
9116 /* Go through the whole list adding anything that the counter selects: */
9117 while (list
!= &image_transform_end
)
9119 if ((counter
& mask
) != 0 && list
->enable
&&
9120 (max
== 0 || list
->local_use
< max
))
9122 /* Candidate to add: */
9123 if (list
->add(list
, this, colour_type
, bit_depth
) || max
== 0)
9125 /* Added, so add to the name too. */
9126 *pos
= safecat(name
, sizeof_name
, *pos
, " +");
9127 *pos
= safecat(name
, sizeof_name
, *pos
, list
->name
);
9132 /* Not useful and max>0, so remove it from *this: */
9136 /* And, since we know it isn't useful, stop it being added again
9139 list
->local_use
= max
;
9147 /* Now if anything was added we have something to do. */
9148 if (*this != &image_transform_end
)
9151 /* Nothing added, but was there anything in there to add? */
9152 if (!image_transform_test_counter(counter
, max
))
9158 perform_transform_test(png_modifier
*pm
)
9160 png_byte colour_type
= 0;
9161 png_byte bit_depth
= 0;
9162 unsigned int palette_number
= 0;
9164 while (next_format(&colour_type
, &bit_depth
, &palette_number
, pm
->test_lbg
,
9167 png_uint_32 counter
= 0;
9171 base_pos
= safecat(name
, sizeof name
, 0, "transform:");
9175 size_t pos
= base_pos
;
9176 const image_transform
*list
= 0;
9178 /* 'max' is currently hardwired to '1'; this should be settable on the
9181 counter
= image_transform_add(&list
, 1/*max*/, counter
,
9182 name
, sizeof name
, &pos
, colour_type
, bit_depth
);
9187 /* The command line can change this to checking interlaced images. */
9191 transform_test(pm
, FILEID(colour_type
, bit_depth
, palette_number
,
9192 pm
->interlace_type
, 0, 0, 0), list
, name
);
9201 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
9203 /********************************* GAMMA TESTS ********************************/
9204 #ifdef PNG_READ_GAMMA_SUPPORTED
9205 /* Reader callbacks and implementations, where they differ from the standard
9208 typedef struct gamma_display
9210 standard_display
this;
9215 double screen_gamma
;
9216 double background_gamma
;
9219 int use_input_precision
;
9223 png_color_16 background_color
;
9225 /* Local variables */
9231 #define ALPHA_MODE_OFFSET 4
9234 gamma_display_init(gamma_display
*dp
, png_modifier
*pm
, png_uint_32 id
,
9235 double file_gamma
, double screen_gamma
, png_byte sbit
, int threshold_test
,
9236 int use_input_precision
, int scale16
, int expand16
,
9237 int do_background
, const png_color_16
*pointer_to_the_background_color
,
9238 double background_gamma
)
9240 /* Standard fields */
9241 standard_display_init(&dp
->this, &pm
->this, id
, do_read_interlace
,
9242 pm
->use_update_info
);
9244 /* Parameter fields */
9246 dp
->file_gamma
= file_gamma
;
9247 dp
->screen_gamma
= screen_gamma
;
9248 dp
->background_gamma
= background_gamma
;
9250 dp
->threshold_test
= threshold_test
;
9251 dp
->use_input_precision
= use_input_precision
;
9252 dp
->scale16
= scale16
;
9253 dp
->expand16
= expand16
;
9254 dp
->do_background
= do_background
;
9255 if (do_background
&& pointer_to_the_background_color
!= 0)
9256 dp
->background_color
= *pointer_to_the_background_color
;
9258 memset(&dp
->background_color
, 0, sizeof dp
->background_color
);
9260 /* Local variable fields */
9261 dp
->maxerrout
= dp
->maxerrpc
= dp
->maxerrabs
= 0;
9265 gamma_info_imp(gamma_display
*dp
, png_structp pp
, png_infop pi
)
9267 /* Reuse the standard stuff as appropriate. */
9268 standard_info_part1(&dp
->this, pp
, pi
);
9270 /* If requested strip 16 to 8 bits - this is handled automagically below
9271 * because the output bit depth is read from the library. Note that there
9272 * are interactions with sBIT but, internally, libpng makes sbit at most
9273 * PNG_MAX_GAMMA_8 prior to 1.7 when doing the following.
9276 # ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
9277 png_set_scale_16(pp
);
9279 /* The following works both in 1.5.4 and earlier versions: */
9280 # ifdef PNG_READ_16_TO_8_SUPPORTED
9281 png_set_strip_16(pp
);
9283 png_error(pp
, "scale16 (16 to 8 bit conversion) not supported");
9288 # ifdef PNG_READ_EXPAND_16_SUPPORTED
9289 png_set_expand_16(pp
);
9291 png_error(pp
, "expand16 (8 to 16 bit conversion) not supported");
9294 if (dp
->do_background
>= ALPHA_MODE_OFFSET
)
9296 # ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9298 /* This tests the alpha mode handling, if supported. */
9299 int mode
= dp
->do_background
- ALPHA_MODE_OFFSET
;
9301 /* The gamma value is the output gamma, and is in the standard,
9302 * non-inverted, representation. It provides a default for the PNG file
9303 * gamma, but since the file has a gAMA chunk this does not matter.
9305 const double sg
= dp
->screen_gamma
;
9306 # ifndef PNG_FLOATING_POINT_SUPPORTED
9307 png_fixed_point g
= fix(sg
);
9310 # ifdef PNG_FLOATING_POINT_SUPPORTED
9311 png_set_alpha_mode(pp
, mode
, sg
);
9313 png_set_alpha_mode_fixed(pp
, mode
, g
);
9316 /* However, for the standard Porter-Duff algorithm the output defaults
9317 * to be linear, so if the test requires non-linear output it must be
9320 if (mode
== PNG_ALPHA_STANDARD
&& sg
!= 1)
9322 # ifdef PNG_FLOATING_POINT_SUPPORTED
9323 png_set_gamma(pp
, sg
, dp
->file_gamma
);
9325 png_fixed_point f
= fix(dp
->file_gamma
);
9326 png_set_gamma_fixed(pp
, g
, f
);
9331 png_error(pp
, "alpha mode handling not supported");
9337 /* Set up gamma processing. */
9338 # ifdef PNG_FLOATING_POINT_SUPPORTED
9339 png_set_gamma(pp
, dp
->screen_gamma
, dp
->file_gamma
);
9342 png_fixed_point s
= fix(dp
->screen_gamma
);
9343 png_fixed_point f
= fix(dp
->file_gamma
);
9344 png_set_gamma_fixed(pp
, s
, f
);
9348 if (dp
->do_background
)
9350 # ifdef PNG_READ_BACKGROUND_SUPPORTED
9351 /* NOTE: this assumes the caller provided the correct background gamma!
9353 const double bg
= dp
->background_gamma
;
9354 # ifndef PNG_FLOATING_POINT_SUPPORTED
9355 png_fixed_point g
= fix(bg
);
9358 # ifdef PNG_FLOATING_POINT_SUPPORTED
9359 png_set_background(pp
, &dp
->background_color
, dp
->do_background
,
9360 0/*need_expand*/, bg
);
9362 png_set_background_fixed(pp
, &dp
->background_color
,
9363 dp
->do_background
, 0/*need_expand*/, g
);
9366 png_error(pp
, "png_set_background not supported");
9372 int i
= dp
->this.use_update_info
;
9373 /* Always do one call, even if use_update_info is 0. */
9375 png_read_update_info(pp
, pi
);
9379 /* Now we may get a different cbRow: */
9380 standard_info_part2(&dp
->this, pp
, pi
, 1 /*images*/);
9383 static void PNGCBAPI
9384 gamma_info(png_structp pp
, png_infop pi
)
9386 gamma_info_imp(voidcast(gamma_display
*, png_get_progressive_ptr(pp
)), pp
,
9390 /* Validate a single component value - the routine gets the input and output
9391 * sample values as unscaled PNG component values along with a cache of all the
9392 * information required to validate the values.
9394 typedef struct validate_info
9396 png_const_structp pp
;
9399 int use_input_precision
;
9402 unsigned int sbit_max
;
9403 unsigned int isbit_shift
;
9404 unsigned int outmax
;
9406 double gamma_correction
; /* Overall correction required. */
9407 double file_inverse
; /* Inverse of file gamma. */
9408 double screen_gamma
;
9409 double screen_inverse
; /* Inverse of screen gamma. */
9411 double background_red
; /* Linear background value, red or gray. */
9412 double background_green
;
9413 double background_blue
;
9419 double maxout_total
; /* Total including quantization error */
9426 init_validate_info(validate_info
*vi
, gamma_display
*dp
, png_const_structp pp
,
9427 int in_depth
, int out_depth
)
9429 unsigned int outmax
= (1U<<out_depth
)-1;
9434 if (dp
->sbit
> 0 && dp
->sbit
< in_depth
)
9436 vi
->sbit
= dp
->sbit
;
9437 vi
->isbit_shift
= in_depth
- dp
->sbit
;
9442 vi
->sbit
= (png_byte
)in_depth
;
9443 vi
->isbit_shift
= 0;
9446 vi
->sbit_max
= (1U << vi
->sbit
)-1;
9448 /* This mimics the libpng threshold test, '0' is used to prevent gamma
9449 * correction in the validation test.
9451 vi
->screen_gamma
= dp
->screen_gamma
;
9452 if (fabs(vi
->screen_gamma
-1) < PNG_GAMMA_THRESHOLD
)
9453 vi
->screen_gamma
= vi
->screen_inverse
= 0;
9455 vi
->screen_inverse
= 1/vi
->screen_gamma
;
9457 vi
->use_input_precision
= dp
->use_input_precision
;
9458 vi
->outmax
= outmax
;
9459 vi
->maxabs
= abserr(dp
->pm
, in_depth
, out_depth
);
9460 vi
->maxpc
= pcerr(dp
->pm
, in_depth
, out_depth
);
9461 vi
->maxcalc
= calcerr(dp
->pm
, in_depth
, out_depth
);
9462 vi
->maxout
= outerr(dp
->pm
, in_depth
, out_depth
);
9463 vi
->outquant
= output_quantization_factor(dp
->pm
, in_depth
, out_depth
);
9464 vi
->maxout_total
= vi
->maxout
+ vi
->outquant
* .5;
9465 vi
->outlog
= outlog(dp
->pm
, in_depth
, out_depth
);
9467 if ((dp
->this.colour_type
& PNG_COLOR_MASK_ALPHA
) != 0 ||
9468 (dp
->this.colour_type
== 3 && dp
->this.is_transparent
) ||
9469 ((dp
->this.colour_type
== 0 || dp
->this.colour_type
== 2) &&
9472 vi
->do_background
= dp
->do_background
;
9474 if (vi
->do_background
!= 0)
9476 const double bg_inverse
= 1/dp
->background_gamma
;
9479 /* Caller must at least put the gray value into the red channel */
9480 r
= dp
->background_color
.red
; r
/= outmax
;
9481 g
= dp
->background_color
.green
; g
/= outmax
;
9482 b
= dp
->background_color
.blue
; b
/= outmax
;
9485 /* libpng doesn't do this optimization, if we do pngvalid will fail.
9487 if (fabs(bg_inverse
-1) >= PNG_GAMMA_THRESHOLD
)
9490 r
= pow(r
, bg_inverse
);
9491 g
= pow(g
, bg_inverse
);
9492 b
= pow(b
, bg_inverse
);
9495 vi
->background_red
= r
;
9496 vi
->background_green
= g
;
9497 vi
->background_blue
= b
;
9500 else /* Do not expect any background processing */
9501 vi
->do_background
= 0;
9503 if (vi
->do_background
== 0)
9504 vi
->background_red
= vi
->background_green
= vi
->background_blue
= 0;
9506 vi
->gamma_correction
= 1/(dp
->file_gamma
*dp
->screen_gamma
);
9507 if (fabs(vi
->gamma_correction
-1) < PNG_GAMMA_THRESHOLD
)
9508 vi
->gamma_correction
= 0;
9510 vi
->file_inverse
= 1/dp
->file_gamma
;
9511 if (fabs(vi
->file_inverse
-1) < PNG_GAMMA_THRESHOLD
)
9512 vi
->file_inverse
= 0;
9514 vi
->scale16
= dp
->scale16
;
9517 /* This function handles composition of a single non-alpha component. The
9518 * argument is the input sample value, in the range 0..1, and the alpha value.
9519 * The result is the composed, linear, input sample. If alpha is less than zero
9520 * this is the alpha component and the function should not be called!
9523 gamma_component_compose(int do_background
, double input_sample
, double alpha
,
9524 double background
, int *compose
)
9526 switch (do_background
)
9528 #ifdef PNG_READ_BACKGROUND_SUPPORTED
9529 case PNG_BACKGROUND_GAMMA_SCREEN
:
9530 case PNG_BACKGROUND_GAMMA_FILE
:
9531 case PNG_BACKGROUND_GAMMA_UNIQUE
:
9532 /* Standard PNG background processing. */
9537 input_sample
= input_sample
* alpha
+ background
* (1-alpha
);
9538 if (compose
!= NULL
)
9543 input_sample
= background
;
9548 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9549 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_STANDARD
:
9550 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_BROKEN
:
9551 /* The components are premultiplied in either case and the output is
9552 * gamma encoded (to get standard Porter-Duff we expect the output
9553 * gamma to be set to 1.0!)
9555 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_OPTIMIZED
:
9556 /* The optimization is that the partial-alpha entries are linear
9557 * while the opaque pixels are gamma encoded, but this only affects the
9564 input_sample
*= alpha
;
9565 if (compose
!= NULL
)
9576 /* Standard cases where no compositing is done (so the component
9577 * value is already correct.)
9585 return input_sample
;
9588 /* This API returns the encoded *input* component, in the range 0..1 */
9590 gamma_component_validate(const char *name
, const validate_info
*vi
,
9591 unsigned int id
, unsigned int od
,
9592 const double alpha
/* <0 for the alpha channel itself */,
9593 const double background
/* component background value */)
9595 unsigned int isbit
= id
>> vi
->isbit_shift
;
9596 unsigned int sbit_max
= vi
->sbit_max
;
9597 unsigned int outmax
= vi
->outmax
;
9598 int do_background
= vi
->do_background
;
9602 /* First check on the 'perfect' result obtained from the digitized input
9603 * value, id, and compare this against the actual digitized result, 'od'.
9604 * 'i' is the input result in the range 0..1:
9606 i
= isbit
; i
/= sbit_max
;
9608 /* Check for the fast route: if we don't do any background composition or if
9609 * this is the alpha channel ('alpha' < 0) or if the pixel is opaque then
9610 * just use the gamma_correction field to correct to the final output gamma.
9612 if (alpha
== 1 /* opaque pixel component */ || !do_background
9613 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9614 || do_background
== ALPHA_MODE_OFFSET
+ PNG_ALPHA_PNG
9616 || (alpha
< 0 /* alpha channel */
9617 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9618 && do_background
!= ALPHA_MODE_OFFSET
+ PNG_ALPHA_BROKEN
9622 /* Then get the gamma corrected version of 'i' and compare to 'od', any
9623 * error less than .5 is insignificant - just quantization of the output
9624 * value to the nearest digital value (nevertheless the error is still
9625 * recorded - it's interesting ;-)
9627 double encoded_sample
= i
;
9628 double encoded_error
;
9630 /* alpha less than 0 indicates the alpha channel, which is always linear
9632 if (alpha
>= 0 && vi
->gamma_correction
> 0)
9633 encoded_sample
= pow(encoded_sample
, vi
->gamma_correction
);
9634 encoded_sample
*= outmax
;
9636 encoded_error
= fabs(od
-encoded_sample
);
9638 if (encoded_error
> vi
->dp
->maxerrout
)
9639 vi
->dp
->maxerrout
= encoded_error
;
9641 if (encoded_error
< vi
->maxout_total
&& encoded_error
< vi
->outlog
)
9645 /* The slow route - attempt to do linear calculations. */
9646 /* There may be an error, or background processing is required, so calculate
9647 * the actual sample values - unencoded light intensity values. Note that in
9648 * practice these are not completely unencoded because they include a
9649 * 'viewing correction' to decrease or (normally) increase the perceptual
9650 * contrast of the image. There's nothing we can do about this - we don't
9651 * know what it is - so assume the unencoded value is perceptually linear.
9654 double input_sample
= i
; /* In range 0..1 */
9655 double output
, error
, encoded_sample
, encoded_error
;
9656 double es_lo
, es_hi
;
9657 int compose
= 0; /* Set to one if composition done */
9658 int output_is_encoded
; /* Set if encoded to screen gamma */
9659 int log_max_error
= 1; /* Check maximum error values */
9660 png_const_charp pass
= 0; /* Reason test passes (or 0 for fail) */
9662 /* Convert to linear light (with the above caveat.) The alpha channel is
9669 if (vi
->file_inverse
> 0)
9670 input_sample
= pow(input_sample
, vi
->file_inverse
);
9672 /* Handle the compose processing: */
9674 input_sample
= gamma_component_compose(do_background
, input_sample
,
9675 alpha
, background
, &tcompose
);
9681 /* And similarly for the output value, but we need to check the background
9682 * handling to linearize it correctly.
9687 output_is_encoded
= vi
->screen_gamma
> 0;
9689 if (alpha
< 0) /* The alpha channel */
9691 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9692 if (do_background
!= ALPHA_MODE_OFFSET
+ PNG_ALPHA_BROKEN
)
9695 /* In all other cases the output alpha channel is linear already,
9696 * don't log errors here, they are much larger in linear data.
9698 output_is_encoded
= 0;
9703 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
9704 else /* A component */
9706 if (do_background
== ALPHA_MODE_OFFSET
+ PNG_ALPHA_OPTIMIZED
&&
9707 alpha
< 1) /* the optimized case - linear output */
9709 if (alpha
> 0) log_max_error
= 0;
9710 output_is_encoded
= 0;
9715 if (output_is_encoded
)
9716 output
= pow(output
, vi
->screen_gamma
);
9718 /* Calculate (or recalculate) the encoded_sample value and repeat the
9719 * check above (unnecessary if we took the fast route, but harmless.)
9721 encoded_sample
= input_sample
;
9722 if (output_is_encoded
)
9723 encoded_sample
= pow(encoded_sample
, vi
->screen_inverse
);
9724 encoded_sample
*= outmax
;
9726 encoded_error
= fabs(od
-encoded_sample
);
9728 /* Don't log errors in the alpha channel, or the 'optimized' case,
9729 * neither are significant to the overall perception.
9731 if (log_max_error
&& encoded_error
> vi
->dp
->maxerrout
)
9732 vi
->dp
->maxerrout
= encoded_error
;
9734 if (encoded_error
< vi
->maxout_total
)
9736 if (encoded_error
< vi
->outlog
)
9739 /* Test passed but error is bigger than the log limit, record why the
9742 pass
= "less than maxout:\n";
9745 /* i: the original input value in the range 0..1
9747 * pngvalid calculations:
9748 * input_sample: linear result; i linearized and composed, range 0..1
9749 * encoded_sample: encoded result; input_sample scaled to output bit depth
9751 * libpng calculations:
9752 * output: linear result; od scaled to 0..1 and linearized
9753 * od: encoded result from libpng
9756 /* Now we have the numbers for real errors, both absolute values as as a
9757 * percentage of the correct value (output):
9759 error
= fabs(input_sample
-output
);
9761 if (log_max_error
&& error
> vi
->dp
->maxerrabs
)
9762 vi
->dp
->maxerrabs
= error
;
9764 /* The following is an attempt to ignore the tendency of quantization to
9765 * dominate the percentage errors for lower result values:
9767 if (log_max_error
&& input_sample
> .5)
9769 double percentage_error
= error
/input_sample
;
9770 if (percentage_error
> vi
->dp
->maxerrpc
)
9771 vi
->dp
->maxerrpc
= percentage_error
;
9774 /* Now calculate the digitization limits for 'encoded_sample' using the
9775 * 'max' values. Note that maxout is in the encoded space but maxpc and
9776 * maxabs are in linear light space.
9778 * First find the maximum error in linear light space, range 0..1:
9781 double tmp
= input_sample
* vi
->maxpc
;
9782 if (tmp
< vi
->maxabs
) tmp
= vi
->maxabs
;
9783 /* If 'compose' is true the composition was done in linear space using
9784 * integer arithmetic. This introduces an extra error of +/- 0.5 (at
9785 * least) in the integer space used. 'maxcalc' records this, taking
9786 * into account the possibility that even for 16 bit output 8 bit space
9787 * may have been used.
9789 if (compose
&& tmp
< vi
->maxcalc
) tmp
= vi
->maxcalc
;
9791 /* The 'maxout' value refers to the encoded result, to compare with
9792 * this encode input_sample adjusted by the maximum error (tmp) above.
9794 es_lo
= encoded_sample
- vi
->maxout
;
9796 if (es_lo
> 0 && input_sample
-tmp
> 0)
9798 double low_value
= input_sample
-tmp
;
9799 if (output_is_encoded
)
9800 low_value
= pow(low_value
, vi
->screen_inverse
);
9801 low_value
*= outmax
;
9802 if (low_value
< es_lo
) es_lo
= low_value
;
9804 /* Quantize this appropriately: */
9805 es_lo
= ceil(es_lo
/ vi
->outquant
- .5) * vi
->outquant
;
9811 es_hi
= encoded_sample
+ vi
->maxout
;
9813 if (es_hi
< outmax
&& input_sample
+tmp
< 1)
9815 double high_value
= input_sample
+tmp
;
9816 if (output_is_encoded
)
9817 high_value
= pow(high_value
, vi
->screen_inverse
);
9818 high_value
*= outmax
;
9819 if (high_value
> es_hi
) es_hi
= high_value
;
9821 es_hi
= floor(es_hi
/ vi
->outquant
+ .5) * vi
->outquant
;
9828 /* The primary test is that the final encoded value returned by the
9829 * library should be between the two limits (inclusive) that were
9832 if (od
>= es_lo
&& od
<= es_hi
)
9834 /* The value passes, but we may need to log the information anyway. */
9835 if (encoded_error
< vi
->outlog
)
9839 pass
= "within digitization limits:\n";
9843 /* There has been an error in processing, or we need to log this
9846 double is_lo
, is_hi
;
9848 /* pass is set at this point if either of the tests above would have
9849 * passed. Don't do these additional tests here - just log the
9850 * original [es_lo..es_hi] values.
9852 if (pass
== 0 && vi
->use_input_precision
&& vi
->dp
->sbit
)
9854 /* Ok, something is wrong - this actually happens in current libpng
9855 * 16-to-8 processing. Assume that the input value (id, adjusted
9856 * for sbit) can be anywhere between value-.5 and value+.5 - quite a
9857 * large range if sbit is low.
9859 * NOTE: at present because the libpng gamma table stuff has been
9860 * changed to use a rounding algorithm to correct errors in 8-bit
9861 * calculations the precise sbit calculation (a shift) has been
9862 * lost. This can result in up to a +/-1 error in the presence of
9863 * an sbit less than the bit depth.
9865 # if PNG_LIBPNG_VER < 10700
9866 # define SBIT_ERROR .5
9868 # define SBIT_ERROR 1.
9870 double tmp
= (isbit
- SBIT_ERROR
)/sbit_max
;
9875 else if (alpha
>= 0 && vi
->file_inverse
> 0 && tmp
< 1)
9876 tmp
= pow(tmp
, vi
->file_inverse
);
9878 tmp
= gamma_component_compose(do_background
, tmp
, alpha
, background
,
9881 if (output_is_encoded
&& tmp
> 0 && tmp
< 1)
9882 tmp
= pow(tmp
, vi
->screen_inverse
);
9884 is_lo
= ceil(outmax
* tmp
- vi
->maxout_total
);
9889 tmp
= (isbit
+ SBIT_ERROR
)/sbit_max
;
9894 else if (alpha
>= 0 && vi
->file_inverse
> 0 && tmp
< 1)
9895 tmp
= pow(tmp
, vi
->file_inverse
);
9897 tmp
= gamma_component_compose(do_background
, tmp
, alpha
, background
,
9900 if (output_is_encoded
&& tmp
> 0 && tmp
< 1)
9901 tmp
= pow(tmp
, vi
->screen_inverse
);
9903 is_hi
= floor(outmax
* tmp
+ vi
->maxout_total
);
9908 if (!(od
< is_lo
|| od
> is_hi
))
9910 if (encoded_error
< vi
->outlog
)
9913 pass
= "within input precision limits:\n";
9916 /* One last chance. If this is an alpha channel and the 16to8
9917 * option has been used and 'inaccurate' scaling is used then the
9918 * bit reduction is obtained by simply using the top 8 bits of the
9921 * This is only done for older libpng versions when the 'inaccurate'
9922 * (chop) method of scaling was used.
9924 # ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
9925 # if PNG_LIBPNG_VER < 10504
9926 /* This may be required for other components in the future,
9927 * but at present the presence of gamma correction effectively
9928 * prevents the errors in the component scaling (I don't quite
9929 * understand why, but since it's better this way I care not
9930 * to ask, JB 20110419.)
9932 if (pass
== 0 && alpha
< 0 && vi
->scale16
&& vi
->sbit
> 8 &&
9933 vi
->sbit
+ vi
->isbit_shift
== 16)
9935 tmp
= ((id
>> 8) - .5)/255;
9939 is_lo
= ceil(outmax
* tmp
- vi
->maxout_total
);
9940 if (is_lo
< 0) is_lo
= 0;
9946 tmp
= ((id
>> 8) + .5)/255;
9950 is_hi
= floor(outmax
* tmp
+ vi
->maxout_total
);
9951 if (is_hi
> outmax
) is_hi
= outmax
;
9957 if (!(od
< is_lo
|| od
> is_hi
))
9959 if (encoded_error
< vi
->outlog
)
9962 pass
= "within 8 bit limits:\n";
9968 else /* !use_input_precision */
9969 is_lo
= es_lo
, is_hi
= es_hi
;
9971 /* Attempt to output a meaningful error/warning message: the message
9972 * output depends on the background/composite operation being performed
9973 * because this changes what parameters were actually used above.
9977 /* Need either 1/255 or 1/65535 precision here; 3 or 6 decimal
9978 * places. Just use outmax to work out which.
9980 int precision
= (outmax
>= 1000 ? 6 : 3);
9981 int use_input
=1, use_background
=0, do_compose
=0;
9985 pos
= safecat(msg
, sizeof msg
, pos
, "\n\t");
9987 /* Set up the various flags, the output_is_encoded flag above
9988 * is also used below. do_compose is just a double check.
9990 switch (do_background
)
9992 # ifdef PNG_READ_BACKGROUND_SUPPORTED
9993 case PNG_BACKGROUND_GAMMA_SCREEN
:
9994 case PNG_BACKGROUND_GAMMA_FILE
:
9995 case PNG_BACKGROUND_GAMMA_UNIQUE
:
9996 use_background
= (alpha
>= 0 && alpha
< 1);
9998 # ifdef PNG_READ_ALPHA_MODE_SUPPORTED
10000 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_STANDARD
:
10001 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_BROKEN
:
10002 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_OPTIMIZED
:
10003 # endif /* ALPHA_MODE_SUPPORTED */
10004 do_compose
= (alpha
> 0 && alpha
< 1);
10005 use_input
= (alpha
!= 0);
10012 /* Check the 'compose' flag */
10013 if (compose
!= do_compose
)
10014 png_error(vi
->pp
, "internal error (compose)");
10016 /* 'name' is the component name */
10017 pos
= safecat(msg
, sizeof msg
, pos
, name
);
10018 pos
= safecat(msg
, sizeof msg
, pos
, "(");
10019 pos
= safecatn(msg
, sizeof msg
, pos
, id
);
10020 if (use_input
|| pass
!= 0/*logging*/)
10024 /* sBIT has reduced the precision of the input: */
10025 pos
= safecat(msg
, sizeof msg
, pos
, ", sbit(");
10026 pos
= safecatn(msg
, sizeof msg
, pos
, vi
->sbit
);
10027 pos
= safecat(msg
, sizeof msg
, pos
, "): ");
10028 pos
= safecatn(msg
, sizeof msg
, pos
, isbit
);
10030 pos
= safecat(msg
, sizeof msg
, pos
, "/");
10031 /* The output is either "id/max" or "id sbit(sbit): isbit/max" */
10032 pos
= safecatn(msg
, sizeof msg
, pos
, vi
->sbit_max
);
10034 pos
= safecat(msg
, sizeof msg
, pos
, ")");
10036 /* A component may have been multiplied (in linear space) by the
10037 * alpha value, 'compose' says whether this is relevant.
10039 if (compose
|| pass
!= 0)
10041 /* If any form of composition is being done report our
10042 * calculated linear value here (the code above doesn't record
10043 * the input value before composition is performed, so what
10044 * gets reported is the value after composition.)
10046 if (use_input
|| pass
!= 0)
10048 if (vi
->file_inverse
> 0)
10050 pos
= safecat(msg
, sizeof msg
, pos
, "^");
10051 pos
= safecatd(msg
, sizeof msg
, pos
, vi
->file_inverse
, 2);
10055 pos
= safecat(msg
, sizeof msg
, pos
, "[linear]");
10057 pos
= safecat(msg
, sizeof msg
, pos
, "*(alpha)");
10058 pos
= safecatd(msg
, sizeof msg
, pos
, alpha
, precision
);
10061 /* Now record the *linear* background value if it was used
10062 * (this function is not passed the original, non-linear,
10063 * value but it is contained in the test name.)
10065 if (use_background
)
10067 pos
= safecat(msg
, sizeof msg
, pos
, use_input
? "+" : " ");
10068 pos
= safecat(msg
, sizeof msg
, pos
, "(background)");
10069 pos
= safecatd(msg
, sizeof msg
, pos
, background
, precision
);
10070 pos
= safecat(msg
, sizeof msg
, pos
, "*");
10071 pos
= safecatd(msg
, sizeof msg
, pos
, 1-alpha
, precision
);
10075 /* Report the calculated value (input_sample) and the linearized
10076 * libpng value (output) unless this is just a component gamma
10079 if (compose
|| alpha
< 0 || pass
!= 0)
10081 pos
= safecat(msg
, sizeof msg
, pos
,
10082 pass
!= 0 ? " =\n\t" : " = ");
10083 pos
= safecatd(msg
, sizeof msg
, pos
, input_sample
, precision
);
10084 pos
= safecat(msg
, sizeof msg
, pos
, " (libpng: ");
10085 pos
= safecatd(msg
, sizeof msg
, pos
, output
, precision
);
10086 pos
= safecat(msg
, sizeof msg
, pos
, ")");
10088 /* Finally report the output gamma encoding, if any. */
10089 if (output_is_encoded
)
10091 pos
= safecat(msg
, sizeof msg
, pos
, " ^");
10092 pos
= safecatd(msg
, sizeof msg
, pos
, vi
->screen_inverse
, 2);
10093 pos
= safecat(msg
, sizeof msg
, pos
, "(to screen) =");
10097 pos
= safecat(msg
, sizeof msg
, pos
, " [screen is linear] =");
10100 if ((!compose
&& alpha
>= 0) || pass
!= 0)
10102 if (pass
!= 0) /* logging */
10103 pos
= safecat(msg
, sizeof msg
, pos
, "\n\t[overall:");
10105 /* This is the non-composition case, the internal linear
10106 * values are irrelevant (though the log below will reveal
10107 * them.) Output a much shorter warning/error message and report
10108 * the overall gamma correction.
10110 if (vi
->gamma_correction
> 0)
10112 pos
= safecat(msg
, sizeof msg
, pos
, " ^");
10113 pos
= safecatd(msg
, sizeof msg
, pos
, vi
->gamma_correction
, 2);
10114 pos
= safecat(msg
, sizeof msg
, pos
, "(gamma correction) =");
10118 pos
= safecat(msg
, sizeof msg
, pos
,
10119 " [no gamma correction] =");
10122 pos
= safecat(msg
, sizeof msg
, pos
, "]");
10125 /* This is our calculated encoded_sample which should (but does
10128 pos
= safecat(msg
, sizeof msg
, pos
, pass
!= 0 ? "\n\t" : " ");
10129 pos
= safecatd(msg
, sizeof msg
, pos
, is_lo
, 1);
10130 pos
= safecat(msg
, sizeof msg
, pos
, " < ");
10131 pos
= safecatd(msg
, sizeof msg
, pos
, encoded_sample
, 1);
10132 pos
= safecat(msg
, sizeof msg
, pos
, " (libpng: ");
10133 pos
= safecatn(msg
, sizeof msg
, pos
, od
);
10134 pos
= safecat(msg
, sizeof msg
, pos
, ")");
10135 pos
= safecat(msg
, sizeof msg
, pos
, "/");
10136 pos
= safecatn(msg
, sizeof msg
, pos
, outmax
);
10137 pos
= safecat(msg
, sizeof msg
, pos
, " < ");
10138 pos
= safecatd(msg
, sizeof msg
, pos
, is_hi
, 1);
10140 if (pass
== 0) /* The error condition */
10142 # ifdef PNG_WARNINGS_SUPPORTED
10143 png_warning(vi
->pp
, msg
);
10145 store_warning(vi
->pp
, msg
);
10149 else /* logging this value */
10150 store_verbose(&vi
->dp
->pm
->this, vi
->pp
, pass
, msg
);
10159 gamma_image_validate(gamma_display
*dp
, png_const_structp pp
,
10162 /* Get some constants derived from the input and output file formats: */
10163 const png_store
* const ps
= dp
->this.ps
;
10164 png_byte in_ct
= dp
->this.colour_type
;
10165 png_byte in_bd
= dp
->this.bit_depth
;
10166 png_uint_32 w
= dp
->this.w
;
10167 png_uint_32 h
= dp
->this.h
;
10168 const size_t cbRow
= dp
->this.cbRow
;
10169 png_byte out_ct
= png_get_color_type(pp
, pi
);
10170 png_byte out_bd
= png_get_bit_depth(pp
, pi
);
10172 /* There are three sources of error, firstly the quantization in the
10173 * file encoding, determined by sbit and/or the file depth, secondly
10174 * the output (screen) gamma and thirdly the output file encoding.
10176 * Since this API receives the screen and file gamma in double
10177 * precision it is possible to calculate an exact answer given an input
10178 * pixel value. Therefore we assume that the *input* value is exact -
10179 * sample/maxsample - calculate the corresponding gamma corrected
10180 * output to the limits of double precision arithmetic and compare with
10181 * what libpng returns.
10183 * Since the library must quantize the output to 8 or 16 bits there is
10184 * a fundamental limit on the accuracy of the output of +/-.5 - this
10185 * quantization limit is included in addition to the other limits
10186 * specified by the parameters to the API. (Effectively, add .5
10189 * The behavior of the 'sbit' parameter is defined by section 12.5
10190 * (sample depth scaling) of the PNG spec. That section forces the
10191 * decoder to assume that the PNG values have been scaled if sBIT is
10194 * png-sample = floor( input-sample * (max-out/max-in) + .5);
10196 * This means that only a subset of the possible PNG values should
10197 * appear in the input. However, the spec allows the encoder to use a
10198 * variety of approximations to the above and doesn't require any
10199 * restriction of the values produced.
10201 * Nevertheless the spec requires that the upper 'sBIT' bits of the
10202 * value stored in a PNG file be the original sample bits.
10203 * Consequently the code below simply scales the top sbit bits by
10204 * (1<<sbit)-1 to obtain an original sample value.
10206 * Because there is limited precision in the input it is arguable that
10207 * an acceptable result is any valid result from input-.5 to input+.5.
10208 * The basic tests below do not do this, however if 'use_input_precision'
10209 * is set a subsequent test is performed above.
10211 unsigned int samples_per_pixel
= (out_ct
& 2U) ? 3U : 1U;
10214 const store_palette_entry
*in_palette
= dp
->this.palette
;
10215 int in_is_transparent
= dp
->this.is_transparent
;
10217 int out_npalette
= -1;
10218 int out_is_transparent
= 0; /* Just refers to the palette case */
10219 store_palette out_palette
;
10222 /* Check for row overwrite errors */
10223 store_image_check(dp
->this.ps
, pp
, 0);
10225 /* Supply the input and output sample depths here - 8 for an indexed image,
10226 * otherwise the bit depth.
10228 init_validate_info(&vi
, dp
, pp
, in_ct
==3?8:in_bd
, out_ct
==3?8:out_bd
);
10230 processing
= (vi
.gamma_correction
> 0 && !dp
->threshold_test
)
10231 || in_bd
!= out_bd
|| in_ct
!= out_ct
|| vi
.do_background
;
10232 process_tRNS
= dp
->this.has_tRNS
&& vi
.do_background
;
10234 /* TODO: FIX THIS: MAJOR BUG! If the transformations all happen inside
10235 * the palette there is no way of finding out, because libpng fails to
10236 * update the palette on png_read_update_info. Indeed, libpng doesn't
10237 * even do the required work until much later, when it doesn't have any
10238 * info pointer. Oops. For the moment 'processing' is turned off if
10239 * out_ct is palette.
10241 if (in_ct
== 3 && out_ct
== 3)
10244 if (processing
&& out_ct
== 3)
10245 out_is_transparent
= read_palette(out_palette
, &out_npalette
, pp
, pi
);
10247 for (y
=0; y
<h
; ++y
)
10249 png_const_bytep pRow
= store_image_row(ps
, pp
, 0, y
);
10250 png_byte std
[STANDARD_ROWMAX
];
10252 transform_row(pp
, std
, in_ct
, in_bd
, y
);
10258 for (x
=0; x
<w
; ++x
)
10260 double alpha
= 1; /* serves as a flag value */
10262 /* Record the palette index for index images. */
10263 unsigned int in_index
=
10264 in_ct
== 3 ? sample(std
, 3, in_bd
, x
, 0, 0, 0) : 256;
10265 unsigned int out_index
=
10266 out_ct
== 3 ? sample(std
, 3, out_bd
, x
, 0, 0, 0) : 256;
10268 /* Handle input alpha - png_set_background will cause the output
10269 * alpha to disappear so there is nothing to check.
10271 if ((in_ct
& PNG_COLOR_MASK_ALPHA
) != 0 ||
10272 (in_ct
== 3 && in_is_transparent
))
10274 unsigned int input_alpha
= in_ct
== 3 ?
10275 dp
->this.palette
[in_index
].alpha
:
10276 sample(std
, in_ct
, in_bd
, x
, samples_per_pixel
, 0, 0);
10278 unsigned int output_alpha
= 65536 /* as a flag value */;
10282 if (out_is_transparent
)
10283 output_alpha
= out_palette
[out_index
].alpha
;
10286 else if ((out_ct
& PNG_COLOR_MASK_ALPHA
) != 0)
10287 output_alpha
= sample(pRow
, out_ct
, out_bd
, x
,
10288 samples_per_pixel
, 0, 0);
10290 if (output_alpha
!= 65536)
10291 alpha
= gamma_component_validate("alpha", &vi
, input_alpha
,
10292 output_alpha
, -1/*alpha*/, 0/*background*/);
10294 else /* no alpha in output */
10296 /* This is a copy of the calculation of 'i' above in order to
10297 * have the alpha value to use in the background calculation.
10299 alpha
= input_alpha
>> vi
.isbit_shift
;
10300 alpha
/= vi
.sbit_max
;
10304 else if (process_tRNS
)
10306 /* alpha needs to be set appropriately for this pixel, it is
10307 * currently 1 and needs to be 0 for an input pixel which matches
10308 * the values in tRNS.
10313 if (sample(std
, in_ct
, in_bd
, x
, 0, 0, 0) ==
10314 dp
->this.transparent
.red
)
10319 if (sample(std
, in_ct
, in_bd
, x
, 0, 0, 0) ==
10320 dp
->this.transparent
.red
&&
10321 sample(std
, in_ct
, in_bd
, x
, 1, 0, 0) ==
10322 dp
->this.transparent
.green
&&
10323 sample(std
, in_ct
, in_bd
, x
, 2, 0, 0) ==
10324 dp
->this.transparent
.blue
)
10333 /* Handle grayscale or RGB components. */
10334 if ((in_ct
& PNG_COLOR_MASK_COLOR
) == 0) /* grayscale */
10335 (void)gamma_component_validate("gray", &vi
,
10336 sample(std
, in_ct
, in_bd
, x
, 0, 0, 0),
10337 sample(pRow
, out_ct
, out_bd
, x
, 0, 0, 0),
10338 alpha
/*component*/, vi
.background_red
);
10339 else /* RGB or palette */
10341 (void)gamma_component_validate("red", &vi
,
10342 in_ct
== 3 ? in_palette
[in_index
].red
:
10343 sample(std
, in_ct
, in_bd
, x
, 0, 0, 0),
10344 out_ct
== 3 ? out_palette
[out_index
].red
:
10345 sample(pRow
, out_ct
, out_bd
, x
, 0, 0, 0),
10346 alpha
/*component*/, vi
.background_red
);
10348 (void)gamma_component_validate("green", &vi
,
10349 in_ct
== 3 ? in_palette
[in_index
].green
:
10350 sample(std
, in_ct
, in_bd
, x
, 1, 0, 0),
10351 out_ct
== 3 ? out_palette
[out_index
].green
:
10352 sample(pRow
, out_ct
, out_bd
, x
, 1, 0, 0),
10353 alpha
/*component*/, vi
.background_green
);
10355 (void)gamma_component_validate("blue", &vi
,
10356 in_ct
== 3 ? in_palette
[in_index
].blue
:
10357 sample(std
, in_ct
, in_bd
, x
, 2, 0, 0),
10358 out_ct
== 3 ? out_palette
[out_index
].blue
:
10359 sample(pRow
, out_ct
, out_bd
, x
, 2, 0, 0),
10360 alpha
/*component*/, vi
.background_blue
);
10365 else if (memcmp(std
, pRow
, cbRow
) != 0)
10369 /* No transform is expected on the threshold tests. */
10370 sprintf(msg
, "gamma: below threshold row %lu changed",
10373 png_error(pp
, msg
);
10375 } /* row (y) loop */
10377 dp
->this.ps
->validated
= 1;
10380 static void PNGCBAPI
10381 gamma_end(png_structp ppIn
, png_infop pi
)
10383 png_const_structp pp
= ppIn
;
10384 gamma_display
*dp
= voidcast(gamma_display
*, png_get_progressive_ptr(pp
));
10386 if (!dp
->this.speed
)
10387 gamma_image_validate(dp
, pp
, pi
);
10389 dp
->this.ps
->validated
= 1;
10392 /* A single test run checking a gamma transformation.
10394 * maxabs: maximum absolute error as a fraction
10395 * maxout: maximum output error in the output units
10396 * maxpc: maximum percentage error (as a percentage)
10399 gamma_test(png_modifier
*pmIn
, png_byte colour_typeIn
,
10400 png_byte bit_depthIn
, int palette_numberIn
,
10401 int interlace_typeIn
,
10402 const double file_gammaIn
, const double screen_gammaIn
,
10403 png_byte sbitIn
, int threshold_testIn
,
10405 int use_input_precisionIn
, int scale16In
,
10406 int expand16In
, int do_backgroundIn
,
10407 const png_color_16
*bkgd_colorIn
, double bkgd_gammaIn
)
10410 context(&pmIn
->this, fault
);
10412 gamma_display_init(&d
, pmIn
, FILEID(colour_typeIn
, bit_depthIn
,
10413 palette_numberIn
, interlace_typeIn
, 0, 0, 0),
10414 file_gammaIn
, screen_gammaIn
, sbitIn
,
10415 threshold_testIn
, use_input_precisionIn
, scale16In
,
10416 expand16In
, do_backgroundIn
, bkgd_colorIn
, bkgd_gammaIn
);
10422 gama_modification gama_mod
;
10423 srgb_modification srgb_mod
;
10424 sbit_modification sbit_mod
;
10426 /* For the moment don't use the png_modifier support here. */
10427 d
.pm
->encoding_counter
= 0;
10428 modifier_set_encoding(d
.pm
); /* Just resets everything */
10429 d
.pm
->current_gamma
= d
.file_gamma
;
10431 /* Make an appropriate modifier to set the PNG file gamma to the
10432 * given gamma value and the sBIT chunk to the given precision.
10434 d
.pm
->modifications
= NULL
;
10435 gama_modification_init(&gama_mod
, d
.pm
, d
.file_gamma
);
10436 srgb_modification_init(&srgb_mod
, d
.pm
, 127 /*delete*/);
10438 sbit_modification_init(&sbit_mod
, d
.pm
, d
.sbit
);
10440 modification_reset(d
.pm
->modifications
);
10442 /* Get a png_struct for reading the image. */
10443 pp
= set_modifier_for_read(d
.pm
, &pi
, d
.this.id
, name
);
10444 standard_palette_init(&d
.this);
10446 /* Introduce the correct read function. */
10447 if (d
.pm
->this.progressive
)
10449 /* Share the row function with the standard implementation. */
10450 png_set_progressive_read_fn(pp
, &d
, gamma_info
, progressive_row
,
10453 /* Now feed data into the reader until we reach the end: */
10454 modifier_progressive_read(d
.pm
, pp
, pi
);
10458 /* modifier_read expects a png_modifier* */
10459 png_set_read_fn(pp
, d
.pm
, modifier_read
);
10461 /* Check the header values: */
10462 png_read_info(pp
, pi
);
10464 /* Process the 'info' requirements. Only one image is generated */
10465 gamma_info_imp(&d
, pp
, pi
);
10467 sequential_row(&d
.this, pp
, pi
, -1, 0);
10470 gamma_image_validate(&d
, pp
, pi
);
10472 d
.this.ps
->validated
= 1;
10475 modifier_reset(d
.pm
);
10477 if (d
.pm
->log
&& !d
.threshold_test
&& !d
.this.speed
)
10478 fprintf(stderr
, "%d bit %s %s: max error %f (%.2g, %2g%%)\n",
10479 d
.this.bit_depth
, colour_types
[d
.this.colour_type
], name
,
10480 d
.maxerrout
, d
.maxerrabs
, 100*d
.maxerrpc
);
10482 /* Log the summary values too. */
10483 if (d
.this.colour_type
== 0 || d
.this.colour_type
== 4)
10485 switch (d
.this.bit_depth
)
10491 if (d
.maxerrout
> d
.pm
->error_gray_2
)
10492 d
.pm
->error_gray_2
= d
.maxerrout
;
10497 if (d
.maxerrout
> d
.pm
->error_gray_4
)
10498 d
.pm
->error_gray_4
= d
.maxerrout
;
10503 if (d
.maxerrout
> d
.pm
->error_gray_8
)
10504 d
.pm
->error_gray_8
= d
.maxerrout
;
10509 if (d
.maxerrout
> d
.pm
->error_gray_16
)
10510 d
.pm
->error_gray_16
= d
.maxerrout
;
10515 png_error(pp
, "bad bit depth (internal: 1)");
10519 else if (d
.this.colour_type
== 2 || d
.this.colour_type
== 6)
10521 switch (d
.this.bit_depth
)
10525 if (d
.maxerrout
> d
.pm
->error_color_8
)
10526 d
.pm
->error_color_8
= d
.maxerrout
;
10532 if (d
.maxerrout
> d
.pm
->error_color_16
)
10533 d
.pm
->error_color_16
= d
.maxerrout
;
10538 png_error(pp
, "bad bit depth (internal: 2)");
10542 else if (d
.this.colour_type
== 3)
10544 if (d
.maxerrout
> d
.pm
->error_indexed
)
10545 d
.pm
->error_indexed
= d
.maxerrout
;
10550 modifier_reset(voidcast(png_modifier
*,(void*)fault
));
10553 static void gamma_threshold_test(png_modifier
*pm
, png_byte colour_type
,
10554 png_byte bit_depth
, int interlace_type
, double file_gamma
,
10555 double screen_gamma
)
10559 pos
= safecat(name
, sizeof name
, pos
, "threshold ");
10560 pos
= safecatd(name
, sizeof name
, pos
, file_gamma
, 3);
10561 pos
= safecat(name
, sizeof name
, pos
, "/");
10562 pos
= safecatd(name
, sizeof name
, pos
, screen_gamma
, 3);
10564 (void)gamma_test(pm
, colour_type
, bit_depth
, 0/*palette*/, interlace_type
,
10565 file_gamma
, screen_gamma
, 0/*sBIT*/, 1/*threshold test*/, name
,
10566 0 /*no input precision*/,
10567 0 /*no scale16*/, 0 /*no expand16*/, 0 /*no background*/, 0 /*hence*/,
10568 0 /*no background gamma*/);
10572 perform_gamma_threshold_tests(png_modifier
*pm
)
10574 png_byte colour_type
= 0;
10575 png_byte bit_depth
= 0;
10576 unsigned int palette_number
= 0;
10578 /* Don't test more than one instance of each palette - it's pointless, in
10579 * fact this test is somewhat excessive since libpng doesn't make this
10580 * decision based on colour type or bit depth!
10582 * CHANGED: now test two palettes and, as a side effect, images with and
10585 while (next_format(&colour_type
, &bit_depth
, &palette_number
,
10586 pm
->test_lbg_gamma_threshold
, pm
->test_tRNS
))
10587 if (palette_number
< 2)
10589 double test_gamma
= 1.0;
10590 while (test_gamma
>= .4)
10592 /* There's little point testing the interlacing vs non-interlacing,
10593 * but this can be set from the command line.
10595 gamma_threshold_test(pm
, colour_type
, bit_depth
, pm
->interlace_type
,
10596 test_gamma
, 1/test_gamma
);
10600 /* And a special test for sRGB */
10601 gamma_threshold_test(pm
, colour_type
, bit_depth
, pm
->interlace_type
,
10609 static void gamma_transform_test(png_modifier
*pm
,
10610 png_byte colour_type
, png_byte bit_depth
,
10611 int palette_number
,
10612 int interlace_type
, const double file_gamma
,
10613 const double screen_gamma
, png_byte sbit
,
10614 int use_input_precision
, int scale16
)
10619 if (sbit
!= bit_depth
&& sbit
!= 0)
10621 pos
= safecat(name
, sizeof name
, pos
, "sbit(");
10622 pos
= safecatn(name
, sizeof name
, pos
, sbit
);
10623 pos
= safecat(name
, sizeof name
, pos
, ") ");
10627 pos
= safecat(name
, sizeof name
, pos
, "gamma ");
10630 pos
= safecat(name
, sizeof name
, pos
, "16to8 ");
10632 pos
= safecatd(name
, sizeof name
, pos
, file_gamma
, 3);
10633 pos
= safecat(name
, sizeof name
, pos
, "->");
10634 pos
= safecatd(name
, sizeof name
, pos
, screen_gamma
, 3);
10636 gamma_test(pm
, colour_type
, bit_depth
, palette_number
, interlace_type
,
10637 file_gamma
, screen_gamma
, sbit
, 0, name
, use_input_precision
,
10638 scale16
, pm
->test_gamma_expand16
, 0 , 0, 0);
10641 static void perform_gamma_transform_tests(png_modifier
*pm
)
10643 png_byte colour_type
= 0;
10644 png_byte bit_depth
= 0;
10645 unsigned int palette_number
= 0;
10647 while (next_format(&colour_type
, &bit_depth
, &palette_number
,
10648 pm
->test_lbg_gamma_transform
, pm
->test_tRNS
))
10652 for (i
=0; i
<pm
->ngamma_tests
; ++i
) for (j
=0; j
<pm
->ngamma_tests
; ++j
)
10655 gamma_transform_test(pm
, colour_type
, bit_depth
, palette_number
,
10656 pm
->interlace_type
, 1/pm
->gammas
[i
], pm
->gammas
[j
], 0/*sBIT*/,
10657 pm
->use_input_precision
, 0 /*do not scale16*/);
10665 static void perform_gamma_sbit_tests(png_modifier
*pm
)
10669 /* The only interesting cases are colour and grayscale, alpha is ignored here
10670 * for overall speed. Only bit depths where sbit is less than the bit depth
10673 for (sbit
=pm
->sbitlow
; sbit
<(1<<READ_BDHI
); ++sbit
)
10675 png_byte colour_type
= 0, bit_depth
= 0;
10676 unsigned int npalette
= 0;
10678 while (next_format(&colour_type
, &bit_depth
, &npalette
,
10679 pm
->test_lbg_gamma_sbit
, pm
->test_tRNS
))
10680 if ((colour_type
& PNG_COLOR_MASK_ALPHA
) == 0 &&
10681 ((colour_type
== 3 && sbit
< 8) ||
10682 (colour_type
!= 3 && sbit
< bit_depth
)))
10686 for (i
=0; i
<pm
->ngamma_tests
; ++i
)
10690 for (j
=0; j
<pm
->ngamma_tests
; ++j
) if (i
!= j
)
10692 gamma_transform_test(pm
, colour_type
, bit_depth
, npalette
,
10693 pm
->interlace_type
, 1/pm
->gammas
[i
], pm
->gammas
[j
],
10694 sbit
, pm
->use_input_precision_sbit
, 0 /*scale16*/);
10704 /* Note that this requires a 16 bit source image but produces 8 bit output, so
10705 * we only need the 16bit write support, but the 16 bit images are only
10706 * generated if DO_16BIT is defined.
10709 static void perform_gamma_scale16_tests(png_modifier
*pm
)
10711 # ifndef PNG_MAX_GAMMA_8
10712 # define PNG_MAX_GAMMA_8 11
10714 # if defined PNG_MAX_GAMMA_8 || PNG_LIBPNG_VER < 10700
10715 # define SBIT_16_TO_8 PNG_MAX_GAMMA_8
10717 # define SBIT_16_TO_8 16
10719 /* Include the alpha cases here. Note that sbit matches the internal value
10720 * used by the library - otherwise we will get spurious errors from the
10721 * internal sbit style approximation.
10723 * The threshold test is here because otherwise the 16 to 8 conversion will
10724 * proceed *without* gamma correction, and the tests above will fail (but not
10725 * by much) - this could be fixed, it only appears with the -g option.
10728 for (i
=0; i
<pm
->ngamma_tests
; ++i
)
10730 for (j
=0; j
<pm
->ngamma_tests
; ++j
)
10733 fabs(pm
->gammas
[j
]/pm
->gammas
[i
]-1) >= PNG_GAMMA_THRESHOLD
)
10735 gamma_transform_test(pm
, 0, 16, 0, pm
->interlace_type
,
10736 1/pm
->gammas
[i
], pm
->gammas
[j
], SBIT_16_TO_8
,
10737 pm
->use_input_precision_16to8
, 1 /*scale16*/);
10742 gamma_transform_test(pm
, 2, 16, 0, pm
->interlace_type
,
10743 1/pm
->gammas
[i
], pm
->gammas
[j
], SBIT_16_TO_8
,
10744 pm
->use_input_precision_16to8
, 1 /*scale16*/);
10749 gamma_transform_test(pm
, 4, 16, 0, pm
->interlace_type
,
10750 1/pm
->gammas
[i
], pm
->gammas
[j
], SBIT_16_TO_8
,
10751 pm
->use_input_precision_16to8
, 1 /*scale16*/);
10756 gamma_transform_test(pm
, 6, 16, 0, pm
->interlace_type
,
10757 1/pm
->gammas
[i
], pm
->gammas
[j
], SBIT_16_TO_8
,
10758 pm
->use_input_precision_16to8
, 1 /*scale16*/);
10766 #endif /* 16 to 8 bit conversion */
10768 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
10769 defined(PNG_READ_ALPHA_MODE_SUPPORTED)
10770 static void gamma_composition_test(png_modifier
*pm
,
10771 png_byte colour_type
, png_byte bit_depth
,
10772 int palette_number
,
10773 int interlace_type
, const double file_gamma
,
10774 const double screen_gamma
,
10775 int use_input_precision
, int do_background
,
10779 png_const_charp base
;
10782 png_color_16 background
;
10784 /* Make up a name and get an appropriate background gamma value. */
10785 switch (do_background
)
10789 bg
= 4; /* should not be used */
10791 case PNG_BACKGROUND_GAMMA_SCREEN
:
10792 base
= " bckg(Screen):";
10793 bg
= 1/screen_gamma
;
10795 case PNG_BACKGROUND_GAMMA_FILE
:
10796 base
= " bckg(File):";
10799 case PNG_BACKGROUND_GAMMA_UNIQUE
:
10800 base
= " bckg(Unique):";
10801 /* This tests the handling of a unique value, the math is such that the
10802 * value tends to be <1, but is neither screen nor file (even if they
10805 bg
= (file_gamma
+ screen_gamma
) / 3;
10807 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
10808 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_PNG
:
10809 base
= " alpha(PNG)";
10810 bg
= 4; /* should not be used */
10812 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_STANDARD
:
10813 base
= " alpha(Porter-Duff)";
10814 bg
= 4; /* should not be used */
10816 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_OPTIMIZED
:
10817 base
= " alpha(Optimized)";
10818 bg
= 4; /* should not be used */
10820 case ALPHA_MODE_OFFSET
+ PNG_ALPHA_BROKEN
:
10821 base
= " alpha(Broken)";
10822 bg
= 4; /* should not be used */
10827 /* Use random background values - the background is always presented in the
10828 * output space (8 or 16 bit components).
10830 if (expand_16
|| bit_depth
== 16)
10832 png_uint_32 r
= random_32();
10834 background
.red
= (png_uint_16
)r
;
10835 background
.green
= (png_uint_16
)(r
>> 16);
10837 background
.blue
= (png_uint_16
)r
;
10838 background
.gray
= (png_uint_16
)(r
>> 16);
10840 /* In earlier libpng versions, those where DIGITIZE is set, any background
10841 * gamma correction in the expand16 case was done using 8-bit gamma
10842 * correction tables, resulting in larger errors. To cope with those
10843 * cases use a 16-bit background value which will handle this gamma
10847 if (expand_16
&& (do_background
== PNG_BACKGROUND_GAMMA_UNIQUE
||
10848 do_background
== PNG_BACKGROUND_GAMMA_FILE
) &&
10849 fabs(bg
*screen_gamma
-1) > PNG_GAMMA_THRESHOLD
)
10851 /* The background values will be looked up in an 8-bit table to do
10852 * the gamma correction, so only select values which are an exact
10853 * match for the 8-bit table entries:
10855 background
.red
= (png_uint_16
)((background
.red
>> 8) * 257);
10856 background
.green
= (png_uint_16
)((background
.green
>> 8) * 257);
10857 background
.blue
= (png_uint_16
)((background
.blue
>> 8) * 257);
10858 background
.gray
= (png_uint_16
)((background
.gray
>> 8) * 257);
10863 else /* 8 bit colors */
10865 png_uint_32 r
= random_32();
10867 background
.red
= (png_byte
)r
;
10868 background
.green
= (png_byte
)(r
>> 8);
10869 background
.blue
= (png_byte
)(r
>> 16);
10870 background
.gray
= (png_byte
)(r
>> 24);
10873 background
.index
= 193; /* rgb(193,193,193) to detect errors */
10875 if (!(colour_type
& PNG_COLOR_MASK_COLOR
))
10877 /* Because, currently, png_set_background is always called with
10878 * 'need_expand' false in this case and because the gamma test itself
10879 * doesn't cause an expand to 8-bit for lower bit depths the colour must
10880 * be reduced to the correct range.
10883 background
.gray
&= (png_uint_16
)((1U << bit_depth
)-1);
10885 /* Grayscale input, we do not convert to RGB (TBD), so we must set the
10886 * background to gray - else libpng seems to fail.
10888 background
.red
= background
.green
= background
.blue
= background
.gray
;
10891 pos
= safecat(name
, sizeof name
, pos
, "gamma ");
10892 pos
= safecatd(name
, sizeof name
, pos
, file_gamma
, 3);
10893 pos
= safecat(name
, sizeof name
, pos
, "->");
10894 pos
= safecatd(name
, sizeof name
, pos
, screen_gamma
, 3);
10896 pos
= safecat(name
, sizeof name
, pos
, base
);
10897 if (do_background
< ALPHA_MODE_OFFSET
)
10899 /* Include the background color and gamma in the name: */
10900 pos
= safecat(name
, sizeof name
, pos
, "(");
10901 /* This assumes no expand gray->rgb - the current code won't handle that!
10903 if (colour_type
& PNG_COLOR_MASK_COLOR
)
10905 pos
= safecatn(name
, sizeof name
, pos
, background
.red
);
10906 pos
= safecat(name
, sizeof name
, pos
, ",");
10907 pos
= safecatn(name
, sizeof name
, pos
, background
.green
);
10908 pos
= safecat(name
, sizeof name
, pos
, ",");
10909 pos
= safecatn(name
, sizeof name
, pos
, background
.blue
);
10912 pos
= safecatn(name
, sizeof name
, pos
, background
.gray
);
10913 pos
= safecat(name
, sizeof name
, pos
, ")^");
10914 pos
= safecatd(name
, sizeof name
, pos
, bg
, 3);
10917 gamma_test(pm
, colour_type
, bit_depth
, palette_number
, interlace_type
,
10918 file_gamma
, screen_gamma
, 0/*sBIT*/, 0, name
, use_input_precision
,
10919 0/*strip 16*/, expand_16
, do_background
, &background
, bg
);
10924 perform_gamma_composition_tests(png_modifier
*pm
, int do_background
,
10927 png_byte colour_type
= 0;
10928 png_byte bit_depth
= 0;
10929 unsigned int palette_number
= 0;
10931 /* Skip the non-alpha cases - there is no setting of a transparency colour at
10934 * TODO: incorrect; the palette case sets tRNS and, now RGB and gray do,
10935 * however the palette case fails miserably so is commented out below.
10937 while (next_format(&colour_type
, &bit_depth
, &palette_number
,
10938 pm
->test_lbg_gamma_composition
, pm
->test_tRNS
))
10939 if ((colour_type
& PNG_COLOR_MASK_ALPHA
) != 0
10940 #if 0 /* TODO: FIXME */
10941 /*TODO: FIXME: this should work */
10942 || colour_type
== 3
10944 || (colour_type
!= 3 && palette_number
!= 0))
10948 /* Don't skip the i==j case here - it's relevant. */
10949 for (i
=0; i
<pm
->ngamma_tests
; ++i
) for (j
=0; j
<pm
->ngamma_tests
; ++j
)
10951 gamma_composition_test(pm
, colour_type
, bit_depth
, palette_number
,
10952 pm
->interlace_type
, 1/pm
->gammas
[i
], pm
->gammas
[j
],
10953 pm
->use_input_precision
, do_background
, expand_16
);
10960 #endif /* READ_BACKGROUND || READ_ALPHA_MODE */
10963 init_gamma_errors(png_modifier
*pm
)
10965 /* Use -1 to catch tests that were not actually run */
10966 pm
->error_gray_2
= pm
->error_gray_4
= pm
->error_gray_8
= -1.;
10967 pm
->error_color_8
= -1.;
10968 pm
->error_indexed
= -1.;
10969 pm
->error_gray_16
= pm
->error_color_16
= -1.;
10973 print_one(const char *leader
, double err
)
10976 printf(" %s %.5f\n", leader
, err
);
10980 summarize_gamma_errors(png_modifier
*pm
, png_const_charp who
, int low_bit_depth
,
10986 printf("\nGamma correction with %s:\n", who
);
10989 printf("\nBasic gamma correction:\n");
10993 print_one(" 2 bit gray: ", pm
->error_gray_2
);
10994 print_one(" 4 bit gray: ", pm
->error_gray_4
);
10995 print_one(" 8 bit gray: ", pm
->error_gray_8
);
10996 print_one(" 8 bit color:", pm
->error_color_8
);
10998 print_one(" indexed: ", pm
->error_indexed
);
11001 print_one("16 bit gray: ", pm
->error_gray_16
);
11002 print_one("16 bit color:", pm
->error_color_16
);
11008 perform_gamma_test(png_modifier
*pm
, int summary
)
11010 /*TODO: remove this*/
11011 /* Save certain values for the temporary overrides below. */
11012 unsigned int calculations_use_input_precision
=
11013 pm
->calculations_use_input_precision
;
11014 # ifdef PNG_READ_BACKGROUND_SUPPORTED
11015 double maxout8
= pm
->maxout8
;
11018 /* First some arbitrary no-transform tests: */
11019 if (!pm
->this.speed
&& pm
->test_gamma_threshold
)
11021 perform_gamma_threshold_tests(pm
);
11027 /* Now some real transforms. */
11028 if (pm
->test_gamma_transform
)
11033 printf("Gamma correction error summary\n\n");
11034 printf("The printed value is the maximum error in the pixel values\n");
11035 printf("calculated by the libpng gamma correction code. The error\n");
11036 printf("is calculated as the difference between the output pixel\n");
11037 printf("value (always an integer) and the ideal value from the\n");
11038 printf("libpng specification (typically not an integer).\n\n");
11040 printf("Expect this value to be less than .5 for 8 bit formats,\n");
11041 printf("less than 1 for formats with fewer than 8 bits and a small\n");
11042 printf("number (typically less than 5) for the 16 bit formats.\n");
11043 printf("For performance reasons the value for 16 bit formats\n");
11044 printf("increases when the image file includes an sBIT chunk.\n");
11048 init_gamma_errors(pm
);
11049 /*TODO: remove this. Necessary because the current libpng
11050 * implementation works in 8 bits:
11052 if (pm
->test_gamma_expand16
)
11053 pm
->calculations_use_input_precision
= 1;
11054 perform_gamma_transform_tests(pm
);
11055 if (!calculations_use_input_precision
)
11056 pm
->calculations_use_input_precision
= 0;
11059 summarize_gamma_errors(pm
, 0/*who*/, 1/*low bit depth*/, 1/*indexed*/);
11065 /* The sbit tests produce much larger errors: */
11066 if (pm
->test_gamma_sbit
)
11068 init_gamma_errors(pm
);
11069 perform_gamma_sbit_tests(pm
);
11072 summarize_gamma_errors(pm
, "sBIT", pm
->sbitlow
< 8U, 1/*indexed*/);
11078 #ifdef DO_16BIT /* Should be READ_16BIT_SUPPORTED */
11079 if (pm
->test_gamma_scale16
)
11081 /* The 16 to 8 bit strip operations: */
11082 init_gamma_errors(pm
);
11083 perform_gamma_scale16_tests(pm
);
11088 printf("\nGamma correction with 16 to 8 bit reduction:\n");
11089 printf(" 16 bit gray: %.5f\n", pm
->error_gray_16
);
11090 printf(" 16 bit color: %.5f\n", pm
->error_color_16
);
11099 #ifdef PNG_READ_BACKGROUND_SUPPORTED
11100 if (pm
->test_gamma_background
)
11102 init_gamma_errors(pm
);
11104 /*TODO: remove this. Necessary because the current libpng
11105 * implementation works in 8 bits:
11107 if (pm
->test_gamma_expand16
)
11109 pm
->calculations_use_input_precision
= 1;
11110 pm
->maxout8
= .499; /* because the 16 bit background is smashed */
11112 perform_gamma_composition_tests(pm
, PNG_BACKGROUND_GAMMA_UNIQUE
,
11113 pm
->test_gamma_expand16
);
11114 if (!calculations_use_input_precision
)
11115 pm
->calculations_use_input_precision
= 0;
11116 pm
->maxout8
= maxout8
;
11119 summarize_gamma_errors(pm
, "background", 1, 0/*indexed*/);
11126 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
11127 if (pm
->test_gamma_alpha_mode
)
11131 init_gamma_errors(pm
);
11133 /*TODO: remove this. Necessary because the current libpng
11134 * implementation works in 8 bits:
11136 if (pm
->test_gamma_expand16
)
11137 pm
->calculations_use_input_precision
= 1;
11138 for (do_background
= ALPHA_MODE_OFFSET
+ PNG_ALPHA_STANDARD
;
11139 do_background
<= ALPHA_MODE_OFFSET
+ PNG_ALPHA_BROKEN
&& !fail(pm
);
11141 perform_gamma_composition_tests(pm
, do_background
,
11142 pm
->test_gamma_expand16
);
11143 if (!calculations_use_input_precision
)
11144 pm
->calculations_use_input_precision
= 0;
11147 summarize_gamma_errors(pm
, "alpha mode", 1, 0/*indexed*/);
11154 #endif /* PNG_READ_GAMMA_SUPPORTED */
11155 #endif /* PNG_READ_SUPPORTED */
11157 /* INTERLACE MACRO VALIDATION */
11158 /* This is copied verbatim from the specification, it is simply the pass
11159 * number in which each pixel in each 8x8 tile appears. The array must
11160 * be indexed adam7[y][x] and notice that the pass numbers are based at
11161 * 1, not 0 - the base libpng uses.
11164 png_byte adam7
[8][8] =
11166 { 1,6,4,6,2,6,4,6 },
11167 { 7,7,7,7,7,7,7,7 },
11168 { 5,6,5,6,5,6,5,6 },
11169 { 7,7,7,7,7,7,7,7 },
11170 { 3,6,4,6,3,6,4,6 },
11171 { 7,7,7,7,7,7,7,7 },
11172 { 5,6,5,6,5,6,5,6 },
11173 { 7,7,7,7,7,7,7,7 }
11176 /* This routine validates all the interlace support macros in png.h for
11177 * a variety of valid PNG widths and heights. It uses a number of similarly
11178 * named internal routines that feed off the above array.
11181 png_pass_start_row(int pass
)
11185 for (y
=0; y
<8; ++y
) for (x
=0; x
<8; ++x
) if (adam7
[y
][x
] == pass
)
11191 png_pass_start_col(int pass
)
11195 for (x
=0; x
<8; ++x
) for (y
=0; y
<8; ++y
) if (adam7
[y
][x
] == pass
)
11201 png_pass_row_shift(int pass
)
11203 int x
, y
, base
=(-1), inc
=8;
11205 for (y
=0; y
<8; ++y
) for (x
=0; x
<8; ++x
) if (adam7
[y
][x
] == pass
)
11209 else if (base
== y
)
11211 else if (inc
== y
-base
)
11214 inc
= y
-base
, base
=y
;
11215 else if (inc
!= y
-base
)
11216 return 0xff; /* error - more than one 'inc' value! */
11219 if (base
== (-1)) return 0xfe; /* error - no row in pass! */
11221 /* The shift is always 1, 2 or 3 - no pass has all the rows! */
11230 /* error - unrecognized 'inc' */
11231 return (inc
<< 8) + 0xfd;
11235 png_pass_col_shift(int pass
)
11237 int x
, y
, base
=(-1), inc
=8;
11239 for (x
=0; x
<8; ++x
) for (y
=0; y
<8; ++y
) if (adam7
[y
][x
] == pass
)
11243 else if (base
== x
)
11245 else if (inc
== x
-base
)
11248 inc
= x
-base
, base
=x
;
11249 else if (inc
!= x
-base
)
11250 return 0xff; /* error - more than one 'inc' value! */
11253 if (base
== (-1)) return 0xfe; /* error - no row in pass! */
11255 /* The shift is always 1, 2 or 3 - no pass has all the rows! */
11258 case 1: return 0; /* pass 7 has all the columns */
11265 /* error - unrecognized 'inc' */
11266 return (inc
<< 8) + 0xfd;
11270 png_row_from_pass_row(png_uint_32 yIn
, int pass
)
11272 /* By examination of the array: */
11275 case 0: return yIn
* 8;
11276 case 1: return yIn
* 8;
11277 case 2: return yIn
* 8 + 4;
11278 case 3: return yIn
* 4;
11279 case 4: return yIn
* 4 + 2;
11280 case 5: return yIn
* 2;
11281 case 6: return yIn
* 2 + 1;
11285 return 0xff; /* bad pass number */
11289 png_col_from_pass_col(png_uint_32 xIn
, int pass
)
11291 /* By examination of the array: */
11294 case 0: return xIn
* 8;
11295 case 1: return xIn
* 8 + 4;
11296 case 2: return xIn
* 4;
11297 case 3: return xIn
* 4 + 2;
11298 case 4: return xIn
* 2;
11299 case 5: return xIn
* 2 + 1;
11300 case 6: return xIn
;
11304 return 0xff; /* bad pass number */
11308 png_row_in_interlace_pass(png_uint_32 y
, int pass
)
11310 /* Is row 'y' in pass 'pass'? */
11314 for (x
=0; x
<8; ++x
) if (adam7
[y
][x
] == pass
)
11321 png_col_in_interlace_pass(png_uint_32 x
, int pass
)
11323 /* Is column 'x' in pass 'pass'? */
11327 for (y
=0; y
<8; ++y
) if (adam7
[y
][x
] == pass
)
11334 png_pass_rows(png_uint_32 height
, int pass
)
11336 png_uint_32 tiles
= height
>>3;
11337 png_uint_32 rows
= 0;
11342 for (y
=0; y
<8; ++y
) for (x
=0; x
<8; ++x
) if (adam7
[y
][x
] == pass
)
11345 if (y
< height
) ++rows
;
11346 break; /* i.e. break the 'x', column, loop. */
11353 png_pass_cols(png_uint_32 width
, int pass
)
11355 png_uint_32 tiles
= width
>>3;
11356 png_uint_32 cols
= 0;
11361 for (x
=0; x
<8; ++x
) for (y
=0; y
<8; ++y
) if (adam7
[y
][x
] == pass
)
11364 if (x
< width
) ++cols
;
11365 break; /* i.e. break the 'y', row, loop. */
11372 perform_interlace_macro_validation(void)
11374 /* The macros to validate, first those that depend only on pass:
11376 * PNG_PASS_START_ROW(pass)
11377 * PNG_PASS_START_COL(pass)
11378 * PNG_PASS_ROW_SHIFT(pass)
11379 * PNG_PASS_COL_SHIFT(pass)
11383 for (pass
=0; pass
<7; ++pass
)
11385 png_uint_32 m
, f
, v
;
11387 m
= PNG_PASS_START_ROW(pass
);
11388 f
= png_pass_start_row(pass
);
11391 fprintf(stderr
, "PNG_PASS_START_ROW(%d) = %u != %x\n", pass
, m
, f
);
11395 m
= PNG_PASS_START_COL(pass
);
11396 f
= png_pass_start_col(pass
);
11399 fprintf(stderr
, "PNG_PASS_START_COL(%d) = %u != %x\n", pass
, m
, f
);
11403 m
= PNG_PASS_ROW_SHIFT(pass
);
11404 f
= png_pass_row_shift(pass
);
11407 fprintf(stderr
, "PNG_PASS_ROW_SHIFT(%d) = %u != %x\n", pass
, m
, f
);
11411 m
= PNG_PASS_COL_SHIFT(pass
);
11412 f
= png_pass_col_shift(pass
);
11415 fprintf(stderr
, "PNG_PASS_COL_SHIFT(%d) = %u != %x\n", pass
, m
, f
);
11419 /* Macros that depend on the image or sub-image height too:
11421 * PNG_PASS_ROWS(height, pass)
11422 * PNG_PASS_COLS(width, pass)
11423 * PNG_ROW_FROM_PASS_ROW(yIn, pass)
11424 * PNG_COL_FROM_PASS_COL(xIn, pass)
11425 * PNG_ROW_IN_INTERLACE_PASS(y, pass)
11426 * PNG_COL_IN_INTERLACE_PASS(x, pass)
11430 /* The first two tests overflow if the pass row or column is outside
11431 * the possible range for a 32-bit result. In fact the values should
11432 * never be outside the range for a 31-bit result, but checking for 32
11433 * bits here ensures that if an app uses a bogus pass row or column
11434 * (just so long as it fits in a 32 bit integer) it won't get a
11435 * possibly dangerous overflow.
11437 /* First the base 0 stuff: */
11438 if (v
< png_pass_rows(0xFFFFFFFFU
, pass
))
11440 m
= PNG_ROW_FROM_PASS_ROW(v
, pass
);
11441 f
= png_row_from_pass_row(v
, pass
);
11444 fprintf(stderr
, "PNG_ROW_FROM_PASS_ROW(%u, %d) = %u != %x\n",
11450 if (v
< png_pass_cols(0xFFFFFFFFU
, pass
))
11452 m
= PNG_COL_FROM_PASS_COL(v
, pass
);
11453 f
= png_col_from_pass_col(v
, pass
);
11456 fprintf(stderr
, "PNG_COL_FROM_PASS_COL(%u, %d) = %u != %x\n",
11462 m
= PNG_ROW_IN_INTERLACE_PASS(v
, pass
);
11463 f
= png_row_in_interlace_pass(v
, pass
);
11466 fprintf(stderr
, "PNG_ROW_IN_INTERLACE_PASS(%u, %d) = %u != %x\n",
11471 m
= PNG_COL_IN_INTERLACE_PASS(v
, pass
);
11472 f
= png_col_in_interlace_pass(v
, pass
);
11475 fprintf(stderr
, "PNG_COL_IN_INTERLACE_PASS(%u, %d) = %u != %x\n",
11480 /* Then the base 1 stuff: */
11482 m
= PNG_PASS_ROWS(v
, pass
);
11483 f
= png_pass_rows(v
, pass
);
11486 fprintf(stderr
, "PNG_PASS_ROWS(%u, %d) = %u != %x\n",
11491 m
= PNG_PASS_COLS(v
, pass
);
11492 f
= png_pass_cols(v
, pass
);
11495 fprintf(stderr
, "PNG_PASS_COLS(%u, %d) = %u != %x\n",
11500 /* Move to the next v - the stepping algorithm starts skipping
11501 * values above 1024.
11505 if (v
== PNG_UINT_31_MAX
)
11509 if (v
>= PNG_UINT_31_MAX
)
11510 v
= PNG_UINT_31_MAX
-1;
11516 /* Test color encodings. These values are back-calculated from the published
11517 * chromaticities. The values are accurate to about 14 decimal places; 15 are
11518 * given. These values are much more accurate than the ones given in the spec,
11519 * which typically don't exceed 4 decimal places. This allows testing of the
11520 * libpng code to its theoretical accuracy of 4 decimal places. (If pngvalid
11521 * used the published errors the 'slack' permitted would have to be +/-.5E-4 or
11524 * The png_modifier code assumes that encodings[0] is sRGB and treats it
11525 * specially: do not change the first entry in this list!
11527 static const color_encoding test_encodings
[] =
11529 /* sRGB: must be first in this list! */
11530 /*gamma:*/ { 1/2.2,
11531 /*red: */ { 0.412390799265959, 0.212639005871510, 0.019330818715592 },
11532 /*green:*/ { 0.357584339383878, 0.715168678767756, 0.119194779794626 },
11533 /*blue: */ { 0.180480788401834, 0.072192315360734, 0.950532152249660} },
11534 /* Kodak ProPhoto (wide gamut) */
11535 /*gamma:*/ { 1/1.6 /*approximate: uses 1.8 power law compared to sRGB 2.4*/,
11536 /*red: */ { 0.797760489672303, 0.288071128229293, 0.000000000000000 },
11537 /*green:*/ { 0.135185837175740, 0.711843217810102, 0.000000000000000 },
11538 /*blue: */ { 0.031349349581525, 0.000085653960605, 0.825104602510460} },
11539 /* Adobe RGB (1998) */
11540 /*gamma:*/ { 1/(2+51./256),
11541 /*red: */ { 0.576669042910131, 0.297344975250536, 0.027031361386412 },
11542 /*green:*/ { 0.185558237906546, 0.627363566255466, 0.070688852535827 },
11543 /*blue: */ { 0.188228646234995, 0.075291458493998, 0.991337536837639} },
11544 /* Adobe Wide Gamut RGB */
11545 /*gamma:*/ { 1/(2+51./256),
11546 /*red: */ { 0.716500716779386, 0.258728243040113, 0.000000000000000 },
11547 /*green:*/ { 0.101020574397477, 0.724682314948566, 0.051211818965388 },
11548 /*blue: */ { 0.146774385252705, 0.016589442011321, 0.773892783545073} },
11549 /* Fake encoding which selects just the green channel */
11550 /*gamma:*/ { 1.45/2.2, /* the 'Mac' gamma */
11551 /*red: */ { 0.716500716779386, 0.000000000000000, 0.000000000000000 },
11552 /*green:*/ { 0.101020574397477, 1.000000000000000, 0.051211818965388 },
11553 /*blue: */ { 0.146774385252705, 0.000000000000000, 0.773892783545073} },
11558 * This attempts to trap signals and escape without crashing. It needs a
11559 * context pointer so that it can throw an exception (call longjmp) to recover
11560 * from the condition; this is handled by making the png_modifier used by 'main'
11561 * into a global variable.
11563 static png_modifier pm
;
11565 static void signal_handler(int signum
)
11571 pos
= safecat(msg
, sizeof msg
, pos
, "caught signal: ");
11576 pos
= safecat(msg
, sizeof msg
, pos
, "abort");
11580 pos
= safecat(msg
, sizeof msg
, pos
, "floating point exception");
11584 pos
= safecat(msg
, sizeof msg
, pos
, "illegal instruction");
11588 pos
= safecat(msg
, sizeof msg
, pos
, "interrupt");
11592 pos
= safecat(msg
, sizeof msg
, pos
, "invalid memory access");
11596 pos
= safecat(msg
, sizeof msg
, pos
, "termination request");
11600 pos
= safecat(msg
, sizeof msg
, pos
, "unknown ");
11601 pos
= safecatn(msg
, sizeof msg
, pos
, signum
);
11605 store_log(&pm
.this, NULL
/*png_structp*/, msg
, 1/*error*/);
11607 /* And finally throw an exception so we can keep going, unless this is
11608 * SIGTERM in which case stop now.
11610 if (signum
!= SIGTERM
)
11612 struct exception_context
*the_exception_context
=
11613 &pm
.this.exception_context
;
11623 int main(int argc
, char **argv
)
11625 int summary
= 1; /* Print the error summary at the end */
11626 int memstats
= 0; /* Print memory statistics at the end */
11628 /* Create the given output file on success: */
11629 const char *touch
= NULL
;
11631 /* This is an array of standard gamma values (believe it or not I've seen
11632 * every one of these mentioned somewhere.)
11634 * In the following list the most useful values are first!
11637 gammas
[]={2.2, 1.0, 2.2/1.45, 1.8, 1.5, 2.4, 2.5, 2.62, 2.9};
11639 /* This records the command and arguments: */
11641 char command
[1024];
11643 anon_context(&pm
.this);
11645 gnu_volatile(summary
)
11646 gnu_volatile(memstats
)
11647 gnu_volatile(touch
)
11649 /* Add appropriate signal handlers, just the ANSI specified ones: */
11650 signal(SIGABRT
, signal_handler
);
11651 signal(SIGFPE
, signal_handler
);
11652 signal(SIGILL
, signal_handler
);
11653 signal(SIGINT
, signal_handler
);
11654 signal(SIGSEGV
, signal_handler
);
11655 signal(SIGTERM
, signal_handler
);
11657 #ifdef HAVE_FEENABLEEXCEPT
11658 /* Only required to enable FP exceptions on platforms where they start off
11659 * disabled; this is not necessary but if it is not done pngvalid will likely
11660 * end up ignoring FP conditions that other platforms fault.
11662 feenableexcept(FE_DIVBYZERO
| FE_INVALID
| FE_OVERFLOW
);
11665 modifier_init(&pm
);
11667 /* Preallocate the image buffer, because we know how big it needs to be,
11668 * note that, for testing purposes, it is deliberately mis-aligned by tag
11669 * bytes either side. All rows have an additional five bytes of padding for
11670 * overwrite checking.
11672 store_ensure_image(&pm
.this, NULL
, 2, TRANSFORM_ROWMAX
, TRANSFORM_HEIGHTMAX
);
11674 /* Don't give argv[0], it's normally some horrible libtool string: */
11675 cp
= safecat(command
, sizeof command
, cp
, "pngvalid");
11677 /* Default to error on warning: */
11678 pm
.this.treat_warnings_as_errors
= 1;
11680 /* Default assume_16_bit_calculations appropriately; this tells the checking
11681 * code that 16-bit arithmetic is used for 8-bit samples when it would make a
11684 pm
.assume_16_bit_calculations
= PNG_LIBPNG_VER
>= 10700;
11686 /* Currently 16 bit expansion happens at the end of the pipeline, so the
11687 * calculations are done in the input bit depth not the output.
11691 pm
.calculations_use_input_precision
= 1U;
11693 /* Store the test gammas */
11694 pm
.gammas
= gammas
;
11695 pm
.ngammas
= ARRAY_SIZE(gammas
);
11696 pm
.ngamma_tests
= 0; /* default to off */
11698 /* Low bit depth gray images don't do well in the gamma tests, until
11699 * this is fixed turn them off for some gamma cases:
11701 # ifdef PNG_WRITE_tRNS_SUPPORTED
11704 pm
.test_lbg
= PNG_LIBPNG_VER
>= 10600;
11705 pm
.test_lbg_gamma_threshold
= 1;
11706 pm
.test_lbg_gamma_transform
= PNG_LIBPNG_VER
>= 10600;
11707 pm
.test_lbg_gamma_sbit
= 1;
11708 pm
.test_lbg_gamma_composition
= PNG_LIBPNG_VER
>= 10700;
11710 /* And the test encodings */
11711 pm
.encodings
= test_encodings
;
11712 pm
.nencodings
= ARRAY_SIZE(test_encodings
);
11714 # if PNG_LIBPNG_VER < 10700
11715 pm
.sbitlow
= 8U; /* because libpng doesn't do sBIT below 8! */
11720 /* The following allows results to pass if they correspond to anything in the
11721 * transformed range [input-.5,input+.5]; this is is required because of the
11722 * way libpng treates the 16_TO_8 flag when building the gamma tables in
11723 * releases up to 1.6.0.
11725 * TODO: review this
11727 pm
.use_input_precision_16to8
= 1U;
11728 pm
.use_input_precision_sbit
= 1U; /* because libpng now rounds sBIT */
11730 /* Some default values (set the behavior for 'make check' here).
11731 * These values simply control the maximum error permitted in the gamma
11732 * transformations. The practical limits for human perception are described
11733 * below (the setting for maxpc16), however for 8 bit encodings it isn't
11734 * possible to meet the accepted capabilities of human vision - i.e. 8 bit
11735 * images can never be good enough, regardless of encoding.
11737 pm
.maxout8
= .1; /* Arithmetic error in *encoded* value */
11738 pm
.maxabs8
= .00005; /* 1/20000 */
11739 pm
.maxcalc8
= 1./255; /* +/-1 in 8 bits for compose errors */
11740 pm
.maxpc8
= .499; /* I.e., .499% fractional error */
11741 pm
.maxout16
= .499; /* Error in *encoded* value */
11742 pm
.maxabs16
= .00005;/* 1/20000 */
11743 pm
.maxcalc16
=1./65535;/* +/-1 in 16 bits for compose errors */
11744 # if PNG_LIBPNG_VER < 10700
11745 pm
.maxcalcG
= 1./((1<<PNG_MAX_GAMMA_8
)-1);
11747 pm
.maxcalcG
= 1./((1<<16)-1);
11750 /* NOTE: this is a reasonable perceptual limit. We assume that humans can
11751 * perceive light level differences of 1% over a 100:1 range, so we need to
11752 * maintain 1 in 10000 accuracy (in linear light space), which is what the
11753 * following guarantees. It also allows significantly higher errors at
11754 * higher 16 bit values, which is important for performance. The actual
11755 * maximum 16 bit error is about +/-1.9 in the fixed point implementation but
11756 * this is only allowed for values >38149 by the following:
11758 pm
.maxpc16
= .005; /* I.e., 1/200% - 1/20000 */
11760 /* Now parse the command line options. */
11761 while (--argc
>= 1)
11763 int catmore
= 0; /* Set if the argument has an argument. */
11765 /* Record each argument for posterity: */
11766 cp
= safecat(command
, sizeof command
, cp
, " ");
11767 cp
= safecat(command
, sizeof command
, cp
, *++argv
);
11769 if (strcmp(*argv
, "-v") == 0)
11770 pm
.this.verbose
= 1;
11772 else if (strcmp(*argv
, "-l") == 0)
11775 else if (strcmp(*argv
, "-q") == 0)
11776 summary
= pm
.this.verbose
= pm
.log
= 0;
11778 else if (strcmp(*argv
, "-w") == 0 ||
11779 strcmp(*argv
, "--strict") == 0)
11780 pm
.this.treat_warnings_as_errors
= 1; /* NOTE: this is the default! */
11782 else if (strcmp(*argv
, "--nostrict") == 0)
11783 pm
.this.treat_warnings_as_errors
= 0;
11785 else if (strcmp(*argv
, "--speed") == 0)
11786 pm
.this.speed
= 1, pm
.ngamma_tests
= pm
.ngammas
, pm
.test_standard
= 0,
11789 else if (strcmp(*argv
, "--memory") == 0)
11792 else if (strcmp(*argv
, "--size") == 0)
11795 else if (strcmp(*argv
, "--nosize") == 0)
11798 else if (strcmp(*argv
, "--standard") == 0)
11799 pm
.test_standard
= 1;
11801 else if (strcmp(*argv
, "--nostandard") == 0)
11802 pm
.test_standard
= 0;
11804 else if (strcmp(*argv
, "--transform") == 0)
11805 pm
.test_transform
= 1;
11807 else if (strcmp(*argv
, "--notransform") == 0)
11808 pm
.test_transform
= 0;
11810 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
11811 else if (strncmp(*argv
, "--transform-disable=",
11812 sizeof "--transform-disable") == 0)
11814 pm
.test_transform
= 1;
11815 transform_disable(*argv
+ sizeof "--transform-disable");
11818 else if (strncmp(*argv
, "--transform-enable=",
11819 sizeof "--transform-enable") == 0)
11821 pm
.test_transform
= 1;
11822 transform_enable(*argv
+ sizeof "--transform-enable");
11824 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
11826 else if (strcmp(*argv
, "--gamma") == 0)
11828 /* Just do two gamma tests here (2.2 and linear) for speed: */
11829 pm
.ngamma_tests
= 2U;
11830 pm
.test_gamma_threshold
= 1;
11831 pm
.test_gamma_transform
= 1;
11832 pm
.test_gamma_sbit
= 1;
11833 pm
.test_gamma_scale16
= 1;
11834 pm
.test_gamma_background
= 1; /* composition */
11835 pm
.test_gamma_alpha_mode
= 1;
11838 else if (strcmp(*argv
, "--nogamma") == 0)
11839 pm
.ngamma_tests
= 0;
11841 else if (strcmp(*argv
, "--gamma-threshold") == 0)
11842 pm
.ngamma_tests
= 2U, pm
.test_gamma_threshold
= 1;
11844 else if (strcmp(*argv
, "--nogamma-threshold") == 0)
11845 pm
.test_gamma_threshold
= 0;
11847 else if (strcmp(*argv
, "--gamma-transform") == 0)
11848 pm
.ngamma_tests
= 2U, pm
.test_gamma_transform
= 1;
11850 else if (strcmp(*argv
, "--nogamma-transform") == 0)
11851 pm
.test_gamma_transform
= 0;
11853 else if (strcmp(*argv
, "--gamma-sbit") == 0)
11854 pm
.ngamma_tests
= 2U, pm
.test_gamma_sbit
= 1;
11856 else if (strcmp(*argv
, "--nogamma-sbit") == 0)
11857 pm
.test_gamma_sbit
= 0;
11859 else if (strcmp(*argv
, "--gamma-16-to-8") == 0)
11860 pm
.ngamma_tests
= 2U, pm
.test_gamma_scale16
= 1;
11862 else if (strcmp(*argv
, "--nogamma-16-to-8") == 0)
11863 pm
.test_gamma_scale16
= 0;
11865 else if (strcmp(*argv
, "--gamma-background") == 0)
11866 pm
.ngamma_tests
= 2U, pm
.test_gamma_background
= 1;
11868 else if (strcmp(*argv
, "--nogamma-background") == 0)
11869 pm
.test_gamma_background
= 0;
11871 else if (strcmp(*argv
, "--gamma-alpha-mode") == 0)
11872 pm
.ngamma_tests
= 2U, pm
.test_gamma_alpha_mode
= 1;
11874 else if (strcmp(*argv
, "--nogamma-alpha-mode") == 0)
11875 pm
.test_gamma_alpha_mode
= 0;
11877 else if (strcmp(*argv
, "--expand16") == 0)
11878 pm
.test_gamma_expand16
= 1;
11880 else if (strcmp(*argv
, "--noexpand16") == 0)
11881 pm
.test_gamma_expand16
= 0;
11883 else if (strcmp(*argv
, "--low-depth-gray") == 0)
11884 pm
.test_lbg
= pm
.test_lbg_gamma_threshold
=
11885 pm
.test_lbg_gamma_transform
= pm
.test_lbg_gamma_sbit
=
11886 pm
.test_lbg_gamma_composition
= 1;
11888 else if (strcmp(*argv
, "--nolow-depth-gray") == 0)
11889 pm
.test_lbg
= pm
.test_lbg_gamma_threshold
=
11890 pm
.test_lbg_gamma_transform
= pm
.test_lbg_gamma_sbit
=
11891 pm
.test_lbg_gamma_composition
= 0;
11893 # ifdef PNG_WRITE_tRNS_SUPPORTED
11894 else if (strcmp(*argv
, "--tRNS") == 0)
11898 else if (strcmp(*argv
, "--notRNS") == 0)
11901 else if (strcmp(*argv
, "--more-gammas") == 0)
11902 pm
.ngamma_tests
= 3U;
11904 else if (strcmp(*argv
, "--all-gammas") == 0)
11905 pm
.ngamma_tests
= pm
.ngammas
;
11907 else if (strcmp(*argv
, "--progressive-read") == 0)
11908 pm
.this.progressive
= 1;
11910 else if (strcmp(*argv
, "--use-update-info") == 0)
11911 ++pm
.use_update_info
; /* Can call multiple times */
11913 else if (strcmp(*argv
, "--interlace") == 0)
11915 # if CAN_WRITE_INTERLACE
11916 pm
.interlace_type
= PNG_INTERLACE_ADAM7
;
11917 # else /* !CAN_WRITE_INTERLACE */
11918 fprintf(stderr
, "pngvalid: no write interlace support\n");
11920 # endif /* !CAN_WRITE_INTERLACE */
11923 else if (strcmp(*argv
, "--use-input-precision") == 0)
11924 pm
.use_input_precision
= 1U;
11926 else if (strcmp(*argv
, "--use-calculation-precision") == 0)
11927 pm
.use_input_precision
= 0;
11929 else if (strcmp(*argv
, "--calculations-use-input-precision") == 0)
11930 pm
.calculations_use_input_precision
= 1U;
11932 else if (strcmp(*argv
, "--assume-16-bit-calculations") == 0)
11933 pm
.assume_16_bit_calculations
= 1U;
11935 else if (strcmp(*argv
, "--calculations-follow-bit-depth") == 0)
11936 pm
.calculations_use_input_precision
=
11937 pm
.assume_16_bit_calculations
= 0;
11939 else if (strcmp(*argv
, "--exhaustive") == 0)
11940 pm
.test_exhaustive
= 1;
11942 else if (argc
> 1 && strcmp(*argv
, "--sbitlow") == 0)
11943 --argc
, pm
.sbitlow
= (png_byte
)atoi(*++argv
), catmore
= 1;
11945 else if (argc
> 1 && strcmp(*argv
, "--touch") == 0)
11946 --argc
, touch
= *++argv
, catmore
= 1;
11948 else if (argc
> 1 && strncmp(*argv
, "--max", 5) == 0)
11952 if (strcmp(5+*argv
, "abs8") == 0)
11953 pm
.maxabs8
= atof(*++argv
);
11955 else if (strcmp(5+*argv
, "abs16") == 0)
11956 pm
.maxabs16
= atof(*++argv
);
11958 else if (strcmp(5+*argv
, "calc8") == 0)
11959 pm
.maxcalc8
= atof(*++argv
);
11961 else if (strcmp(5+*argv
, "calc16") == 0)
11962 pm
.maxcalc16
= atof(*++argv
);
11964 else if (strcmp(5+*argv
, "out8") == 0)
11965 pm
.maxout8
= atof(*++argv
);
11967 else if (strcmp(5+*argv
, "out16") == 0)
11968 pm
.maxout16
= atof(*++argv
);
11970 else if (strcmp(5+*argv
, "pc8") == 0)
11971 pm
.maxpc8
= atof(*++argv
);
11973 else if (strcmp(5+*argv
, "pc16") == 0)
11974 pm
.maxpc16
= atof(*++argv
);
11978 fprintf(stderr
, "pngvalid: %s: unknown 'max' option\n", *argv
);
11985 else if (strcmp(*argv
, "--log8") == 0)
11986 --argc
, pm
.log8
= atof(*++argv
), catmore
= 1;
11988 else if (strcmp(*argv
, "--log16") == 0)
11989 --argc
, pm
.log16
= atof(*++argv
), catmore
= 1;
11991 #ifdef PNG_SET_OPTION_SUPPORTED
11992 else if (strncmp(*argv
, "--option=", 9) == 0)
11994 /* Syntax of the argument is <option>:{on|off} */
11995 const char *arg
= 9+*argv
;
11996 unsigned char option
=0, setting
=0;
11998 #ifdef PNG_ARM_NEON
11999 if (strncmp(arg
, "arm-neon:", 9) == 0)
12000 option
= PNG_ARM_NEON
, arg
+= 9;
12004 #ifdef PNG_EXTENSIONS
12005 if (strncmp(arg
, "extensions:", 11) == 0)
12006 option
= PNG_EXTENSIONS
, arg
+= 11;
12010 #ifdef PNG_MAXIMUM_INFLATE_WINDOW
12011 if (strncmp(arg
, "max-inflate-window:", 19) == 0)
12012 option
= PNG_MAXIMUM_INFLATE_WINDOW
, arg
+= 19;
12017 fprintf(stderr
, "pngvalid: %s: %s: unknown option\n", *argv
, arg
);
12021 if (strcmp(arg
, "off") == 0)
12022 setting
= PNG_OPTION_OFF
;
12024 else if (strcmp(arg
, "on") == 0)
12025 setting
= PNG_OPTION_ON
;
12030 "pngvalid: %s: %s: unknown setting (use 'on' or 'off')\n",
12035 pm
.this.options
[pm
.this.noptions
].option
= option
;
12036 pm
.this.options
[pm
.this.noptions
++].setting
= setting
;
12038 #endif /* PNG_SET_OPTION_SUPPORTED */
12042 fprintf(stderr
, "pngvalid: %s: unknown argument\n", *argv
);
12046 if (catmore
) /* consumed an extra *argv */
12048 cp
= safecat(command
, sizeof command
, cp
, " ");
12049 cp
= safecat(command
, sizeof command
, cp
, *argv
);
12053 /* If pngvalid is run with no arguments default to a reasonable set of the
12056 if (pm
.test_standard
== 0 && pm
.test_size
== 0 && pm
.test_transform
== 0 &&
12057 pm
.ngamma_tests
== 0)
12059 /* Make this do all the tests done in the test shell scripts with the same
12060 * parameters, where possible. The limitation is that all the progressive
12061 * read and interlace stuff has to be done in separate runs, so only the
12062 * basic 'standard' and 'size' tests are done.
12064 pm
.test_standard
= 1;
12066 pm
.test_transform
= 1;
12067 pm
.ngamma_tests
= 2U;
12070 if (pm
.ngamma_tests
> 0 &&
12071 pm
.test_gamma_threshold
== 0 && pm
.test_gamma_transform
== 0 &&
12072 pm
.test_gamma_sbit
== 0 && pm
.test_gamma_scale16
== 0 &&
12073 pm
.test_gamma_background
== 0 && pm
.test_gamma_alpha_mode
== 0)
12075 pm
.test_gamma_threshold
= 1;
12076 pm
.test_gamma_transform
= 1;
12077 pm
.test_gamma_sbit
= 1;
12078 pm
.test_gamma_scale16
= 1;
12079 pm
.test_gamma_background
= 1;
12080 pm
.test_gamma_alpha_mode
= 1;
12083 else if (pm
.ngamma_tests
== 0)
12085 /* Nothing to test so turn everything off: */
12086 pm
.test_gamma_threshold
= 0;
12087 pm
.test_gamma_transform
= 0;
12088 pm
.test_gamma_sbit
= 0;
12089 pm
.test_gamma_scale16
= 0;
12090 pm
.test_gamma_background
= 0;
12091 pm
.test_gamma_alpha_mode
= 0;
12096 /* Make useful base images */
12097 make_transform_images(&pm
);
12099 /* Perform the standard and gamma tests. */
12100 if (pm
.test_standard
)
12102 perform_interlace_macro_validation();
12103 perform_formatting_test(&pm
.this);
12104 # ifdef PNG_READ_SUPPORTED
12105 perform_standard_test(&pm
);
12107 perform_error_test(&pm
);
12110 /* Various oddly sized images: */
12113 make_size_images(&pm
.this);
12114 # ifdef PNG_READ_SUPPORTED
12115 perform_size_test(&pm
);
12119 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
12120 /* Combinatorial transforms: */
12121 if (pm
.test_transform
)
12122 perform_transform_test(&pm
);
12123 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */
12125 #ifdef PNG_READ_GAMMA_SUPPORTED
12126 if (pm
.ngamma_tests
> 0)
12127 perform_gamma_test(&pm
, summary
);
12133 fprintf(stderr
, "pngvalid: test aborted (probably failed in cleanup)\n");
12134 if (!pm
.this.verbose
)
12136 if (pm
.this.error
[0] != 0)
12137 fprintf(stderr
, "pngvalid: first error: %s\n", pm
.this.error
);
12139 fprintf(stderr
, "pngvalid: run with -v to see what happened\n");
12146 printf("%s: %s (%s point arithmetic)\n",
12147 (pm
.this.nerrors
|| (pm
.this.treat_warnings_as_errors
&&
12148 pm
.this.nwarnings
)) ? "FAIL" : "PASS",
12150 #if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || PNG_LIBPNG_VER < 10500
12160 printf("Allocated memory statistics (in bytes):\n"
12161 "\tread %lu maximum single, %lu peak, %lu total\n"
12162 "\twrite %lu maximum single, %lu peak, %lu total\n",
12163 (unsigned long)pm
.this.read_memory_pool
.max_max
,
12164 (unsigned long)pm
.this.read_memory_pool
.max_limit
,
12165 (unsigned long)pm
.this.read_memory_pool
.max_total
,
12166 (unsigned long)pm
.this.write_memory_pool
.max_max
,
12167 (unsigned long)pm
.this.write_memory_pool
.max_limit
,
12168 (unsigned long)pm
.this.write_memory_pool
.max_total
);
12171 /* Do this here to provoke memory corruption errors in memory not directly
12172 * allocated by libpng - not a complete test, but better than nothing.
12174 store_delete(&pm
.this);
12176 /* Error exit if there are any errors, and maybe if there are any
12179 if (pm
.this.nerrors
|| (pm
.this.treat_warnings_as_errors
&&
12180 pm
.this.nwarnings
))
12182 if (!pm
.this.verbose
)
12183 fprintf(stderr
, "pngvalid: %s\n", pm
.this.error
);
12185 fprintf(stderr
, "pngvalid: %d errors, %d warnings\n", pm
.this.nerrors
,
12186 pm
.this.nwarnings
);
12191 /* Success case. */
12194 FILE *fsuccess
= fopen(touch
, "wt");
12196 if (fsuccess
!= NULL
)
12199 fprintf(fsuccess
, "PNG validation succeeded\n");
12201 error
= ferror(fsuccess
);
12203 if (fclose(fsuccess
) || error
)
12205 fprintf(stderr
, "%s: write failed\n", touch
);
12212 fprintf(stderr
, "%s: open failed\n", touch
);
12217 /* This is required because some very minimal configurations do not use it:
12222 #else /* write or low level APIs not supported */
12226 "pngvalid: no low level write support in libpng, all tests skipped\n");
12227 /* So the test is skipped: */