openshot-audio  0.1.6
pngpriv.h
Go to the documentation of this file.
1 
2 /* pngpriv.h - private declarations for use inside libpng
3  *
4  * For conditions of distribution and use, see copyright notice in png.h
5  * Copyright (c) 1998-2013 Glenn Randers-Pehrson
6  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
8  *
9  * Last changed in libpng 1.6.1 [March 28, 2013]
10  *
11  * This code is released under the libpng license.
12  * For conditions of distribution and use, see the disclaimer
13  * and license in png.h
14  */
15 
16 /* The symbols declared in this file (including the functions declared
17  * as extern) are PRIVATE. They are not part of the libpng public
18  * interface, and are not recommended for use by regular applications.
19  * Some of them may become public in the future; others may stay private,
20  * change in an incompatible way, or even disappear.
21  * Although the libpng users are not forbidden to include this header,
22  * they should be well aware of the issues that may arise from doing so.
23  */
24 
25 #ifndef PNGPRIV_H
26 #define PNGPRIV_H
27 
28 /* Feature Test Macros. The following are defined here to ensure that correctly
29  * implemented libraries reveal the APIs libpng needs to build and hide those
30  * that are not needed and potentially damaging to the compilation.
31  *
32  * Feature Test Macros must be defined before any system header is included (see
33  * POSIX 1003.1 2.8.2 "POSIX Symbols."
34  *
35  * These macros only have an effect if the operating system supports either
36  * POSIX 1003.1 or C99, or both. On other operating systems (particularly
37  * Windows/Visual Studio) there is no effect; the OS specific tests below are
38  * still required (as of 2011-05-02.)
39  */
40 #define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */
41 
42 #ifndef PNG_VERSION_INFO_ONLY
43 /* Standard library headers not required by png.h: */
44 # include <stdlib.h>
45 # include <string.h>
46 #endif
47 
48 #define PNGLIB_BUILD /*libpng is being built, not used*/
49 
50 /* If HAVE_CONFIG_H is defined during the build then the build system must
51  * provide an appropriate "config.h" file on the include path. The header file
52  * must provide definitions as required below (search for "HAVE_CONFIG_H");
53  * see configure.ac for more details of the requirements. The macro
54  * "PNG_NO_CONFIG_H" is provided for maintainers to test for dependencies on
55  * 'configure'; define this macro to prevent the configure build including the
56  * configure generated config.h. Libpng is expected to compile without *any*
57  * special build system support on a reasonably ANSI-C compliant system.
58  */
59 #if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
60 # include <config.h>
61 
62  /* Pick up the definition of 'restrict' from config.h if it was read: */
63 # define PNG_RESTRICT restrict
64 #endif
65 
66 /* To support symbol prefixing it is necessary to know *before* including png.h
67  * whether the fixed point (and maybe other) APIs are exported, because if they
68  * are not internal definitions may be required. This is handled below just
69  * before png.h is included, but load the configuration now if it is available.
70  */
71 #ifndef PNGLCONF_H
72 # include "pnglibconf.h"
73 #endif
74 
75 /* Local renames may change non-exported API functions from png.h */
76 #if defined(PNG_PREFIX) && !defined(PNGPREFIX_H)
77 # include "pngprefix.h"
78 #endif
79 
80 #ifdef PNG_USER_CONFIG
81 # include "pngusr.h"
82  /* These should have been defined in pngusr.h */
83 # ifndef PNG_USER_PRIVATEBUILD
84 # define PNG_USER_PRIVATEBUILD "Custom libpng build"
85 # endif
86 # ifndef PNG_USER_DLLFNAME_POSTFIX
87 # define PNG_USER_DLLFNAME_POSTFIX "Cb"
88 # endif
89 #endif
90 
91 /* Is this a build of a DLL where compilation of the object modules requires
92  * different preprocessor settings to those required for a simple library? If
93  * so PNG_BUILD_DLL must be set.
94  *
95  * If libpng is used inside a DLL but that DLL does not export the libpng APIs
96  * PNG_BUILD_DLL must not be set. To avoid the code below kicking in build a
97  * static library of libpng then link the DLL against that.
98  */
99 #ifndef PNG_BUILD_DLL
100 # ifdef DLL_EXPORT
101  /* This is set by libtool when files are compiled for a DLL; libtool
102  * always compiles twice, even on systems where it isn't necessary. Set
103  * PNG_BUILD_DLL in case it is necessary:
104  */
105 # define PNG_BUILD_DLL
106 # else
107 # ifdef _WINDLL
108  /* This is set by the Microsoft Visual Studio IDE in projects that
109  * build a DLL. It can't easily be removed from those projects (it
110  * isn't visible in the Visual Studio UI) so it is a fairly reliable
111  * indication that PNG_IMPEXP needs to be set to the DLL export
112  * attributes.
113  */
114 # define PNG_BUILD_DLL
115 # else
116 # ifdef __DLL__
117  /* This is set by the Borland C system when compiling for a DLL
118  * (as above.)
119  */
120 # define PNG_BUILD_DLL
121 # else
122  /* Add additional compiler cases here. */
123 # endif
124 # endif
125 # endif
126 #endif /* Setting PNG_BUILD_DLL if required */
127 
128 /* See pngconf.h for more details: the builder of the library may set this on
129  * the command line to the right thing for the specific compilation system or it
130  * may be automagically set above (at present we know of no system where it does
131  * need to be set on the command line.)
132  *
133  * PNG_IMPEXP must be set here when building the library to prevent pngconf.h
134  * setting it to the "import" setting for a DLL build.
135  */
136 #ifndef PNG_IMPEXP
137 # ifdef PNG_BUILD_DLL
138 # define PNG_IMPEXP PNG_DLL_EXPORT
139 # else
140  /* Not building a DLL, or the DLL doesn't require specific export
141  * definitions.
142  */
143 # define PNG_IMPEXP
144 # endif
145 #endif
146 
147 /* No warnings for private or deprecated functions in the build: */
148 #ifndef PNG_DEPRECATED
149 # define PNG_DEPRECATED
150 #endif
151 #ifndef PNG_PRIVATE
152 # define PNG_PRIVATE
153 #endif
154 
155 /* Symbol preprocessing support.
156  *
157  * To enable listing global, but internal, symbols the following macros should
158  * always be used to declare an extern data or function object in this file.
159  */
160 #ifndef PNG_INTERNAL_DATA
161 # define PNG_INTERNAL_DATA(type, name, array) extern type name array
162 #endif
163 
164 #ifndef PNG_INTERNAL_FUNCTION
165 # define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\
166  extern PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)
167 #endif
168 
169 /* If floating or fixed point APIs are disabled they may still be compiled
170  * internally. To handle this make sure they are declared as the appropriate
171  * internal extern function (otherwise the symbol prefixing stuff won't work and
172  * the functions will be used without definitions.)
173  *
174  * NOTE: although all the API functions are declared here they are not all
175  * actually built! Because the declarations are still made it is necessary to
176  * fake out types that they depend on.
177  */
178 #ifndef PNG_FP_EXPORT
179 # ifndef PNG_FLOATING_POINT_SUPPORTED
180 # define PNG_FP_EXPORT(ordinal, type, name, args)\
181  PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
182 # ifndef PNG_VERSION_INFO_ONLY
183  typedef struct png_incomplete png_double;
187 # endif
188 # endif
189 #endif
190 #ifndef PNG_FIXED_EXPORT
191 # ifndef PNG_FIXED_POINT_SUPPORTED
192 # define PNG_FIXED_EXPORT(ordinal, type, name, args)\
193  PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
194 # endif
195 #endif
196 
197 #include "png.h"
198 
199 /* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */
200 #ifndef PNG_DLL_EXPORT
201 # define PNG_DLL_EXPORT
202 #endif
203 
204 /* SECURITY and SAFETY:
205  *
206  * By default libpng is built without any internal limits on image size,
207  * individual heap (png_malloc) allocations or the total amount of memory used.
208  * If PNG_SAFE_LIMITS_SUPPORTED is defined, however, the limits below are used
209  * (unless individually overridden). These limits are believed to be fairly
210  * safe, but builders of secure systems should verify the values against the
211  * real system capabilities.
212  */
213 #ifdef PNG_SAFE_LIMITS_SUPPORTED
214  /* 'safe' limits */
215 # ifndef PNG_USER_WIDTH_MAX
216 # define PNG_USER_WIDTH_MAX 1000000
217 # endif
218 # ifndef PNG_USER_HEIGHT_MAX
219 # define PNG_USER_HEIGHT_MAX 1000000
220 # endif
221 # ifndef PNG_USER_CHUNK_CACHE_MAX
222 # define PNG_USER_CHUNK_CACHE_MAX 128
223 # endif
224 # ifndef PNG_USER_CHUNK_MALLOC_MAX
225 # define PNG_USER_CHUNK_MALLOC_MAX 8000000
226 # endif
227 #else
228  /* values for no limits */
229 # ifndef PNG_USER_WIDTH_MAX
230 # define PNG_USER_WIDTH_MAX 0x7fffffff
231 # endif
232 # ifndef PNG_USER_HEIGHT_MAX
233 # define PNG_USER_HEIGHT_MAX 0x7fffffff
234 # endif
235 # ifndef PNG_USER_CHUNK_CACHE_MAX
236 # define PNG_USER_CHUNK_CACHE_MAX 0
237 # endif
238 # ifndef PNG_USER_CHUNK_MALLOC_MAX
239 # define PNG_USER_CHUNK_MALLOC_MAX 0
240 # endif
241 #endif
242 
243 /* Moved to pngpriv.h at libpng-1.5.0 */
244 /* NOTE: some of these may have been used in external applications as
245  * these definitions were exposed in pngconf.h prior to 1.5.
246  */
247 
248 /* If you are running on a machine where you cannot allocate more
249  * than 64K of memory at once, uncomment this. While libpng will not
250  * normally need that much memory in a chunk (unless you load up a very
251  * large file), zlib needs to know how big of a chunk it can use, and
252  * libpng thus makes sure to check any memory allocation to verify it
253  * will fit into memory.
254  *
255  * zlib provides 'MAXSEG_64K' which, if defined, indicates the
256  * same limit and pngconf.h (already included) sets the limit
257  * if certain operating systems are detected.
258  */
259 #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
260 # define PNG_MAX_MALLOC_64K
261 #endif
262 
263 #ifndef PNG_UNUSED
264 /* Unused formal parameter warnings are silenced using the following macro
265  * which is expected to have no bad effects on performance (optimizing
266  * compilers will probably remove it entirely). Note that if you replace
267  * it with something other than whitespace, you must include the terminating
268  * semicolon.
269  */
270 # define PNG_UNUSED(param) (void)param;
271 #endif
272 
273 /* Just a little check that someone hasn't tried to define something
274  * contradictory.
275  */
276 #if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)
277 # undef PNG_ZBUF_SIZE
278 # define PNG_ZBUF_SIZE 65536L
279 #endif
280 
281 /* If warnings or errors are turned off the code is disabled or redirected here.
282  * From 1.5.4 functions have been added to allow very limited formatting of
283  * error and warning messages - this code will also be disabled here.
284  */
285 #ifdef PNG_WARNINGS_SUPPORTED
286 # define PNG_WARNING_PARAMETERS(p) png_warning_parameters p;
287 #else
288 # define png_warning(s1,s2) ((void)(s1))
289 # define png_chunk_warning(s1,s2) ((void)(s1))
290 # define png_warning_parameter(p,number,string) ((void)0)
291 # define png_warning_parameter_unsigned(p,number,format,value) ((void)0)
292 # define png_warning_parameter_signed(p,number,format,value) ((void)0)
293 # define png_formatted_warning(pp,p,message) ((void)(pp))
294 # define PNG_WARNING_PARAMETERS(p)
295 #endif
296 #ifndef PNG_ERROR_TEXT_SUPPORTED
297 # define png_error(s1,s2) png_err(s1)
298 # define png_chunk_error(s1,s2) png_err(s1)
299 # define png_fixed_error(s1,s2) png_err(s1)
300 #endif
301 
302 /* C allows up-casts from (void*) to any pointer and (const void*) to any
303  * pointer to a const object. C++ regards this as a type error and requires an
304  * explicit, static, cast and provides the static_cast<> rune to ensure that
305  * const is not cast away.
306  */
307 #ifdef __cplusplus
308 # define png_voidcast(type, value) static_cast<type>(value)
309 # define png_constcast(type, value) const_cast<type>(value)
310 # define png_aligncast(type, value) \
311  static_cast<type>(static_cast<void*>(value))
312 # define png_aligncastconst(type, value) \
313  static_cast<type>(static_cast<const void*>(value))
314 #else
315 # define png_voidcast(type, value) (value)
316 # define png_constcast(type, value) ((type)(value))
317 # define png_aligncast(type, value) ((void*)(value))
318 # define png_aligncastconst(type, value) ((const void*)(value))
319 #endif /* __cplusplus */
320 
321 /* Some fixed point APIs are still required even if not exported because
322  * they get used by the corresponding floating point APIs. This magic
323  * deals with this:
324  */
325 #ifdef PNG_FIXED_POINT_SUPPORTED
326 # define PNGFAPI PNGAPI
327 #else
328 # define PNGFAPI /* PRIVATE */
329 #endif
330 
331 #ifndef PNG_VERSION_INFO_ONLY
332 /* Other defines specific to compilers can go here. Try to keep
333  * them inside an appropriate ifdef/endif pair for portability.
334  */
335 #if defined(PNG_FLOATING_POINT_SUPPORTED) ||\
336  defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
337  /* png.c requires the following ANSI-C constants if the conversion of
338  * floating point to ASCII is implemented therein:
339  *
340  * DBL_DIG Maximum number of decimal digits (can be set to any constant)
341  * DBL_MIN Smallest normalized fp number (can be set to an arbitrary value)
342  * DBL_MAX Maximum floating point number (can be set to an arbitrary value)
343  */
344 # include <float.h>
345 
346 # if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
347  defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
348  /* We need to check that <math.h> hasn't already been included earlier
349  * as it seems it doesn't agree with <fp.h>, yet we should really use
350  * <fp.h> if possible.
351  */
352 # if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
353 # include <fp.h>
354 # endif
355 # else
356 # include <math.h>
357 # endif
358 # if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
359  /* Amiga SAS/C: We must include builtin FPU functions when compiling using
360  * MATH=68881
361  */
362 # include <m68881.h>
363 # endif
364 #endif
365 
366 /* This provides the non-ANSI (far) memory allocation routines. */
367 #if defined(__TURBOC__) && defined(__MSDOS__)
368 # include <mem.h>
369 # include <alloc.h>
370 #endif
371 
372 #if defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \
373  defined(_WIN32) || defined(__WIN32__)
374 # include <windows.h> /* defines _WINDOWS_ macro */
375 #endif
376 #endif /* PNG_VERSION_INFO_ONLY */
377 
378 /* Moved here around 1.5.0beta36 from pngconf.h */
379 /* Users may want to use these so they are not private. Any library
380  * functions that are passed far data must be model-independent.
381  */
382 
383 /* Memory model/platform independent fns */
384 #ifndef PNG_ABORT
385 # ifdef _WINDOWS_
386 # define PNG_ABORT() ExitProcess(0)
387 # else
388 # define PNG_ABORT() abort()
389 # endif
390 #endif
391 
392 /* These macros may need to be architecture dependent. */
393 #define PNG_ALIGN_NONE 0 /* do not use data alignment */
394 #define PNG_ALIGN_ALWAYS 1 /* assume unaligned accesses are OK */
395 #ifdef offsetof
396 # define PNG_ALIGN_OFFSET 2 /* use offsetof to determine alignment */
397 #else
398 # define PNG_ALIGN_OFFSET -1 /* prevent the use of this */
399 #endif
400 #define PNG_ALIGN_SIZE 3 /* use sizeof to determine alignment */
401 
402 #ifndef PNG_ALIGN_TYPE
403  /* Default to using aligned access optimizations and requiring alignment to a
404  * multiple of the data type size. Override in a compiler specific fashion
405  * if necessary by inserting tests here:
406  */
407 # define PNG_ALIGN_TYPE PNG_ALIGN_SIZE
408 #endif
409 
410 #if PNG_ALIGN_TYPE == PNG_ALIGN_SIZE
411  /* This is used because in some compiler implementations non-aligned
412  * structure members are supported, so the offsetof approach below fails.
413  * Set PNG_ALIGN_SIZE=0 for compiler combinations where unaligned access
414  * is good for performance. Do not do this unless you have tested the result
415  * and understand it.
416  */
417 # define png_alignof(type) (sizeof (type))
418 #else
419 # if PNG_ALIGN_TYPE == PNG_ALIGN_OFFSET
420 # define png_alignof(type) offsetof(struct{char c; type t;}, t)
421 # else
422 # if PNG_ALIGN_TYPE == PNG_ALIGN_ALWAYS
423 # define png_alignof(type) (1)
424 # endif
425  /* Else leave png_alignof undefined to prevent use thereof */
426 # endif
427 #endif
428 
429 /* This implicitly assumes alignment is always to a power of 2. */
430 #ifdef png_alignof
431 # define png_isaligned(ptr, type)\
432  ((((const char*)ptr-(const char*)0) & (png_alignof(type)-1)) == 0)
433 #else
434 # define png_isaligned(ptr, type) 0
435 #endif
436 
437 /* End of memory model/platform independent support */
438 /* End of 1.5.0beta36 move from pngconf.h */
439 
440 /* CONSTANTS and UTILITY MACROS
441  * These are used internally by libpng and not exposed in the API
442  */
443 
444 /* Various modes of operation. Note that after an init, mode is set to
445  * zero automatically when the structure is created. Three of these
446  * are defined in png.h because they need to be visible to applications
447  * that call png_set_unknown_chunk().
448  */
449 /* #define PNG_HAVE_IHDR 0x01 (defined in png.h) */
450 /* #define PNG_HAVE_PLTE 0x02 (defined in png.h) */
451 #define PNG_HAVE_IDAT 0x04
452 /* #define PNG_AFTER_IDAT 0x08 (defined in png.h) */
453 #define PNG_HAVE_IEND 0x10
454  /* 0x20 (unused) */
455  /* 0x40 (unused) */
456  /* 0x80 (unused) */
457 #define PNG_HAVE_CHUNK_HEADER 0x100
458 #define PNG_WROTE_tIME 0x200
459 #define PNG_WROTE_INFO_BEFORE_PLTE 0x400
460 #define PNG_BACKGROUND_IS_GRAY 0x800
461 #define PNG_HAVE_PNG_SIGNATURE 0x1000
462 #define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */
463  /* 0x4000 (unused) */
464 #define PNG_IS_READ_STRUCT 0x8000 /* Else is a write struct */
465 
466 /* Flags for the transformations the PNG library does on the image data */
467 #define PNG_BGR 0x0001
468 #define PNG_INTERLACE 0x0002
469 #define PNG_PACK 0x0004
470 #define PNG_SHIFT 0x0008
471 #define PNG_SWAP_BYTES 0x0010
472 #define PNG_INVERT_MONO 0x0020
473 #define PNG_QUANTIZE 0x0040
474 #define PNG_COMPOSE 0x0080 /* Was PNG_BACKGROUND */
475 #define PNG_BACKGROUND_EXPAND 0x0100
476 #define PNG_EXPAND_16 0x0200 /* Added to libpng 1.5.2 */
477 #define PNG_16_TO_8 0x0400 /* Becomes 'chop' in 1.5.4 */
478 #define PNG_RGBA 0x0800
479 #define PNG_EXPAND 0x1000
480 #define PNG_GAMMA 0x2000
481 #define PNG_GRAY_TO_RGB 0x4000
482 #define PNG_FILLER 0x8000
483 #define PNG_PACKSWAP 0x10000
484 #define PNG_SWAP_ALPHA 0x20000
485 #define PNG_STRIP_ALPHA 0x40000
486 #define PNG_INVERT_ALPHA 0x80000
487 #define PNG_USER_TRANSFORM 0x100000
488 #define PNG_RGB_TO_GRAY_ERR 0x200000
489 #define PNG_RGB_TO_GRAY_WARN 0x400000
490 #define PNG_RGB_TO_GRAY 0x600000 /* two bits, RGB_TO_GRAY_ERR|WARN */
491 #define PNG_ENCODE_ALPHA 0x800000 /* Added to libpng-1.5.4 */
492 #define PNG_ADD_ALPHA 0x1000000 /* Added to libpng-1.2.7 */
493 #define PNG_EXPAND_tRNS 0x2000000 /* Added to libpng-1.2.9 */
494 #define PNG_SCALE_16_TO_8 0x4000000 /* Added to libpng-1.5.4 */
495  /* 0x8000000 unused */
496  /* 0x10000000 unused */
497  /* 0x20000000 unused */
498  /* 0x40000000 unused */
499 /* Flags for png_create_struct */
500 #define PNG_STRUCT_PNG 0x0001
501 #define PNG_STRUCT_INFO 0x0002
502 
503 /* Scaling factor for filter heuristic weighting calculations */
504 #define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))
505 #define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))
506 
507 /* Flags for the png_ptr->flags rather than declaring a byte for each one */
508 #define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001
509 #define PNG_FLAG_ZSTREAM_INITIALIZED 0x0002 /* Added to libpng-1.6.0 */
510  /* 0x0004 unused */
511 #define PNG_FLAG_ZSTREAM_ENDED 0x0008 /* Added to libpng-1.6.0 */
512  /* 0x0010 unused */
513  /* 0x0020 unused */
514 #define PNG_FLAG_ROW_INIT 0x0040
515 #define PNG_FLAG_FILLER_AFTER 0x0080
516 #define PNG_FLAG_CRC_ANCILLARY_USE 0x0100
517 #define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200
518 #define PNG_FLAG_CRC_CRITICAL_USE 0x0400
519 #define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800
520 #define PNG_FLAG_ASSUME_sRGB 0x1000 /* Added to libpng-1.5.4 */
521 #define PNG_FLAG_OPTIMIZE_ALPHA 0x2000 /* Added to libpng-1.5.4 */
522 #define PNG_FLAG_DETECT_UNINITIALIZED 0x4000 /* Added to libpng-1.5.4 */
523 /* #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000 */
524 /* #define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000 */
525 #define PNG_FLAG_LIBRARY_MISMATCH 0x20000
526 #define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000
527 #define PNG_FLAG_STRIP_ERROR_TEXT 0x80000
528 #define PNG_FLAG_BENIGN_ERRORS_WARN 0x100000 /* Added to libpng-1.4.0 */
529 #define PNG_FLAG_APP_WARNINGS_WARN 0x200000 /* Added to libpng-1.6.0 */
530 #define PNG_FLAG_APP_ERRORS_WARN 0x400000 /* Added to libpng-1.6.0 */
531  /* 0x800000 unused */
532  /* 0x1000000 unused */
533  /* 0x2000000 unused */
534  /* 0x4000000 unused */
535  /* 0x8000000 unused */
536  /* 0x10000000 unused */
537  /* 0x20000000 unused */
538  /* 0x40000000 unused */
539 
540 #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
541  PNG_FLAG_CRC_ANCILLARY_NOWARN)
542 
543 #define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \
544  PNG_FLAG_CRC_CRITICAL_IGNORE)
545 
546 #define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \
547  PNG_FLAG_CRC_CRITICAL_MASK)
548 
549 /* Save typing and make code easier to understand */
550 
551 #define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
552  abs((int)((c1).green) - (int)((c2).green)) + \
553  abs((int)((c1).blue) - (int)((c2).blue)))
554 
555 /* Added to libpng-1.6.0: scale a 16-bit value in the range 0..65535 to 0..255
556  * by dividing by 257 *with rounding*. This macro is exact for the given range.
557  * See the discourse in pngrtran.c png_do_scale_16_to_8. The values in the
558  * macro were established by experiment (modifying the added value). The macro
559  * has a second variant that takes a value already scaled by 255 and divides by
560  * 65535 - this has a maximum error of .502. Over the range 0..65535*65535 it
561  * only gives off-by-one errors and only for 0.5% (1 in 200) of the values.
562  */
563 #define PNG_DIV65535(v24) (((v24) + 32895) >> 16)
564 #define PNG_DIV257(v16) PNG_DIV65535((png_uint_32)(v16) * 255)
565 
566 /* Added to libpng-1.2.6 JB */
567 #define PNG_ROWBYTES(pixel_bits, width) \
568  ((pixel_bits) >= 8 ? \
569  ((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \
570  (( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) )
571 
572 /* PNG_OUT_OF_RANGE returns true if value is outside the range
573  * ideal-delta..ideal+delta. Each argument is evaluated twice.
574  * "ideal" and "delta" should be constants, normally simple
575  * integers, "value" a variable. Added to libpng-1.2.6 JB
576  */
577 #define PNG_OUT_OF_RANGE(value, ideal, delta) \
578  ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )
579 
580 /* Conversions between fixed and floating point, only defined if
581  * required (to make sure the code doesn't accidentally use float
582  * when it is supposedly disabled.)
583  */
584 #ifdef PNG_FLOATING_POINT_SUPPORTED
585 /* The floating point conversion can't overflow, though it can and
586  * does lose accuracy relative to the original fixed point value.
587  * In practice this doesn't matter because png_fixed_point only
588  * stores numbers with very low precision. The png_ptr and s
589  * arguments are unused by default but are there in case error
590  * checking becomes a requirement.
591  */
592 #define png_float(png_ptr, fixed, s) (.00001 * (fixed))
593 
594 /* The fixed point conversion performs range checking and evaluates
595  * its argument multiple times, so must be used with care. The
596  * range checking uses the PNG specification values for a signed
597  * 32 bit fixed point value except that the values are deliberately
598  * rounded-to-zero to an integral value - 21474 (21474.83 is roughly
599  * (2^31-1) * 100000). 's' is a string that describes the value being
600  * converted.
601  *
602  * NOTE: this macro will raise a png_error if the range check fails,
603  * therefore it is normally only appropriate to use this on values
604  * that come from API calls or other sources where an out of range
605  * error indicates a programming error, not a data error!
606  *
607  * NOTE: by default this is off - the macro is not used - because the
608  * function call saves a lot of code.
609  */
610 #ifdef PNG_FIXED_POINT_MACRO_SUPPORTED
611 #define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\
612  ((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0))
613 #endif
614 /* else the corresponding function is defined below, inside the scope of the
615  * cplusplus test.
616  */
617 #endif
618 
619 /* Constants for known chunk types. If you need to add a chunk, define the name
620  * here. For historical reasons these constants have the form png_<name>; i.e.
621  * the prefix is lower case. Please use decimal values as the parameters to
622  * match the ISO PNG specification and to avoid relying on the C locale
623  * interpretation of character values.
624  *
625  * Prior to 1.5.6 these constants were strings, as of 1.5.6 png_uint_32 values
626  * are computed and a new macro (PNG_STRING_FROM_CHUNK) added to allow a string
627  * to be generated if required.
628  *
629  * PNG_32b correctly produces a value shifted by up to 24 bits, even on
630  * architectures where (int) is only 16 bits.
631  */
632 #define PNG_32b(b,s) ((png_uint_32)(b) << (s))
633 #define PNG_CHUNK(b1,b2,b3,b4) \
634  (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0))
635 
636 #define png_IHDR PNG_CHUNK( 73, 72, 68, 82)
637 #define png_IDAT PNG_CHUNK( 73, 68, 65, 84)
638 #define png_IEND PNG_CHUNK( 73, 69, 78, 68)
639 #define png_PLTE PNG_CHUNK( 80, 76, 84, 69)
640 #define png_bKGD PNG_CHUNK( 98, 75, 71, 68)
641 #define png_cHRM PNG_CHUNK( 99, 72, 82, 77)
642 #define png_gAMA PNG_CHUNK(103, 65, 77, 65)
643 #define png_hIST PNG_CHUNK(104, 73, 83, 84)
644 #define png_iCCP PNG_CHUNK(105, 67, 67, 80)
645 #define png_iTXt PNG_CHUNK(105, 84, 88, 116)
646 #define png_oFFs PNG_CHUNK(111, 70, 70, 115)
647 #define png_pCAL PNG_CHUNK(112, 67, 65, 76)
648 #define png_sCAL PNG_CHUNK(115, 67, 65, 76)
649 #define png_pHYs PNG_CHUNK(112, 72, 89, 115)
650 #define png_sBIT PNG_CHUNK(115, 66, 73, 84)
651 #define png_sPLT PNG_CHUNK(115, 80, 76, 84)
652 #define png_sRGB PNG_CHUNK(115, 82, 71, 66)
653 #define png_sTER PNG_CHUNK(115, 84, 69, 82)
654 #define png_tEXt PNG_CHUNK(116, 69, 88, 116)
655 #define png_tIME PNG_CHUNK(116, 73, 77, 69)
656 #define png_tRNS PNG_CHUNK(116, 82, 78, 83)
657 #define png_zTXt PNG_CHUNK(122, 84, 88, 116)
658 
659 /* The following will work on (signed char*) strings, whereas the get_uint_32
660  * macro will fail on top-bit-set values because of the sign extension.
661  */
662 #define PNG_CHUNK_FROM_STRING(s)\
663  PNG_CHUNK(0xff&(s)[0], 0xff&(s)[1], 0xff&(s)[2], 0xff&(s)[3])
664 
665 /* This uses (char), not (png_byte) to avoid warnings on systems where (char) is
666  * signed and the argument is a (char[]) This macro will fail miserably on
667  * systems where (char) is more than 8 bits.
668  */
669 #define PNG_STRING_FROM_CHUNK(s,c)\
670  (void)(((char*)(s))[0]=(char)((c)>>24), ((char*)(s))[1]=(char)((c)>>16),\
671  ((char*)(s))[2]=(char)((c)>>8), ((char*)(s))[3]=(char)((c)))
672 
673 /* Do the same but terminate with a null character. */
674 #define PNG_CSTRING_FROM_CHUNK(s,c)\
675  (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0)
676 
677 /* Test on flag values as defined in the spec (section 5.4): */
678 #define PNG_CHUNK_ANCILLIARY(c) (1 & ((c) >> 29))
679 #define PNG_CHUNK_CRITICAL(c) (!PNG_CHUNK_ANCILLIARY(c))
680 #define PNG_CHUNK_PRIVATE(c) (1 & ((c) >> 21))
681 #define PNG_CHUNK_RESERVED(c) (1 & ((c) >> 13))
682 #define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >> 5))
683 
684 /* Gamma values (new at libpng-1.5.4): */
685 #define PNG_GAMMA_MAC_OLD 151724 /* Assume '1.8' is really 2.2/1.45! */
686 #define PNG_GAMMA_MAC_INVERSE 65909
687 #define PNG_GAMMA_sRGB_INVERSE 45455
688 
689 /* Almost everything below is C specific; the #defines above can be used in
690  * non-C code (so long as it is C-preprocessed) the rest of this stuff cannot.
691  */
692 #ifndef PNG_VERSION_INFO_ONLY
693 
694 #include "pngstruct.h"
695 #include "pnginfo.h"
696 
697 /* This is used for 16 bit gamma tables -- only the top level pointers are
698  * const; this could be changed:
699  */
701 
702 /* Added to libpng-1.5.7: sRGB conversion tables */
703 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
704  defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
705 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
706 PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_table, [256]);
707  /* Convert from an sRGB encoded value 0..255 to a 16-bit linear value,
708  * 0..65535. This table gives the closest 16-bit answers (no errors).
709  */
710 #endif
711 
712 PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_base, [512]);
713 PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]);
714 
715 #define PNG_sRGB_FROM_LINEAR(linear) ((png_byte)((png_sRGB_base[(linear)>>15] +\
716  ((((linear)&0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8))
717  /* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB
718  * encoded value with maximum error 0.646365. Note that the input is not a
719  * 16-bit value; it has been multiplied by 255! */
720 #endif /* PNG_SIMPLIFIED_READ/WRITE */
721 
722 
723 /* Internal functions; these are not exported from a DLL however because they
724  * are used within several of the C source files they have to be C extern.
725  *
726  * All of these functions must be declared with PNG_INTERNAL_FUNCTION.
727  */
728 
729 /* Zlib support */
730 #define PNG_UNEXPECTED_ZLIB_RETURN (-7)
732  PNG_EMPTY);
733  /* Used by the zlib handling functions to ensure that z_stream::msg is always
734  * set before they return.
735  */
736 
737 #ifdef PNG_WRITE_SUPPORTED
740  /* Free the buffer list used by the compressed write code. */
741 #endif
742 
743 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
744  !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
745  (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
746  defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
747  defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
748  (defined(PNG_sCAL_SUPPORTED) && \
749  defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))
751  double fp, png_const_charp text),PNG_EMPTY);
752 #endif
753 
754 /* Check the user version string for compatibility, returns false if the version
755  * numbers aren't compatible.
756  */
758  png_const_charp user_png_ver),PNG_EMPTY);
759 
760 /* Internal base allocator - no messages, NULL on failure to allocate. This
761  * does, however, call the application provided allocator and that could call
762  * png_error (although that would be a bug in the application implementation.)
763  */
766 
767 #if defined(PNG_TEXT_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) ||\
768  defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED)
769 /* Internal array allocator, outputs no error or warning messages on failure,
770  * just returns NULL.
771  */
773  int nelements, size_t element_size),PNG_ALLOCATED);
774 
775 /* The same but an existing array is extended by add_elements. This function
776  * also memsets the new elements to 0 and copies the old elements. The old
777  * array is not freed or altered.
778  */
780  png_const_voidp array, int old_elements, int add_elements,
781  size_t element_size),PNG_ALLOCATED);
782 #endif /* text, sPLT or unknown chunks */
783 
784 /* Magic to create a struct when there is no struct to call the user supplied
785  * memory allocators. Because error handling has not been set up the memory
786  * handlers can't safely call png_error, but this is an obscure and undocumented
787  * restriction so libpng has to assume that the 'free' handler, at least, might
788  * call png_error.
789  */
790 PNG_INTERNAL_FUNCTION(png_structp,png_create_png_struct,
791  (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
792  png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn,
793  png_free_ptr free_fn),PNG_ALLOCATED);
794 
795 /* Free memory from internal libpng struct */
797  PNG_EMPTY);
798 
799 /* Free an allocated jmp_buf (always succeeds) */
800 PNG_INTERNAL_FUNCTION(void,png_free_jmpbuf,(png_structrp png_ptr),PNG_EMPTY);
801 
802 /* Function to allocate memory for zlib. PNGAPI is disallowed. */
803 PNG_INTERNAL_FUNCTION(voidpf,png_zalloc,(voidpf png_ptr, uInt items, uInt size),
804  PNG_ALLOCATED);
805 
806 /* Function to free memory for zlib. PNGAPI is disallowed. */
808 
809 /* Next four functions are used internally as callbacks. PNGCBAPI is required
810  * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3, changed to
811  * PNGCBAPI at 1.5.0
812  */
813 
816 
817 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
820 #endif
821 
824 
825 #ifdef PNG_WRITE_FLUSH_SUPPORTED
826 # ifdef PNG_STDIO_SUPPORTED
828  PNG_EMPTY);
829 # endif
830 #endif
831 
832 /* Reset the CRC variable */
834 
835 /* Write the "data" buffer to whatever output you are using */
838 
839 /* Read and check the PNG file signature */
842 
843 /* Read the chunk header (length + type name) */
845  PNG_EMPTY);
846 
847 /* Read data from whatever input you are using into the "data" buffer */
850 
851 /* Read bytes into buf, and update png_ptr->crc */
854 
855 /* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
857  png_uint_32 skip),PNG_EMPTY);
858 
859 /* Read the CRC from the file and compare it to the libpng calculated CRC */
861 
862 /* Calculate the CRC over a section of data. Note that we are only
863  * passing a maximum of 64K on systems that have this as a memory limit,
864  * since this is the maximum buffer size we can specify.
865  */
868 
869 #ifdef PNG_WRITE_FLUSH_SUPPORTED
871 #endif
872 
873 /* Write various chunks */
874 
875 /* Write the IHDR chunk, and update the png_struct with the necessary
876  * information.
877  */
879  png_uint_32 width, png_uint_32 height, int bit_depth, int color_type,
880  int compression_method, int filter_method, int interlace_method),PNG_EMPTY);
881 
883  png_const_colorp palette, png_uint_32 num_pal),PNG_EMPTY);
884 
886  png_const_bytep row_data, png_alloc_size_t row_data_length, int flush),
887  PNG_EMPTY);
888 
890 
891 #ifdef PNG_WRITE_gAMA_SUPPORTED
893  png_fixed_point file_gamma),PNG_EMPTY);
894 #endif
895 
896 #ifdef PNG_WRITE_sBIT_SUPPORTED
898  png_const_color_8p sbit, int color_type),PNG_EMPTY);
899 #endif
900 
901 #ifdef PNG_WRITE_cHRM_SUPPORTED
903  const png_xy *xy), PNG_EMPTY);
904  /* The xy value must have been previously validated */
905 #endif
906 
907 #ifdef PNG_WRITE_sRGB_SUPPORTED
909  int intent),PNG_EMPTY);
910 #endif
911 
912 #ifdef PNG_WRITE_iCCP_SUPPORTED
914  png_const_charp name, png_const_bytep profile), PNG_EMPTY);
915  /* The profile must have been previously validated for correctness, the
916  * length comes from the first four bytes. Only the base, deflate,
917  * compression is supported.
918  */
919 #endif
920 
921 #ifdef PNG_WRITE_sPLT_SUPPORTED
923  png_const_sPLT_tp palette),PNG_EMPTY);
924 #endif
925 
926 #ifdef PNG_WRITE_tRNS_SUPPORTED
928  png_const_bytep trans, png_const_color_16p values, int number,
929  int color_type),PNG_EMPTY);
930 #endif
931 
932 #ifdef PNG_WRITE_bKGD_SUPPORTED
934  png_const_color_16p values, int color_type),PNG_EMPTY);
935 #endif
936 
937 #ifdef PNG_WRITE_hIST_SUPPORTED
939  png_const_uint_16p hist, int num_hist),PNG_EMPTY);
940 #endif
941 
942 /* Chunks that have keywords */
943 #ifdef PNG_WRITE_tEXt_SUPPORTED
945  png_const_charp key, png_const_charp text, png_size_t text_len),PNG_EMPTY);
946 #endif
947 
948 #ifdef PNG_WRITE_zTXt_SUPPORTED
950  key, png_const_charp text, png_size_t text_len, int compression),PNG_EMPTY);
951 #endif
952 
953 #ifdef PNG_WRITE_iTXt_SUPPORTED
955  int compression, png_const_charp key, png_const_charp lang,
956  png_const_charp lang_key, png_const_charp text),PNG_EMPTY);
957 #endif
958 
959 #ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */
961  png_inforp info_ptr, png_const_textp text_ptr, int num_text),PNG_EMPTY);
962 #endif
963 
964 #ifdef PNG_WRITE_oFFs_SUPPORTED
966  png_int_32 x_offset, png_int_32 y_offset, int unit_type),PNG_EMPTY);
967 #endif
968 
969 #ifdef PNG_WRITE_pCAL_SUPPORTED
971  png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
972  png_const_charp units, png_charpp params),PNG_EMPTY);
973 #endif
974 
975 #ifdef PNG_WRITE_pHYs_SUPPORTED
977  png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
978  int unit_type),PNG_EMPTY);
979 #endif
980 
981 #ifdef PNG_WRITE_tIME_SUPPORTED
983  png_const_timep mod_time),PNG_EMPTY);
984 #endif
985 
986 #ifdef PNG_WRITE_sCAL_SUPPORTED
989 #endif
990 
991 /* Called when finished processing a row of data */
993  PNG_EMPTY);
994 
995 /* Internal use only. Called before first row of data */
997  PNG_EMPTY);
998 
999 /* Combine a row of data, dealing with alpha, etc. if requested. 'row' is an
1000  * array of png_ptr->width pixels. If the image is not interlaced or this
1001  * is the final pass this just does a memcpy, otherwise the "display" flag
1002  * is used to determine whether to copy pixels that are not in the current pass.
1003  *
1004  * Because 'png_do_read_interlace' (below) replicates pixels this allows this
1005  * function to achieve the documented 'blocky' appearance during interlaced read
1006  * if display is 1 and the 'sparkle' appearance, where existing pixels in 'row'
1007  * are not changed if they are not in the current pass, when display is 0.
1008  *
1009  * 'display' must be 0 or 1, otherwise the memcpy will be done regardless.
1010  *
1011  * The API always reads from the png_struct row buffer and always assumes that
1012  * it is full width (png_do_read_interlace has already been called.)
1013  *
1014  * This function is only ever used to write to row buffers provided by the
1015  * caller of the relevant libpng API and the row must have already been
1016  * transformed by the read transformations.
1017  *
1018  * The PNG_USE_COMPILE_TIME_MASKS option causes generation of pre-computed
1019  * bitmasks for use within the code, otherwise runtime generated masks are used.
1020  * The default is compile time masks.
1021  */
1022 #ifndef PNG_USE_COMPILE_TIME_MASKS
1023 # define PNG_USE_COMPILE_TIME_MASKS 1
1024 #endif
1026  png_bytep row, int display),PNG_EMPTY);
1027 
1028 #ifdef PNG_READ_INTERLACING_SUPPORTED
1029 /* Expand an interlaced row: the 'row_info' describes the pass data that has
1030  * been read in and must correspond to the pixels in 'row', the pixels are
1031  * expanded (moved apart) in 'row' to match the final layout, when doing this
1032  * the pixels are *replicated* to the intervening space. This is essential for
1033  * the correct operation of png_combine_row, above.
1034  */
1036  png_bytep row, int pass, png_uint_32 transformations),PNG_EMPTY);
1037 #endif
1038 
1039 /* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */
1040 
1041 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
1042 /* Grab pixels out of a row for an interlaced pass */
1044  png_bytep row, int pass),PNG_EMPTY);
1045 #endif
1046 
1047 /* Unfilter a row: check the filter value before calling this, there is no point
1048  * calling it for PNG_FILTER_VALUE_NONE.
1049  */
1051  row_info, png_bytep row, png_const_bytep prev_row, int filter),PNG_EMPTY);
1052 
1053 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,(png_row_infop row_info,
1054  png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1055 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,(png_row_infop
1056  row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1057 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_neon,(png_row_infop
1058  row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1059 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_neon,(png_row_infop
1060  row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1061 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_neon,(png_row_infop
1062  row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1063 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_neon,(png_row_infop
1064  row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1065 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop
1066  row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1067 
1068 /* Choose the best filter to use and filter the row data */
1070  png_row_infop row_info),PNG_EMPTY);
1071 
1072 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1074  png_bytep output, png_alloc_size_t avail_out),PNG_EMPTY);
1075  /* Read 'avail_out' bytes of data from the IDAT stream. If the output buffer
1076  * is NULL the function checks, instead, for the end of the stream. In this
1077  * case a benign error will be issued if the stream end is not found or if
1078  * extra data has to be consumed.
1079  */
1081  PNG_EMPTY);
1082  /* This cleans up when the IDAT LZ stream does not end when the last image
1083  * byte is read; there is still some pending input.
1084  */
1085 
1087  PNG_EMPTY);
1088  /* Finish a row while reading, dealing with interlacing passes, etc. */
1089 #endif
1090 
1091 /* Initialize the row buffers, etc. */
1093 
1094 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
1095 /* Optional call to update the users info structure */
1098 #endif
1099 
1100 /* These are the functions that do the transformations */
1101 #ifdef PNG_READ_FILLER_SUPPORTED
1104 #endif
1105 
1106 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
1108  png_bytep row),PNG_EMPTY);
1109 #endif
1110 
1111 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
1113  png_bytep row),PNG_EMPTY);
1114 #endif
1115 
1116 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
1118  png_bytep row),PNG_EMPTY);
1119 #endif
1120 
1121 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
1123  png_bytep row),PNG_EMPTY);
1124 #endif
1125 
1126 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
1127  defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
1129  png_bytep row, int at_start),PNG_EMPTY);
1130 #endif
1131 
1132 #ifdef PNG_16BIT_SUPPORTED
1133 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
1135  png_bytep row),PNG_EMPTY);
1136 #endif
1137 #endif
1138 
1139 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
1140  defined(PNG_WRITE_PACKSWAP_SUPPORTED)
1142  png_bytep row),PNG_EMPTY);
1143 #endif
1144 
1145 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1147  png_row_infop row_info, png_bytep row),PNG_EMPTY);
1148 #endif
1149 
1150 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
1152  png_bytep row),PNG_EMPTY);
1153 #endif
1154 
1155 #ifdef PNG_READ_PACK_SUPPORTED
1157  png_bytep row),PNG_EMPTY);
1158 #endif
1159 
1160 #ifdef PNG_READ_SHIFT_SUPPORTED
1162  png_bytep row, png_const_color_8p sig_bits),PNG_EMPTY);
1163 #endif
1164 
1165 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
1167  png_bytep row),PNG_EMPTY);
1168 #endif
1169 
1170 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
1172  png_bytep row),PNG_EMPTY);
1173 #endif
1174 
1175 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
1177  png_bytep row),PNG_EMPTY);
1178 #endif
1179 
1180 #ifdef PNG_READ_QUANTIZE_SUPPORTED
1182  png_bytep row, png_const_bytep palette_lookup,
1183  png_const_bytep quantize_lookup),PNG_EMPTY);
1184 
1185 # ifdef PNG_CORRECT_PALETTE_SUPPORTED
1186 PNG_INTERNAL_FUNCTION(void,png_correct_palette,(png_structrp png_ptr,
1187  png_colorp palette, int num_palette),PNG_EMPTY);
1188 # endif
1189 #endif
1190 
1191 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
1193  png_bytep row),PNG_EMPTY);
1194 #endif
1195 
1196 #ifdef PNG_WRITE_PACK_SUPPORTED
1198  png_bytep row, png_uint_32 bit_depth),PNG_EMPTY);
1199 #endif
1200 
1201 #ifdef PNG_WRITE_SHIFT_SUPPORTED
1203  png_bytep row, png_const_color_8p bit_depth),PNG_EMPTY);
1204 #endif
1205 
1206 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
1207  defined(PNG_READ_ALPHA_MODE_SUPPORTED)
1210 #endif
1211 
1212 #ifdef PNG_READ_GAMMA_SUPPORTED
1215 #endif
1216 
1217 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
1220 #endif
1221 
1222 #ifdef PNG_READ_EXPAND_SUPPORTED
1224  png_bytep row, png_const_colorp palette, png_const_bytep trans,
1225  int num_trans),PNG_EMPTY);
1227  png_bytep row, png_const_color_16p trans_color),PNG_EMPTY);
1228 #endif
1229 
1230 #ifdef PNG_READ_EXPAND_16_SUPPORTED
1232  png_bytep row),PNG_EMPTY);
1233 #endif
1234 
1235 /* The following decodes the appropriate chunks, and does error correction,
1236  * then calls the appropriate callback for the chunk if it is valid.
1237  */
1238 
1239 /* Decode the IHDR chunk */
1246 
1247 #ifdef PNG_READ_bKGD_SUPPORTED
1250 #endif
1251 
1252 #ifdef PNG_READ_cHRM_SUPPORTED
1255 #endif
1256 
1257 #ifdef PNG_READ_gAMA_SUPPORTED
1260 #endif
1261 
1262 #ifdef PNG_READ_hIST_SUPPORTED
1265 #endif
1266 
1267 #ifdef PNG_READ_iCCP_SUPPORTED
1270 #endif /* PNG_READ_iCCP_SUPPORTED */
1271 
1272 #ifdef PNG_READ_iTXt_SUPPORTED
1275 #endif
1276 
1277 #ifdef PNG_READ_oFFs_SUPPORTED
1280 #endif
1281 
1282 #ifdef PNG_READ_pCAL_SUPPORTED
1285 #endif
1286 
1287 #ifdef PNG_READ_pHYs_SUPPORTED
1290 #endif
1291 
1292 #ifdef PNG_READ_sBIT_SUPPORTED
1295 #endif
1296 
1297 #ifdef PNG_READ_sCAL_SUPPORTED
1300 #endif
1301 
1302 #ifdef PNG_READ_sPLT_SUPPORTED
1305 #endif /* PNG_READ_sPLT_SUPPORTED */
1306 
1307 #ifdef PNG_READ_sRGB_SUPPORTED
1310 #endif
1311 
1312 #ifdef PNG_READ_tEXt_SUPPORTED
1315 #endif
1316 
1317 #ifdef PNG_READ_tIME_SUPPORTED
1320 #endif
1321 
1322 #ifdef PNG_READ_tRNS_SUPPORTED
1325 #endif
1326 
1327 #ifdef PNG_READ_zTXt_SUPPORTED
1330 #endif
1331 
1333  png_uint_32 chunk_name),PNG_EMPTY);
1334 
1335 #ifdef PNG_READ_SUPPORTED
1338  /* This is the function that gets called for unknown chunks. The 'keep'
1339  * argument is either non-zero for a known chunk that has been set to be
1340  * handled as unknown or zero for an unknown chunk. By default the function
1341  * just skips the chunk or errors out if it is critical.
1342  */
1343 
1344 #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
1345 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
1348  /* Exactly as the API png_handle_as_unknown() except that the argument is a
1349  * 32-bit chunk name, not a string.
1350  */
1351 #endif
1352 #endif /* PNG_READ_UNKNOWN_CHUNKS_SUPPORTED */
1353 #endif /* PNG_READ_SUPPORTED */
1354 
1355 /* Handle the transformations for reading and writing */
1356 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
1358  png_row_infop row_info),PNG_EMPTY);
1359 #endif
1360 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
1362  png_row_infop row_info),PNG_EMPTY);
1363 #endif
1364 
1365 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
1367  PNG_EMPTY);
1368 #endif
1369 
1370 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
1375 PNG_INTERNAL_FUNCTION(void,png_push_check_crc,(png_structrp png_ptr),PNG_EMPTY);
1379  PNG_EMPTY);
1381  PNG_EMPTY);
1383  png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
1386  png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
1388  PNG_EMPTY);
1389 PNG_INTERNAL_FUNCTION(void,png_push_handle_unknown,(png_structrp png_ptr,
1396  png_bytep row),PNG_EMPTY);
1397 PNG_INTERNAL_FUNCTION(void,png_push_read_end,(png_structrp png_ptr,
1402  PNG_EMPTY);
1403 # ifdef PNG_READ_tEXt_SUPPORTED
1404 PNG_INTERNAL_FUNCTION(void,png_push_handle_tEXt,(png_structrp png_ptr,
1406 PNG_INTERNAL_FUNCTION(void,png_push_read_tEXt,(png_structrp png_ptr,
1408 # endif
1409 # ifdef PNG_READ_zTXt_SUPPORTED
1410 PNG_INTERNAL_FUNCTION(void,png_push_handle_zTXt,(png_structrp png_ptr,
1412 PNG_INTERNAL_FUNCTION(void,png_push_read_zTXt,(png_structrp png_ptr,
1414 # endif
1415 # ifdef PNG_READ_iTXt_SUPPORTED
1416 PNG_INTERNAL_FUNCTION(void,png_push_handle_iTXt,(png_structrp png_ptr,
1418 PNG_INTERNAL_FUNCTION(void,png_push_read_iTXt,(png_structrp png_ptr,
1420 # endif
1421 
1422 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
1423 
1424 #ifdef PNG_MNG_FEATURES_SUPPORTED
1426  png_bytep row),PNG_EMPTY);
1428  png_bytep row),PNG_EMPTY);
1429 #endif
1430 
1431 /* Added at libpng version 1.6.0 */
1432 #ifdef PNG_GAMMA_SUPPORTED
1435  /* Set the colorspace gamma with a value provided by the application or by
1436  * the gAMA chunk on read. The value will override anything set by an ICC
1437  * profile.
1438  */
1439 
1442  /* Synchronize the info 'valid' flags with the colorspace */
1443 
1446  /* Copy the png_struct colorspace to the info_struct and call the above to
1447  * synchronize the flags. Checks for NULL info_ptr and does nothing.
1448  */
1449 #endif
1450 
1451 /* Added at libpng version 1.4.0 */
1452 #ifdef PNG_COLORSPACE_SUPPORTED
1453 /* These internal functions are for maintaining the colorspace structure within
1454  * a png_info or png_struct (or, indeed, both).
1455  */
1458  int preferred), PNG_EMPTY);
1459 
1462  int preferred), PNG_EMPTY);
1463 
1464 #ifdef PNG_sRGB_SUPPORTED
1467  /* This does set the colorspace gAMA and cHRM values too, but doesn't set the
1468  * flags to write them, if it returns false there was a problem and an error
1469  * message has already been output (but the colorspace may still need to be
1470  * synced to record the invalid flag).
1471  */
1472 #endif /* sRGB */
1473 
1474 #ifdef PNG_iCCP_SUPPORTED
1477  png_uint_32 profile_length, png_const_bytep profile, int color_type),
1478  PNG_EMPTY);
1479  /* The 'name' is used for information only */
1480 
1481 /* Routines for checking parts of an ICC profile. */
1484  png_uint_32 profile_length), PNG_EMPTY);
1487  png_uint_32 profile_length,
1488  png_const_bytep profile /* first 132 bytes only */, int color_type),
1489  PNG_EMPTY);
1492  png_uint_32 profile_length,
1493  png_const_bytep profile /* header plus whole tag table */), PNG_EMPTY);
1494 #ifdef PNG_sRGB_SUPPORTED
1497  png_const_bytep profile, uLong adler), PNG_EMPTY);
1498  /* 'adler' is the Adler32 checksum of the uncompressed profile data. It may
1499  * be zero to indicate that it is not available. It is used, if provided,
1500  * as a fast check on the profile when checking to see if it is sRGB.
1501  */
1502 #endif
1503 #endif /* iCCP */
1504 
1505 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1508  /* Set the rgb_to_gray coefficients from the colorspace Y values */
1509 #endif /* READ_RGB_TO_GRAY */
1510 #endif /* COLORSPACE */
1511 
1512 /* Added at libpng version 1.4.0 */
1514  png_uint_32 width, png_uint_32 height, int bit_depth,
1515  int color_type, int interlace_type, int compression_type,
1516  int filter_type),PNG_EMPTY);
1517 
1518 /* Added at libpng version 1.5.10 */
1519 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
1520  defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
1523 #endif
1524 
1525 #if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
1528 #endif
1529 
1530 /* Puts 'string' into 'buffer' at buffer[pos], taking care never to overwrite
1531  * the end. Always leaves the buffer nul terminated. Never errors out (and
1532  * there is no error code.)
1533  */
1534 PNG_INTERNAL_FUNCTION(size_t,png_safecat,(png_charp buffer, size_t bufsize,
1535  size_t pos, png_const_charp string),PNG_EMPTY);
1536 
1537 /* Various internal functions to handle formatted warning messages, currently
1538  * only implemented for warnings.
1539  */
1540 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED)
1541 /* Utility to dump an unsigned value into a buffer, given a start pointer and
1542  * and end pointer (which should point just *beyond* the end of the buffer!)
1543  * Returns the pointer to the start of the formatted string. This utility only
1544  * does unsigned values.
1545  */
1547  png_charp end, int format, png_alloc_size_t number),PNG_EMPTY);
1548 
1549 /* Convenience macro that takes an array: */
1550 #define PNG_FORMAT_NUMBER(buffer,format,number) \
1551  png_format_number(buffer, buffer + (sizeof buffer), format, number)
1552 
1553 /* Suggested size for a number buffer (enough for 64 bits and a sign!) */
1554 #define PNG_NUMBER_BUFFER_SIZE 24
1555 
1556 /* These are the integer formats currently supported, the name is formed from
1557  * the standard printf(3) format string.
1558  */
1559 #define PNG_NUMBER_FORMAT_u 1 /* chose unsigned API! */
1560 #define PNG_NUMBER_FORMAT_02u 2
1561 #define PNG_NUMBER_FORMAT_d 1 /* chose signed API! */
1562 #define PNG_NUMBER_FORMAT_02d 2
1563 #define PNG_NUMBER_FORMAT_x 3
1564 #define PNG_NUMBER_FORMAT_02x 4
1565 #define PNG_NUMBER_FORMAT_fixed 5 /* choose the signed API */
1566 #endif
1567 
1568 #ifdef PNG_WARNINGS_SUPPORTED
1569 /* New defines and members adding in libpng-1.5.4 */
1570 # define PNG_WARNING_PARAMETER_SIZE 32
1571 # define PNG_WARNING_PARAMETER_COUNT 8 /* Maximum 9; see pngerror.c */
1572 
1573 /* An l-value of this type has to be passed to the APIs below to cache the
1574  * values of the parameters to a formatted warning message.
1575  */
1578 
1579 PNG_INTERNAL_FUNCTION(void,png_warning_parameter,(png_warning_parameters p,
1580  int number, png_const_charp string),PNG_EMPTY);
1581  /* Parameters are limited in size to PNG_WARNING_PARAMETER_SIZE characters,
1582  * including the trailing '\0'.
1583  */
1585  (png_warning_parameters p, int number, int format, png_alloc_size_t value),
1586  PNG_EMPTY);
1587  /* Use png_alloc_size_t because it is an unsigned type as big as any we
1588  * need to output. Use the following for a signed value.
1589  */
1591  (png_warning_parameters p, int number, int format, png_int_32 value),
1592  PNG_EMPTY);
1593 
1595  png_warning_parameters p, png_const_charp message),PNG_EMPTY);
1596  /* 'message' follows the X/Open approach of using @1, @2 to insert
1597  * parameters previously supplied using the above functions. Errors in
1598  * specifying the parameters will simply result in garbage substitutions.
1599  */
1600 #endif
1601 
1602 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
1603 /* Application errors (new in 1.6); use these functions (declared below) for
1604  * errors in the parameters or order of API function calls on read. The
1605  * 'warning' should be used for an error that can be handled completely; the
1606  * 'error' for one which can be handled safely but which may lose application
1607  * information or settings.
1608  *
1609  * By default these both result in a png_error call prior to release, while in a
1610  * released version the 'warning' is just a warning. However if the application
1611  * explicitly disables benign errors (explicitly permitting the code to lose
1612  * information) they both turn into warnings.
1613  *
1614  * If benign errors aren't supported they end up as the corresponding base call
1615  * (png_warning or png_error.)
1616  */
1618  png_const_charp message),PNG_EMPTY);
1619  /* The application provided invalid parameters to an API function or called
1620  * an API function at the wrong time, libpng can completely recover.
1621  */
1622 
1624  png_const_charp message),PNG_EMPTY);
1625  /* As above but libpng will ignore the call, or attempt some other partial
1626  * recovery from the error.
1627  */
1628 #else
1629 # define png_app_warning(pp,s) png_warning(pp,s)
1630 # define png_app_error(pp,s) png_error(pp,s)
1631 #endif
1632 
1634  png_const_charp message, int error),PNG_EMPTY);
1635  /* Report a recoverable issue in chunk data. On read this is used to report
1636  * a problem found while reading a particular chunk and the
1637  * png_chunk_benign_error or png_chunk_warning function is used as
1638  * appropriate. On write this is used to report an error that comes from
1639  * data set via an application call to a png_set_ API and png_app_error or
1640  * png_app_warning is used as appropriate.
1641  *
1642  * The 'error' parameter must have one of the following values:
1643  */
1644 #define PNG_CHUNK_WARNING 0 /* never an error */
1645 #define PNG_CHUNK_WRITE_ERROR 1 /* an error only on write */
1646 #define PNG_CHUNK_ERROR 2 /* always an error */
1647 
1648 /* ASCII to FP interfaces, currently only implemented if sCAL
1649  * support is required.
1650  */
1651 #if defined(PNG_sCAL_SUPPORTED)
1652 /* MAX_DIGITS is actually the maximum number of characters in an sCAL
1653  * width or height, derived from the precision (number of significant
1654  * digits - a build time settable option) and assumptions about the
1655  * maximum ridiculous exponent.
1656  */
1657 #define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/)
1658 
1659 #ifdef PNG_FLOATING_POINT_SUPPORTED
1661  png_charp ascii, png_size_t size, double fp, unsigned int precision),
1662  PNG_EMPTY);
1663 #endif /* FLOATING_POINT */
1664 
1665 #ifdef PNG_FIXED_POINT_SUPPORTED
1667  png_charp ascii, png_size_t size, png_fixed_point fp),PNG_EMPTY);
1668 #endif /* FIXED_POINT */
1669 #endif /* sCAL */
1670 
1671 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
1672 /* An internal API to validate the format of a floating point number.
1673  * The result is the index of the next character. If the number is
1674  * not valid it will be the index of a character in the supposed number.
1675  *
1676  * The format of a number is defined in the PNG extensions specification
1677  * and this API is strictly conformant to that spec, not anyone elses!
1678  *
1679  * The format as a regular expression is:
1680  *
1681  * [+-]?[0-9]+.?([Ee][+-]?[0-9]+)?
1682  *
1683  * or:
1684  *
1685  * [+-]?.[0-9]+(.[0-9]+)?([Ee][+-]?[0-9]+)?
1686  *
1687  * The complexity is that either integer or fraction must be present and the
1688  * fraction is permitted to have no digits only if the integer is present.
1689  *
1690  * NOTE: The dangling E problem.
1691  * There is a PNG valid floating point number in the following:
1692  *
1693  * PNG floating point numbers are not greedy.
1694  *
1695  * Working this out requires *TWO* character lookahead (because of the
1696  * sign), the parser does not do this - it will fail at the 'r' - this
1697  * doesn't matter for PNG sCAL chunk values, but it requires more care
1698  * if the value were ever to be embedded in something more complex. Use
1699  * ANSI-C strtod if you need the lookahead.
1700  */
1701 /* State table for the parser. */
1702 #define PNG_FP_INTEGER 0 /* before or in integer */
1703 #define PNG_FP_FRACTION 1 /* before or in fraction */
1704 #define PNG_FP_EXPONENT 2 /* before or in exponent */
1705 #define PNG_FP_STATE 3 /* mask for the above */
1706 #define PNG_FP_SAW_SIGN 4 /* Saw +/- in current state */
1707 #define PNG_FP_SAW_DIGIT 8 /* Saw a digit in current state */
1708 #define PNG_FP_SAW_DOT 16 /* Saw a dot in current state */
1709 #define PNG_FP_SAW_E 32 /* Saw an E (or e) in current state */
1710 #define PNG_FP_SAW_ANY 60 /* Saw any of the above 4 */
1711 
1712 /* These three values don't affect the parser. They are set but not used.
1713  */
1714 #define PNG_FP_WAS_VALID 64 /* Preceding substring is a valid fp number */
1715 #define PNG_FP_NEGATIVE 128 /* A negative number, including "-0" */
1716 #define PNG_FP_NONZERO 256 /* A non-zero value */
1717 #define PNG_FP_STICKY 448 /* The above three flags */
1718 
1719 /* This is available for the caller to store in 'state' if required. Do not
1720  * call the parser after setting it (the parser sometimes clears it.)
1721  */
1722 #define PNG_FP_INVALID 512 /* Available for callers as a distinct value */
1723 
1724 /* Result codes for the parser (boolean - true meants ok, false means
1725  * not ok yet.)
1726  */
1727 #define PNG_FP_MAYBE 0 /* The number may be valid in the future */
1728 #define PNG_FP_OK 1 /* The number is valid */
1729 
1730 /* Tests on the sticky non-zero and negative flags. To pass these checks
1731  * the state must also indicate that the whole number is valid - this is
1732  * achieved by testing PNG_FP_SAW_DIGIT (see the implementation for why this
1733  * is equivalent to PNG_FP_OK above.)
1734  */
1735 #define PNG_FP_NZ_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NEGATIVE | PNG_FP_NONZERO)
1736  /* NZ_MASK: the string is valid and a non-zero negative value */
1737 #define PNG_FP_Z_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NONZERO)
1738  /* Z MASK: the string is valid and a non-zero value. */
1739  /* PNG_FP_SAW_DIGIT: the string is valid. */
1740 #define PNG_FP_IS_ZERO(state) (((state) & PNG_FP_Z_MASK) == PNG_FP_SAW_DIGIT)
1741 #define PNG_FP_IS_POSITIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_Z_MASK)
1742 #define PNG_FP_IS_NEGATIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_NZ_MASK)
1743 
1744 /* The actual parser. This can be called repeatedly. It updates
1745  * the index into the string and the state variable (which must
1746  * be initialized to 0). It returns a result code, as above. There
1747  * is no point calling the parser any more if it fails to advance to
1748  * the end of the string - it is stuck on an invalid character (or
1749  * terminated by '\0').
1750  *
1751  * Note that the pointer will consume an E or even an E+ and then leave
1752  * a 'maybe' state even though a preceding integer.fraction is valid.
1753  * The PNG_FP_WAS_VALID flag indicates that a preceding substring was
1754  * a valid number. It's possible to recover from this by calling
1755  * the parser again (from the start, with state 0) but with a string
1756  * that omits the last character (i.e. set the size to the index of
1757  * the problem character.) This has not been tested within libpng.
1758  */
1760  png_size_t size, int *statep, png_size_tp whereami),PNG_EMPTY);
1761 
1762 /* This is the same but it checks a complete string and returns true
1763  * only if it just contains a floating point number. As of 1.5.4 this
1764  * function also returns the state at the end of parsing the number if
1765  * it was valid (otherwise it returns 0.) This can be used for testing
1766  * for negative or zero values using the sticky flag.
1767  */
1769  png_size_t size),PNG_EMPTY);
1770 #endif /* pCAL || sCAL */
1771 
1772 #if defined(PNG_READ_GAMMA_SUPPORTED) ||\
1773  defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
1774 /* Added at libpng version 1.5.0 */
1775 /* This is a utility to provide a*times/div (rounded) and indicate
1776  * if there is an overflow. The result is a boolean - false (0)
1777  * for overflow, true (1) if no overflow, in which case *res
1778  * holds the result.
1779  */
1781  png_int_32 multiplied_by, png_int_32 divided_by),PNG_EMPTY);
1782 #endif
1783 
1784 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
1785 /* Same deal, but issue a warning on overflow and return 0. */
1788  png_int_32 divided_by),PNG_EMPTY);
1789 #endif
1790 
1791 #ifdef PNG_GAMMA_SUPPORTED
1792 /* Calculate a reciprocal - used for gamma values. This returns
1793  * 0 if the argument is 0 in order to maintain an undefined value;
1794  * there are no warnings.
1795  */
1797  PNG_EMPTY);
1798 
1799 #ifdef PNG_READ_GAMMA_SUPPORTED
1800 /* The same but gives a reciprocal of the product of two fixed point
1801  * values. Accuracy is suitable for gamma calculations but this is
1802  * not exact - use png_muldiv for that. Only required at present on read.
1803  */
1806 #endif
1807 
1808 /* Return true if the gamma value is significantly different from 1.0 */
1810  PNG_EMPTY);
1811 #endif
1812 
1813 #ifdef PNG_READ_GAMMA_SUPPORTED
1814 /* Internal fixed point gamma correction. These APIs are called as
1815  * required to convert single values - they don't need to be fast,
1816  * they are not used when processing image pixel values.
1817  *
1818  * While the input is an 'unsigned' value it must actually be the
1819  * correct bit value - 0..255 or 0..65535 as required.
1820  */
1822  unsigned int value, png_fixed_point gamma_value),PNG_EMPTY);
1824  png_fixed_point gamma_value),PNG_EMPTY);
1825 PNG_INTERNAL_FUNCTION(png_byte,png_gamma_8bit_correct,(unsigned int value,
1826  png_fixed_point gamma_value),PNG_EMPTY);
1828  PNG_EMPTY);
1830  int bit_depth),PNG_EMPTY);
1831 #endif
1832 
1833 /* SIMPLIFIED READ/WRITE SUPPORT */
1834 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
1835  defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
1836 /* The internal structure that png_image::opaque points to. */
1837 typedef struct png_control
1838 {
1841  png_voidp error_buf; /* Always a jmp_buf at present. */
1842 
1843  png_const_bytep memory; /* Memory buffer. */
1844  png_size_t size; /* Size of the memory buffer. */
1845 
1846  unsigned int for_write :1; /* Otherwise it is a read structure */
1847  unsigned int owned_file :1; /* We own the file in io_ptr */
1848 } png_control;
1849 
1850 /* Return the pointer to the jmp_buf from a png_control: necessary because C
1851  * does not reveal the type of the elements of jmp_buf.
1852  */
1853 #ifdef __cplusplus
1854 # define png_control_jmp_buf(pc) (((jmp_buf*)((pc)->error_buf))[0])
1855 #else
1856 # define png_control_jmp_buf(pc) ((pc)->error_buf)
1857 #endif
1858 
1859 /* Utility to safely execute a piece of libpng code catching and logging any
1860  * errors that might occur. Returns true on success, false on failure (either
1861  * of the function or as a result of a png_error.)
1862  */
1863 PNG_INTERNAL_FUNCTION(void,png_safe_error,(png_structp png_ptr,
1864  png_const_charp error_message),PNG_NORETURN);
1865 
1866 #ifdef PNG_WARNINGS_SUPPORTED
1867 PNG_INTERNAL_FUNCTION(void,png_safe_warning,(png_structp png_ptr,
1868  png_const_charp warning_message),PNG_EMPTY);
1869 #else
1870 # define png_safe_warning 0/*dummy argument*/
1871 #endif
1872 
1873 PNG_INTERNAL_FUNCTION(int,png_safe_execute,(png_imagep image,
1874  int (*function)(png_voidp), png_voidp arg),PNG_EMPTY);
1875 
1876 /* Utility to log an error; this also cleans up the png_image; the function
1877  * always returns 0 (false).
1878  */
1879 PNG_INTERNAL_FUNCTION(int,png_image_error,(png_imagep image,
1880  png_const_charp error_message),PNG_EMPTY);
1881 
1882 #ifndef PNG_SIMPLIFIED_READ_SUPPORTED
1883 /* png_image_free is used by the write code but not exported */
1884 PNG_INTERNAL_FUNCTION(void, png_image_free, (png_imagep image), PNG_EMPTY);
1885 #endif /* !SIMPLIFIED_READ */
1886 
1887 #endif /* SIMPLIFIED READ/WRITE */
1888 
1889 #ifdef PNG_FILTER_OPTIMIZATIONS
1890 PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr,
1891  unsigned int bpp), PNG_EMPTY);
1892  /* This is the initialization function for hardware specific optimizations,
1893  * one implementation (for ARM NEON machines) is contained in
1894  * arm/filter_neon.c. It need not be defined - the generic code will be used
1895  * if not.
1896  */
1897 #endif
1898 
1899 /* Maintainer: Put new private prototypes here ^ */
1900 
1901 //#include "pngdebug.h"
1902 
1903 #endif /* PNG_VERSION_INFO_ONLY */
1904 #endif /* PNGPRIV_H */
void PNGCBAPI png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
Definition: juce_PNGLoader.cpp:51
void png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset, int unit_type)
Definition: juce_PNGLoader.cpp:1770
void png_do_scale_16_to_8(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:2657
int png_crc_finish(png_structrp png_ptr, png_uint_32 skip)
Definition: juce_PNGLoader.cpp:204
void png_handle_IEND(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1040
void png_push_have_row(png_structrp png_ptr, png_bytep row)
Definition: juce_PNGLoader.cpp:1244
void png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:3528
#define png_warning_parameter_unsigned(p, number, format, value)
Definition: pngpriv.h:291
void PNGCBAPI png_default_flush(png_structp png_ptr)
Definition: juce_PNGLoader.cpp:79
void png_handle_hIST(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1940
void png_write_zTXt(png_structrp png_ptr, png_const_charp key, png_const_charp text, png_size_t text_len, int compression)
Definition: juce_PNGLoader.cpp:1621
#define png_formatted_warning(pp, p, message)
Definition: pngpriv.h:293
Definition: png.h:846
Byte FAR * voidpf
Definition: zconf.h:296
void * png_voidp
Definition: pngconf.h:570
#define png_app_error(pp, s)
Definition: pngpriv.h:1630
png_structrp png_ptr
Definition: juce_PNGLoader.cpp:1173
const char * png_const_charp
Definition: pngconf.h:583
#define PNG_ALLOCATED
void png_push_have_info(png_structrp png_ptr, png_inforp info_ptr)
Definition: juce_PNGLoader.cpp:1230
void png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:576
int png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_charp name, png_uint_32 profile_length, png_const_bytep profile, int color_type)
Definition: juce_PNGLoader.cpp:1852
void png_push_have_end(png_structrp png_ptr, png_inforp info_ptr)
Definition: juce_PNGLoader.cpp:1237
void png_push_save_buffer(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:659
void png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length, int keep)
Definition: juce_PNGLoader.cpp:2750
void png_write_iTXt(png_structrp png_ptr, int compression, png_const_charp key, png_const_charp lang, png_const_charp lang_key, png_const_charp text)
Definition: juce_PNGLoader.cpp:1673
void png_do_expand_palette(png_row_infop row_info, png_bytep row, png_const_colorp palette, png_const_bytep trans_alpha, int num_trans)
Definition: juce_PNGLoader.cpp:4535
void png_do_quantize(png_row_infop row_info, png_bytep row, png_const_bytep palette_lookup, png_const_bytep quantize_lookup)
Definition: juce_PNGLoader.cpp:4946
#define PNGCBAPI
void png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
Definition: juce_PNGLoader.cpp:485
int png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_charp name, png_uint_32 profile_length)
Definition: juce_PNGLoader.cpp:1837
png_uint_16(PNGAPI png_get_uint_16)(png_const_bytep buf)
Definition: juce_PNGLoader.cpp:98
int png_check_fp_number(png_const_charp string, png_size_t size, int *statep, png_size_tp whereami)
Definition: juce_PNGLoader.cpp:2508
png_uint_16 png_gamma_correct(png_structrp png_ptr, unsigned int value, png_fixed_point gamma_val)
Definition: juce_PNGLoader.cpp:3656
const png_uint_16p * png_const_uint_16pp
Definition: pngpriv.h:700
void png_destroy_png_struct(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:25
void png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer, png_size_t buffer_length)
Definition: juce_PNGLoader.cpp:828
void png_handle_pHYs(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1990
void png_do_expand(png_row_infop row_info, png_bytep row, png_const_color_16p trans_color)
Definition: juce_PNGLoader.cpp:4688
void png_write_sRGB(png_structrp png_ptr, int srgb_intent)
Definition: juce_PNGLoader.cpp:1171
int png_crc_error(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:247
png_byte * png_bytep
Definition: pngconf.h:572
void png_crc_read(png_structrp png_ptr, png_bytep buf, png_uint_32 length)
Definition: juce_PNGLoader.cpp:189
void png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width, png_const_charp height)
Definition: juce_PNGLoader.cpp:1855
int png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr, png_const_textp text_ptr, int num_text)
Definition: juce_PNGLoader.cpp:703
void png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:2289
void png_compress_IDAT(png_structrp png_ptr, png_const_bytep input, png_alloc_size_t input_len, int flush)
Definition: juce_PNGLoader.cpp:1005
void png_write_start_row(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:1936
unsigned int png_uint_32
Definition: pngconf.h:505
char * png_charp
Definition: pngconf.h:582
void png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha, png_const_color_16p tran, int num_trans, int color_type)
Definition: juce_PNGLoader.cpp:1419
png_const_structrp png_const_inforp info_ptr
Definition: juce_PNGLoader.cpp:2126
Definition: pngstruct.h:144
Definition: png.h:2825
void png_reset_crc(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:102
void png_handle_sBIT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1097
void png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, png_const_charp units, png_charpp params)
Definition: juce_PNGLoader.cpp:1790
unsigned long uLong
Definition: zconf.h:277
void png_check_chunk_name(png_structrp png_ptr, png_uint_32 chunk_name)
Definition: juce_PNGLoader.cpp:2963
void png_write_tIME(png_structrp png_ptr, png_const_timep mod_time)
Definition: juce_PNGLoader.cpp:1909
void png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
Definition: juce_PNGLoader.cpp:2120
#define PNG_EMPTY
png_double * png_doublep
Definition: pngpriv.h:184
void png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer, png_size_t buffer_length)
Definition: juce_PNGLoader.cpp:716
png_int_32(PNGAPI png_get_int_32)(png_const_bytep buf)
Definition: juce_PNGLoader.cpp:86
long b
Definition: jpegint.h:371
Definition: pnginfo.h:56
void png_read_sig(png_structrp png_ptr, png_inforp info_ptr)
Definition: juce_PNGLoader.cpp:117
void png_read_IDAT_data(png_structrp png_ptr, png_bytep output, png_alloc_size_t avail_out)
Definition: juce_PNGLoader.cpp:3923
struct png_incomplete png_double
Definition: pngpriv.h:183
void png_handle_gAMA(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1059
void png_handle_IHDR(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:784
void png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:479
void png_read_data(png_structrp png_ptr, png_bytep data, png_size_t length)
Definition: juce_PNGLoader.cpp:32
png_size_t png_alloc_size_t
Definition: pngconf.h:550
const png_text * png_const_textp
Definition: juce_PNGLoader.cpp:674
void png_do_expand_16(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:4918
int png_gamma_significant(png_fixed_point gamma_val)
Definition: juce_PNGLoader.cpp:3259
void png_init_read_transformations(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:1269
png_uint_32 adler
Definition: juce_PNGLoader.cpp:2078
JOCTET * buffer
Definition: juce_JPEGLoader.cpp:302
void png_handle_tIME(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:2305
void png_push_crc_skip(png_structrp png_ptr, png_uint_32 skip)
Definition: juce_PNGLoader.cpp:548
void png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
Definition: juce_PNGLoader.cpp:675
const png_struct *PNG_RESTRICT png_const_structrp
Definition: png.h:564
#define png_warning_parameter_signed(p, number, format, value)
Definition: pngpriv.h:292
#define png_warning_parameter(p, number, string)
Definition: pngpriv.h:290
void png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
Definition: juce_PNGLoader.cpp:152
void png_handle_cHRM(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1164
Display * display
Definition: juce_linux_Messaging.cpp:29
there are legal restrictions on arithmetic coding Invalid progressive parameters caller expects u Cannot quantize more than d color components Adobe APP14 flags
Definition: juce_JPEGLoader.cpp:127
png_byte png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
Definition: juce_PNGLoader.cpp:3605
void png_handle_PLTE(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:859
void png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
Definition: juce_PNGLoader.cpp:2317
#define png_fixed_error(s1, s2)
Definition: pngpriv.h:299
void png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
Definition: juce_PNGLoader.cpp:185
Definition: png.h:627
void png_do_read_filler(png_row_infop row_info, png_bytep row, png_uint_32 filler, png_uint_32 flags)
Definition: juce_PNGLoader.cpp:2942
void png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:3129
void png_handle_bKGD(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1840
void png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int compression_type, int filter_type, int interlace_type)
Definition: juce_PNGLoader.cpp:754
const png_byte * png_const_bytep
Definition: pngconf.h:573
void png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:2840
void png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
Definition: juce_PNGLoader.cpp:1916
const png_uint_16 * png_const_uint_16p
Definition: pngconf.h:579
void png_write_PLTE(png_structrp png_ptr, png_const_colorp palette, png_uint_32 num_pal)
Definition: juce_PNGLoader.cpp:919
struct pnglibNamespace::png_colorspace png_colorspacerp
void png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma)
Definition: juce_PNGLoader.cpp:1156
void png_handle_zTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:2432
void png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text, png_size_t text_len)
Definition: juce_PNGLoader.cpp:1578
void png_handle_tRNS(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1737
void png_write_iCCP(png_structrp png_ptr, png_const_charp name, png_const_bytep profile)
Definition: juce_PNGLoader.cpp:1189
int png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_charp name, png_uint_32 profile_length, png_const_bytep profile)
Definition: juce_PNGLoader.cpp:2030
void png_push_crc_finish(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:555
void png_do_shift(png_row_infop row_info, png_bytep row, png_const_color_8p bit_depth)
Definition: juce_PNGLoader.cpp:246
#define PNG_NORETURN
const png_double * png_const_doublep
Definition: pngpriv.h:185
void png_handle_sPLT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1560
char ** png_charpp
Definition: pngconf.h:605
Definition: png.h:694
void png_colorspace_set_gamma(png_const_structrp png_ptr, png_colorspacerp colorspace, png_fixed_point gAMA)
Definition: juce_PNGLoader.cpp:1015
png_uint_32 length
Definition: juce_PNGLoader.cpp:2078
const void * png_const_voidp
Definition: pngconf.h:571
Definition: png.h:572
png_struct *PNG_RESTRICT png_structrp
Definition: png.h:563
#define png_app_warning(pp, s)
Definition: pngpriv.h:1629
void png_do_swap(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:316
char png_warning_parameters[PNG_WARNING_PARAMETER_COUNT][PNG_WARNING_PARAMETER_SIZE]
Definition: juce_PNGLoader.cpp:1577
int png_colorspace_set_chromaticities(png_const_structrp png_ptr, png_colorspacerp colorspace, const png_xy *xy, int preferred)
Definition: juce_PNGLoader.cpp:1587
png_const_structrp png_const_inforp int png_fixed_point * width
Definition: juce_PNGLoader.cpp:2339
void png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)
Definition: juce_PNGLoader.cpp:1069
#define PNG_WARNING_PARAMETER_SIZE
Definition: juce_PNGLoader.cpp:1570
void png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
Definition: juce_PNGLoader.cpp:2988
png_charp png_format_number(png_const_charp start, png_charp end, int format, png_alloc_size_t number)
Definition: juce_PNGLoader.cpp:133
Definition: png.h:594
void png_read_finish_row(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:4097
void png_flush(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:71
int png_colorspace_set_endpoints(png_const_structrp png_ptr, png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred)
Definition: juce_PNGLoader.cpp:1625
void png_destroy_gamma_table(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:3827
int png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_charp name, png_uint_32 profile_length, png_const_bytep profile, int color_type)
Definition: juce_PNGLoader.cpp:2265
int png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)
Definition: juce_PNGLoader.cpp:166
void png_write_cHRM_fixed(png_structrp png_ptr, const png_xy *xy)
Definition: juce_PNGLoader.cpp:1393
void png_write_finish_row(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:2042
void png_handle_tEXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:2351
png_fixed_point png_reciprocal(png_fixed_point a)
Definition: juce_PNGLoader.cpp:3238
void png_do_chop(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:2718
void png_read_finish_IDAT(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:4049
void png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:2743
void png_read_start_row(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:4166
void png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist)
Definition: juce_PNGLoader.cpp:1547
struct pnglibNamespace::png_xy png_xy
void png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1286
struct pnglibNamespace::png_compression_buffer * png_compression_bufferp
size_t png_safecat(png_charp buffer, size_t bufsize, size_t pos, png_const_charp string)
Definition: juce_PNGLoader.cpp:112
void png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size, double fp, unsigned int precision)
Definition: juce_PNGLoader.cpp:2691
void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, png_uint_32 transformations)
Definition: juce_PNGLoader.cpp:3470
png_fixed_point png_reciprocal2(png_fixed_point a, png_fixed_point b)
Definition: juce_PNGLoader.cpp:3291
png_uint_16 * png_uint_16p
Definition: pngconf.h:578
void png_colorspace_sync(png_const_structrp png_ptr, png_inforp info_ptr)
Definition: juce_PNGLoader.cpp:1115
void png_handle_oFFs(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:2036
int png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace, int intent)
Definition: juce_PNGLoader.cpp:1739
void png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:385
struct pnglibNamespace::png_XYZ png_XYZ
void png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
Definition: juce_PNGLoader.cpp:101
J_COLOR_SPACE colorspace
Definition: jpeglib.h:917
png_fixed_point * png_fixed_point_p
Definition: pngconf.h:584
png_int_32 png_fixed_point
Definition: pngconf.h:567
void png_read_filter_row(png_structrp pp, png_row_infop row_info, png_bytep row, png_const_bytep prev_row, int filter)
Definition: juce_PNGLoader.cpp:3908
png_uint_16 png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
Definition: juce_PNGLoader.cpp:3628
size_t png_size_t
Definition: pngconf.h:515
png_uint_32 png_read_chunk_header(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:152
JSAMPIMAGE data
Definition: jpeglib.h:945
void png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, int unit_type)
Definition: juce_PNGLoader.cpp:1885
void png_do_bgr(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:595
png_double ** png_doublepp
Definition: pngpriv.h:186
void png_zstream_error(png_structrp png_ptr, int ret)
Definition: juce_PNGLoader.cpp:899
void png_push_process_row(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:935
void png_write_IEND(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:1145
void png_check_IHDR(png_const_structrp png_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int interlace_type, int compression_type, int filter_type)
Definition: juce_PNGLoader.cpp:2356
png_size_t * png_size_tp
Definition: pngconf.h:586
void png_icc_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_bytep profile, uLong adler)
Definition: juce_PNGLoader.cpp:2252
png_fixed_point png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times, png_int_32 divisor)
Definition: juce_PNGLoader.cpp:3222
png_const_structrp png_const_inforp int * unit
Definition: juce_PNGLoader.cpp:2339
png_info *PNG_RESTRICT png_inforp
Definition: png.h:565
void png_write_data(png_structrp png_ptr, png_const_bytep data, png_size_t length)
Definition: juce_PNGLoader.cpp:33
int png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times, png_int_32 divisor)
Definition: juce_PNGLoader.cpp:3103
void png_build_gamma_table(png_structrp png_ptr, int bit_depth)
Definition: juce_PNGLoader.cpp:3883
void png_do_unshift(png_row_infop row_info, png_bytep row, png_const_color_8p sig_bits)
Definition: juce_PNGLoader.cpp:2518
void PNGCBAPI png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
Definition: juce_PNGLoader.cpp:50
png_uint_16 intent
Definition: juce_PNGLoader.cpp:2082
void png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
Definition: juce_PNGLoader.cpp:1249
png_fixed_point png_fixed(png_const_structrp png_ptr, double fp, png_const_charp)
Definition: juce_PNGLoader.cpp:3083
int png_check_fp_string(png_const_charp string, png_size_t size)
Definition: juce_PNGLoader.cpp:2635
#define PNG_WARNING_PARAMETER_COUNT
Definition: juce_PNGLoader.cpp:1571
void png_handle_sRGB(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:1236
void png_do_gamma(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:4268
Definition: png.h:582
#define PNG_INTERNAL_FUNCTION(type, name, args, attributes)
Definition: pngpriv.h:165
void png_do_packswap(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:445
void png_handle_iTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:2541
void png_zfree(voidpf png_ptr, voidpf ptr)
Definition: juce_PNGLoader.cpp:93
void png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
Definition: juce_PNGLoader.cpp:114
int png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:3268
void png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:5042
void png_handle_pCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:2083
int png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name)
Definition: juce_PNGLoader.cpp:860
void PNGCBAPI png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
Definition: juce_PNGLoader.cpp:616
void png_push_read_IDAT(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:726
void png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:4469
void png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
Definition: juce_PNGLoader.cpp:1485
void png_do_unpack(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:2420
void png_read_push_finish_row(png_structrp png_ptr)
Definition: juce_PNGLoader.cpp:1164
void png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
Definition: juce_PNGLoader.cpp:106
void png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
Definition: juce_PNGLoader.cpp:23
void png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
Definition: juce_PNGLoader.cpp:2133
#define PNG_INTERNAL_DATA(type, name, array)
Definition: pngpriv.h:161
void png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp)
Definition: juce_PNGLoader.cpp:440
void png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
Definition: juce_PNGLoader.cpp:514
void png_handle_sCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
Definition: juce_PNGLoader.cpp:2212
unsigned int uInt
Definition: zconf.h:276
void png_do_invert(png_row_infop row_info, png_bytep row)
Definition: juce_PNGLoader.cpp:259
void png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
Definition: juce_PNGLoader.cpp:1334
void png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii, png_size_t size, png_fixed_point fp)
Definition: juce_PNGLoader.cpp:3005