ReactOS  0.4.14-dev-593-g1793dcc
png.h
Go to the documentation of this file.
1 
2 /* png.h - header file for PNG reference library
3  *
4  * libpng version 1.6.37 - April 14, 2019
5  *
6  * Copyright (c) 2018-2019 Cosmin Truta
7  * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
8  * Copyright (c) 1996-1997 Andreas Dilger
9  * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
10  *
11  * This code is released under the libpng license. (See LICENSE, below.)
12  *
13  * Authors and maintainers:
14  * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
15  * libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
16  * libpng versions 0.97, January 1998, through 1.6.35, July 2018:
17  * Glenn Randers-Pehrson
18  * libpng versions 1.6.36, December 2018, through 1.6.37, April 2019:
19  * Cosmin Truta
20  * See also "Contributing Authors", below.
21  */
22 
23 /*
24  * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE
25  * =========================================
26  *
27  * PNG Reference Library License version 2
28  * ---------------------------------------
29  *
30  * * Copyright (c) 1995-2019 The PNG Reference Library Authors.
31  * * Copyright (c) 2018-2019 Cosmin Truta.
32  * * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.
33  * * Copyright (c) 1996-1997 Andreas Dilger.
34  * * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
35  *
36  * The software is supplied "as is", without warranty of any kind,
37  * express or implied, including, without limitation, the warranties
38  * of merchantability, fitness for a particular purpose, title, and
39  * non-infringement. In no event shall the Copyright owners, or
40  * anyone distributing the software, be liable for any damages or
41  * other liability, whether in contract, tort or otherwise, arising
42  * from, out of, or in connection with the software, or the use or
43  * other dealings in the software, even if advised of the possibility
44  * of such damage.
45  *
46  * Permission is hereby granted to use, copy, modify, and distribute
47  * this software, or portions hereof, for any purpose, without fee,
48  * subject to the following restrictions:
49  *
50  * 1. The origin of this software must not be misrepresented; you
51  * must not claim that you wrote the original software. If you
52  * use this software in a product, an acknowledgment in the product
53  * documentation would be appreciated, but is not required.
54  *
55  * 2. Altered source versions must be plainly marked as such, and must
56  * not be misrepresented as being the original software.
57  *
58  * 3. This Copyright notice may not be removed or altered from any
59  * source or altered source distribution.
60  *
61  *
62  * PNG Reference Library License version 1 (for libpng 0.5 through 1.6.35)
63  * -----------------------------------------------------------------------
64  *
65  * libpng versions 1.0.7, July 1, 2000, through 1.6.35, July 15, 2018 are
66  * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson, are
67  * derived from libpng-1.0.6, and are distributed according to the same
68  * disclaimer and license as libpng-1.0.6 with the following individuals
69  * added to the list of Contributing Authors:
70  *
71  * Simon-Pierre Cadieux
72  * Eric S. Raymond
73  * Mans Rullgard
74  * Cosmin Truta
75  * Gilles Vollant
76  * James Yu
77  * Mandar Sahastrabuddhe
78  * Google Inc.
79  * Vadim Barkov
80  *
81  * and with the following additions to the disclaimer:
82  *
83  * There is no warranty against interference with your enjoyment of
84  * the library or against infringement. There is no warranty that our
85  * efforts or the library will fulfill any of your particular purposes
86  * or needs. This library is provided with all faults, and the entire
87  * risk of satisfactory quality, performance, accuracy, and effort is
88  * with the user.
89  *
90  * Some files in the "contrib" directory and some configure-generated
91  * files that are distributed with libpng have other copyright owners, and
92  * are released under other open source licenses.
93  *
94  * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
95  * Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
96  * libpng-0.96, and are distributed according to the same disclaimer and
97  * license as libpng-0.96, with the following individuals added to the
98  * list of Contributing Authors:
99  *
100  * Tom Lane
101  * Glenn Randers-Pehrson
102  * Willem van Schaik
103  *
104  * libpng versions 0.89, June 1996, through 0.96, May 1997, are
105  * Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
106  * and are distributed according to the same disclaimer and license as
107  * libpng-0.88, with the following individuals added to the list of
108  * Contributing Authors:
109  *
110  * John Bowler
111  * Kevin Bracey
112  * Sam Bushell
113  * Magnus Holmgren
114  * Greg Roelofs
115  * Tom Tanner
116  *
117  * Some files in the "scripts" directory have other copyright owners,
118  * but are released under this license.
119  *
120  * libpng versions 0.5, May 1995, through 0.88, January 1996, are
121  * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
122  *
123  * For the purposes of this copyright and license, "Contributing Authors"
124  * is defined as the following set of individuals:
125  *
126  * Andreas Dilger
127  * Dave Martindale
128  * Guy Eric Schalnat
129  * Paul Schmidt
130  * Tim Wegner
131  *
132  * The PNG Reference Library is supplied "AS IS". The Contributing
133  * Authors and Group 42, Inc. disclaim all warranties, expressed or
134  * implied, including, without limitation, the warranties of
135  * merchantability and of fitness for any purpose. The Contributing
136  * Authors and Group 42, Inc. assume no liability for direct, indirect,
137  * incidental, special, exemplary, or consequential damages, which may
138  * result from the use of the PNG Reference Library, even if advised of
139  * the possibility of such damage.
140  *
141  * Permission is hereby granted to use, copy, modify, and distribute this
142  * source code, or portions hereof, for any purpose, without fee, subject
143  * to the following restrictions:
144  *
145  * 1. The origin of this source code must not be misrepresented.
146  *
147  * 2. Altered versions must be plainly marked as such and must not
148  * be misrepresented as being the original source.
149  *
150  * 3. This Copyright notice may not be removed or altered from any
151  * source or altered source distribution.
152  *
153  * The Contributing Authors and Group 42, Inc. specifically permit,
154  * without fee, and encourage the use of this source code as a component
155  * to supporting the PNG file format in commercial products. If you use
156  * this source code in a product, acknowledgment is not required but would
157  * be appreciated.
158  *
159  * END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
160  *
161  * TRADEMARK
162  * =========
163  *
164  * The name "libpng" has not been registered by the Copyright owners
165  * as a trademark in any jurisdiction. However, because libpng has
166  * been distributed and maintained world-wide, continually since 1995,
167  * the Copyright owners claim "common-law trademark protection" in any
168  * jurisdiction where common-law trademark is recognized.
169  */
170 
171 /*
172  * A "png_get_copyright" function is available, for convenient use in "about"
173  * boxes and the like:
174  *
175  * printf("%s", png_get_copyright(NULL));
176  *
177  * Also, the PNG logo (in PNG format, of course) is supplied in the
178  * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
179  */
180 
181 /*
182  * The contributing authors would like to thank all those who helped
183  * with testing, bug fixes, and patience. This wouldn't have been
184  * possible without all of you.
185  *
186  * Thanks to Frank J. T. Wojcik for helping with the documentation.
187  */
188 
189 /* Note about libpng version numbers:
190  *
191  * Due to various miscommunications, unforeseen code incompatibilities
192  * and occasional factors outside the authors' control, version numbering
193  * on the library has not always been consistent and straightforward.
194  * The following table summarizes matters since version 0.89c, which was
195  * the first widely used release:
196  *
197  * source png.h png.h shared-lib
198  * version string int version
199  * ------- ------ ----- ----------
200  * 0.89c "1.0 beta 3" 0.89 89 1.0.89
201  * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90]
202  * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95]
203  * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96]
204  * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97]
205  * 0.97c 0.97 97 2.0.97
206  * 0.98 0.98 98 2.0.98
207  * 0.99 0.99 98 2.0.99
208  * 0.99a-m 0.99 99 2.0.99
209  * 1.00 1.00 100 2.1.0 [100 should be 10000]
210  * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000]
211  * 1.0.1 png.h string is 10001 2.1.0
212  * 1.0.1a-e identical to the 10002 from here on, the shared library
213  * 1.0.2 source version) 10002 is 2.V where V is the source code
214  * 1.0.2a-b 10003 version, except as noted.
215  * 1.0.3 10003
216  * 1.0.3a-d 10004
217  * 1.0.4 10004
218  * 1.0.4a-f 10005
219  * 1.0.5 (+ 2 patches) 10005
220  * 1.0.5a-d 10006
221  * 1.0.5e-r 10100 (not source compatible)
222  * 1.0.5s-v 10006 (not binary compatible)
223  * 1.0.6 (+ 3 patches) 10006 (still binary incompatible)
224  * 1.0.6d-f 10007 (still binary incompatible)
225  * 1.0.6g 10007
226  * 1.0.6h 10007 10.6h (testing xy.z so-numbering)
227  * 1.0.6i 10007 10.6i
228  * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0)
229  * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible)
230  * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible)
231  * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible)
232  * 1.0.7 1 10007 (still compatible)
233  * ...
234  * 1.0.69 10 10069 10.so.0.69[.0]
235  * ...
236  * 1.2.59 13 10259 12.so.0.59[.0]
237  * ...
238  * 1.4.20 14 10420 14.so.0.20[.0]
239  * ...
240  * 1.5.30 15 10530 15.so.15.30[.0]
241  * ...
242  * 1.6.37 16 10637 16.so.16.37[.0]
243  *
244  * Henceforth the source version will match the shared-library major and
245  * minor numbers; the shared-library major version number will be used for
246  * changes in backward compatibility, as it is intended.
247  * The PNG_LIBPNG_VER macro, which is not used within libpng but is
248  * available for applications, is an unsigned integer of the form XYYZZ
249  * corresponding to the source version X.Y.Z (leading zeros in Y and Z).
250  * Beta versions were given the previous public release number plus a
251  * letter, until version 1.0.6j; from then on they were given the upcoming
252  * public release number plus "betaNN" or "rcNN".
253  *
254  * Binary incompatibility exists only when applications make direct access
255  * to the info_ptr or png_ptr members through png.h, and the compiled
256  * application is loaded with a different version of the library.
257  *
258  * DLLNUM will change each time there are forward or backward changes
259  * in binary compatibility (e.g., when a new feature is added).
260  *
261  * See libpng.txt or libpng.3 for more information. The PNG specification
262  * is available as a W3C Recommendation and as an ISO/IEC Standard; see
263  * <https://www.w3.org/TR/2003/REC-PNG-20031110/>
264  */
265 
266 #ifndef PNG_H
267 #define PNG_H
268 
269 /* This is not the place to learn how to use libpng. The file libpng-manual.txt
270  * describes how to use libpng, and the file example.c summarizes it
271  * with some code on which to build. This file is useful for looking
272  * at the actual function definitions and structure components. If that
273  * file has been stripped from your copy of libpng, you can find it at
274  * <http://www.libpng.org/pub/png/libpng-manual.txt>
275  *
276  * If you just need to read a PNG file and don't want to read the documentation
277  * skip to the end of this file and read the section entitled 'simplified API'.
278  */
279 
280 /* Version information for png.h - this should match the version in png.c */
281 #define PNG_LIBPNG_VER_STRING "1.6.37"
282 #define PNG_HEADER_VERSION_STRING " libpng version 1.6.37 - April 14, 2019\n"
283 
284 #define PNG_LIBPNG_VER_SONUM 16
285 #define PNG_LIBPNG_VER_DLLNUM 16
286 
287 /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
288 #define PNG_LIBPNG_VER_MAJOR 1
289 #define PNG_LIBPNG_VER_MINOR 6
290 #define PNG_LIBPNG_VER_RELEASE 37
291 
292 /* This should be zero for a public release, or non-zero for a
293  * development version. [Deprecated]
294  */
295 #define PNG_LIBPNG_VER_BUILD 0
296 
297 /* Release Status */
298 #define PNG_LIBPNG_BUILD_ALPHA 1
299 #define PNG_LIBPNG_BUILD_BETA 2
300 #define PNG_LIBPNG_BUILD_RC 3
301 #define PNG_LIBPNG_BUILD_STABLE 4
302 #define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7
303 
304 /* Release-Specific Flags */
305 #define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with
306  PNG_LIBPNG_BUILD_STABLE only */
307 #define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with
308  PNG_LIBPNG_BUILD_SPECIAL */
309 #define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
310  PNG_LIBPNG_BUILD_PRIVATE */
311 
312 #define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE
313 
314 /* Careful here. At one time, Guy wanted to use 082, but that
315  * would be octal. We must not include leading zeros.
316  * Versions 0.7 through 1.0.0 were in the range 0 to 100 here
317  * (only version 1.0.0 was mis-numbered 100 instead of 10000).
318  * From version 1.0.1 it is:
319  * XXYYZZ, where XX=major, YY=minor, ZZ=release
320  */
321 #define PNG_LIBPNG_VER 10637 /* 1.6.37 */
322 
323 /* Library configuration: these options cannot be changed after
324  * the library has been built.
325  */
326 #ifndef PNGLCONF_H
327 /* If pnglibconf.h is missing, you can
328  * copy scripts/pnglibconf.h.prebuilt to pnglibconf.h
329  */
330 # include "pnglibconf.h"
331 #endif
332 
333 #ifndef PNG_VERSION_INFO_ONLY
334 /* Machine specific configuration. */
335 # include "pngconf.h"
336 #endif
337 
338 /*
339  * Added at libpng-1.2.8
340  *
341  * Ref MSDN: Private as priority over Special
342  * VS_FF_PRIVATEBUILD File *was not* built using standard release
343  * procedures. If this value is given, the StringFileInfo block must
344  * contain a PrivateBuild string.
345  *
346  * VS_FF_SPECIALBUILD File *was* built by the original company using
347  * standard release procedures but is a variation of the standard
348  * file of the same version number. If this value is given, the
349  * StringFileInfo block must contain a SpecialBuild string.
350  */
351 
352 #ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */
353 # define PNG_LIBPNG_BUILD_TYPE \
354  (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE)
355 #else
356 # ifdef PNG_LIBPNG_SPECIALBUILD
357 # define PNG_LIBPNG_BUILD_TYPE \
358  (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL)
359 # else
360 # define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)
361 # endif
362 #endif
363 
364 #ifndef PNG_VERSION_INFO_ONLY
365 
366 /* Inhibit C++ name-mangling for libpng functions but not for system calls. */
367 #ifdef __cplusplus
368 extern "C" {
369 #endif /* __cplusplus */
370 
371 /* Version information for C files, stored in png.c. This had better match
372  * the version above.
373  */
374 #define png_libpng_ver png_get_header_ver(NULL)
375 
376 /* This file is arranged in several sections:
377  *
378  * 1. [omitted]
379  * 2. Any configuration options that can be specified by for the application
380  * code when it is built. (Build time configuration is in pnglibconf.h)
381  * 3. Type definitions (base types are defined in pngconf.h), structure
382  * definitions.
383  * 4. Exported library functions.
384  * 5. Simplified API.
385  * 6. Implementation options.
386  *
387  * The library source code has additional files (principally pngpriv.h) that
388  * allow configuration of the library.
389  */
390 
391 /* Section 1: [omitted] */
392 
393 /* Section 2: run time configuration
394  * See pnglibconf.h for build time configuration
395  *
396  * Run time configuration allows the application to choose between
397  * implementations of certain arithmetic APIs. The default is set
398  * at build time and recorded in pnglibconf.h, but it is safe to
399  * override these (and only these) settings. Note that this won't
400  * change what the library does, only application code, and the
401  * settings can (and probably should) be made on a per-file basis
402  * by setting the #defines before including png.h
403  *
404  * Use macros to read integers from PNG data or use the exported
405  * functions?
406  * PNG_USE_READ_MACROS: use the macros (see below) Note that
407  * the macros evaluate their argument multiple times.
408  * PNG_NO_USE_READ_MACROS: call the relevant library function.
409  *
410  * Use the alternative algorithm for compositing alpha samples that
411  * does not use division?
412  * PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division'
413  * algorithm.
414  * PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm.
415  *
416  * How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is
417  * false?
418  * PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error
419  * APIs to png_warning.
420  * Otherwise the calls are mapped to png_error.
421  */
422 
423 /* Section 3: type definitions, including structures and compile time
424  * constants.
425  * See pngconf.h for base types that vary by machine/system
426  */
427 
428 /* This triggers a compiler error in png.c, if png.c and png.h
429  * do not agree upon the version number.
430  */
432 
433 /* Basic control structions. Read libpng-manual.txt or libpng.3 for more info.
434  *
435  * png_struct is the cache of information used while reading or writing a single
436  * PNG file. One of these is always required, although the simplified API
437  * (below) hides the creation and destruction of it.
438  */
439 typedef struct png_struct_def png_struct;
443 
444 /* png_info contains information read from or to be written to a PNG file. One
445  * or more of these must exist while reading or creating a PNG file. The
446  * information is not used by libpng during read but is used to control what
447  * gets written when a PNG file is created. "png_get_" function calls read
448  * information during read and "png_set_" functions calls write information
449  * when creating a PNG.
450  * been moved into a separate header file that is not accessible to
451  * applications. Read libpng-manual.txt or libpng.3 for more info.
452  */
453 typedef struct png_info_def png_info;
454 typedef png_info * png_infop;
455 typedef const png_info * png_const_infop;
456 typedef png_info * * png_infopp;
457 
458 /* Types with names ending 'p' are pointer types. The corresponding types with
459  * names ending 'rp' are identical pointer types except that the pointer is
460  * marked 'restrict', which means that it is the only pointer to the object
461  * passed to the function. Applications should not use the 'restrict' types;
462  * it is always valid to pass 'p' to a pointer with a function argument of the
463  * corresponding 'rp' type. Different compilers have different rules with
464  * regard to type matching in the presence of 'restrict'. For backward
465  * compatibility libpng callbacks never have 'restrict' in their parameters and,
466  * consequentially, writing portable application code is extremely difficult if
467  * an attempt is made to use 'restrict'.
468  */
473 
474 /* Three color definitions. The order of the red, green, and blue, (and the
475  * exact size) is not important, although the size of the fields need to
476  * be png_byte or png_uint_16 (as defined below).
477  */
478 typedef struct png_color_struct
479 {
480  png_byte red;
481  png_byte green;
482  png_byte blue;
483 } png_color;
485 typedef const png_color * png_const_colorp;
486 typedef png_color * * png_colorpp;
487 
488 typedef struct png_color_16_struct
489 {
490  png_byte index; /* used for palette files */
491  png_uint_16 red; /* for use in red green blue files */
492  png_uint_16 green;
493  png_uint_16 blue;
494  png_uint_16 gray; /* for use in grayscale files */
495 } png_color_16;
499 
500 typedef struct png_color_8_struct
501 {
502  png_byte red; /* for use in red green blue files */
503  png_byte green;
504  png_byte blue;
505  png_byte gray; /* for use in grayscale files */
506  png_byte alpha; /* for alpha channel files */
507 } png_color_8;
511 
512 /*
513  * The following two structures are used for the in-core representation
514  * of sPLT chunks.
515  */
516 typedef struct png_sPLT_entry_struct
517 {
518  png_uint_16 red;
519  png_uint_16 green;
520  png_uint_16 blue;
521  png_uint_16 alpha;
522  png_uint_16 frequency;
527 
528 /* When the depth of the sPLT palette is 8 bits, the color and alpha samples
529  * occupy the LSB of their respective members, and the MSB of each member
530  * is zero-filled. The frequency member always occupies the full 16 bits.
531  */
532 
533 typedef struct png_sPLT_struct
534 {
535  png_charp name; /* palette name */
536  png_byte depth; /* depth of palette samples */
537  png_sPLT_entryp entries; /* palette entries */
538  png_int_32 nentries; /* number of palette entries */
539 } png_sPLT_t;
543 
544 #ifdef PNG_TEXT_SUPPORTED
545 /* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,
546  * and whether that contents is compressed or not. The "key" field
547  * points to a regular zero-terminated C string. The "text" fields can be a
548  * regular C string, an empty string, or a NULL pointer.
549  * However, the structure returned by png_get_text() will always contain
550  * the "text" field as a regular zero-terminated C string (possibly
551  * empty), never a NULL pointer, so it can be safely used in printf() and
552  * other string-handling functions. Note that the "itxt_length", "lang", and
553  * "lang_key" members of the structure only exist when the library is built
554  * with iTXt chunk support. Prior to libpng-1.4.0 the library was built by
555  * default without iTXt support. Also note that when iTXt *is* supported,
556  * the "lang" and "lang_key" fields contain NULL pointers when the
557  * "compression" field contains * PNG_TEXT_COMPRESSION_NONE or
558  * PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the
559  * same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag"
560  * which is always 0 or 1, or its "compression method" which is always 0.
561  */
562 typedef struct png_text_struct
563 {
564  int compression; /* compression value:
565  -1: tEXt, none
566  0: zTXt, deflate
567  1: iTXt, none
568  2: iTXt, deflate */
569  png_charp key; /* keyword, 1-79 character description of "text" */
570  png_charp text; /* comment, may be an empty string (ie "")
571  or a NULL pointer */
572  size_t text_length; /* length of the text string */
573  size_t itxt_length; /* length of the itxt string */
574  png_charp lang; /* language code, 0-79 characters
575  or a NULL pointer */
576  png_charp lang_key; /* keyword translated UTF-8 string, 0 or more
577  chars or a NULL pointer */
578 } png_text;
579 typedef png_text * png_textp;
580 typedef const png_text * png_const_textp;
581 typedef png_text * * png_textpp;
582 #endif
583 
584 /* Supported compression types for text in PNG files (tEXt, and zTXt).
585  * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */
586 #define PNG_TEXT_COMPRESSION_NONE_WR -3
587 #define PNG_TEXT_COMPRESSION_zTXt_WR -2
588 #define PNG_TEXT_COMPRESSION_NONE -1
589 #define PNG_TEXT_COMPRESSION_zTXt 0
590 #define PNG_ITXT_COMPRESSION_NONE 1
591 #define PNG_ITXT_COMPRESSION_zTXt 2
592 #define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */
593 
594 /* png_time is a way to hold the time in an machine independent way.
595  * Two conversions are provided, both from time_t and struct tm. There
596  * is no portable way to convert to either of these structures, as far
597  * as I know. If you know of a portable way, send it to me. As a side
598  * note - PNG has always been Year 2000 compliant!
599  */
600 typedef struct png_time_struct
601 {
602  png_uint_16 year; /* full year, as in, 1995 */
603  png_byte month; /* month of year, 1 - 12 */
604  png_byte day; /* day of month, 1 - 31 */
605  png_byte hour; /* hour of day, 0 - 23 */
606  png_byte minute; /* minute of hour, 0 - 59 */
607  png_byte second; /* second of minute, 0 - 60 (for leap seconds) */
608 } png_time;
609 typedef png_time * png_timep;
610 typedef const png_time * png_const_timep;
611 typedef png_time * * png_timepp;
612 
613 #if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) ||\
614  defined(PNG_USER_CHUNKS_SUPPORTED)
615 /* png_unknown_chunk is a structure to hold queued chunks for which there is
616  * no specific support. The idea is that we can use this to queue
617  * up private chunks for output even though the library doesn't actually
618  * know about their semantics.
619  *
620  * The data in the structure is set by libpng on read and used on write.
621  */
622 typedef struct png_unknown_chunk_t
623 {
624  png_byte name[5]; /* Textual chunk name with '\0' terminator */
625  png_byte *data; /* Data, should not be modified on read! */
626  size_t size;
627 
628  /* On write 'location' must be set using the flag values listed below.
629  * Notice that on read it is set by libpng however the values stored have
630  * more bits set than are listed below. Always treat the value as a
631  * bitmask. On write set only one bit - setting multiple bits may cause the
632  * chunk to be written in multiple places.
633  */
634  png_byte location; /* mode of operation at read time */
635 }
637 
641 #endif
642 
643 /* Flag values for the unknown chunk location byte. */
644 #define PNG_HAVE_IHDR 0x01
645 #define PNG_HAVE_PLTE 0x02
646 #define PNG_AFTER_IDAT 0x08
647 
648 /* Maximum positive integer used in PNG is (2^31)-1 */
649 #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
650 #define PNG_UINT_32_MAX ((png_uint_32)(-1))
651 #define PNG_SIZE_MAX ((size_t)(-1))
652 
653 /* These are constants for fixed point values encoded in the
654  * PNG specification manner (x100000)
655  */
656 #define PNG_FP_1 100000
657 #define PNG_FP_HALF 50000
658 #define PNG_FP_MAX ((png_fixed_point)0x7fffffffL)
659 #define PNG_FP_MIN (-PNG_FP_MAX)
660 
661 /* These describe the color_type field in png_info. */
662 /* color type masks */
663 #define PNG_COLOR_MASK_PALETTE 1
664 #define PNG_COLOR_MASK_COLOR 2
665 #define PNG_COLOR_MASK_ALPHA 4
666 
667 /* color types. Note that not all combinations are legal */
668 #define PNG_COLOR_TYPE_GRAY 0
669 #define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
670 #define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
671 #define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
672 #define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
673 /* aliases */
674 #define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA
675 #define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA
676 
677 /* This is for compression type. PNG 1.0-1.2 only define the single type. */
678 #define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */
679 #define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE
680 
681 /* This is for filter type. PNG 1.0-1.2 only define the single type. */
682 #define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */
683 #define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */
684 #define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE
685 
686 /* These are for the interlacing type. These values should NOT be changed. */
687 #define PNG_INTERLACE_NONE 0 /* Non-interlaced image */
688 #define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */
689 #define PNG_INTERLACE_LAST 2 /* Not a valid value */
690 
691 /* These are for the oFFs chunk. These values should NOT be changed. */
692 #define PNG_OFFSET_PIXEL 0 /* Offset in pixels */
693 #define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */
694 #define PNG_OFFSET_LAST 2 /* Not a valid value */
695 
696 /* These are for the pCAL chunk. These values should NOT be changed. */
697 #define PNG_EQUATION_LINEAR 0 /* Linear transformation */
698 #define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */
699 #define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */
700 #define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */
701 #define PNG_EQUATION_LAST 4 /* Not a valid value */
702 
703 /* These are for the sCAL chunk. These values should NOT be changed. */
704 #define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */
705 #define PNG_SCALE_METER 1 /* meters per pixel */
706 #define PNG_SCALE_RADIAN 2 /* radians per pixel */
707 #define PNG_SCALE_LAST 3 /* Not a valid value */
708 
709 /* These are for the pHYs chunk. These values should NOT be changed. */
710 #define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */
711 #define PNG_RESOLUTION_METER 1 /* pixels/meter */
712 #define PNG_RESOLUTION_LAST 2 /* Not a valid value */
713 
714 /* These are for the sRGB chunk. These values should NOT be changed. */
715 #define PNG_sRGB_INTENT_PERCEPTUAL 0
716 #define PNG_sRGB_INTENT_RELATIVE 1
717 #define PNG_sRGB_INTENT_SATURATION 2
718 #define PNG_sRGB_INTENT_ABSOLUTE 3
719 #define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */
720 
721 /* This is for text chunks */
722 #define PNG_KEYWORD_MAX_LENGTH 79
723 
724 /* Maximum number of entries in PLTE/sPLT/tRNS arrays */
725 #define PNG_MAX_PALETTE_LENGTH 256
726 
727 /* These determine if an ancillary chunk's data has been successfully read
728  * from the PNG header, or if the application has filled in the corresponding
729  * data in the info_struct to be written into the output file. The values
730  * of the PNG_INFO_<chunk> defines should NOT be changed.
731  */
732 #define PNG_INFO_gAMA 0x0001U
733 #define PNG_INFO_sBIT 0x0002U
734 #define PNG_INFO_cHRM 0x0004U
735 #define PNG_INFO_PLTE 0x0008U
736 #define PNG_INFO_tRNS 0x0010U
737 #define PNG_INFO_bKGD 0x0020U
738 #define PNG_INFO_hIST 0x0040U
739 #define PNG_INFO_pHYs 0x0080U
740 #define PNG_INFO_oFFs 0x0100U
741 #define PNG_INFO_tIME 0x0200U
742 #define PNG_INFO_pCAL 0x0400U
743 #define PNG_INFO_sRGB 0x0800U /* GR-P, 0.96a */
744 #define PNG_INFO_iCCP 0x1000U /* ESR, 1.0.6 */
745 #define PNG_INFO_sPLT 0x2000U /* ESR, 1.0.6 */
746 #define PNG_INFO_sCAL 0x4000U /* ESR, 1.0.6 */
747 #define PNG_INFO_IDAT 0x8000U /* ESR, 1.0.6 */
748 #define PNG_INFO_eXIf 0x10000U /* GR-P, 1.6.31 */
749 
750 /* This is used for the transformation routines, as some of them
751  * change these values for the row. It also should enable using
752  * the routines for other purposes.
753  */
754 typedef struct png_row_info_struct
755 {
756  png_uint_32 width; /* width of row */
757  size_t rowbytes; /* number of bytes in row */
758  png_byte color_type; /* color type of row */
759  png_byte bit_depth; /* bit depth of row */
760  png_byte channels; /* number of channels (1, 2, 3, or 4) */
761  png_byte pixel_depth; /* bits per pixel (depth * channels) */
762 } png_row_info;
763 
766 
767 /* These are the function types for the I/O functions and for the functions
768  * that allow the user to override the default I/O functions with his or her
769  * own. The png_error_ptr type should match that of user-supplied warning
770  * and error functions, while the png_rw_ptr type should match that of the
771  * user read/write data functions. Note that the 'write' function must not
772  * modify the buffer it is passed. The 'read' function, on the other hand, is
773  * expected to return the read data in the buffer.
774  */
775 typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp));
776 typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, size_t));
777 typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp));
778 typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32,
779  int));
780 typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32,
781  int));
782 
783 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
784 typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop));
785 typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop));
786 
787 /* The following callback receives png_uint_32 row_number, int pass for the
788  * png_bytep data of the row. When transforming an interlaced image the
789  * row number is the row number within the sub-image of the interlace pass, so
790  * the value will increase to the height of the sub-image (not the full image)
791  * then reset to 0 for the next pass.
792  *
793  * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
794  * find the output pixel (x,y) given an interlaced sub-image pixel
795  * (row,col,pass). (See below for these macros.)
796  */
797 typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep,
798  png_uint_32, int));
799 #endif
800 
801 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
802  defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
803 typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop,
804  png_bytep));
805 #endif
806 
807 #ifdef PNG_USER_CHUNKS_SUPPORTED
808 typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp,
810 #endif
811 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
812 /* not used anywhere */
813 /* typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); */
814 #endif
815 
816 #ifdef PNG_SETJMP_SUPPORTED
817 /* This must match the function definition in <setjmp.h>, and the application
818  * must include this before png.h to obtain the definition of jmp_buf. The
819  * function is required to be PNG_NORETURN, but this is not checked. If the
820  * function does return the application will crash via an abort() or similar
821  * system level call.
822  *
823  * If you get a warning here while building the library you may need to make
824  * changes to ensure that pnglibconf.h records the calling convention used by
825  * your compiler. This may be very difficult - try using a different compiler
826  * to build the library!
827  */
828 PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef);
829 #endif
830 
831 /* Transform masks for the high-level interface */
832 #define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */
833 #define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */
834 #define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */
835 #define PNG_TRANSFORM_PACKING 0x0004 /* read and write */
836 #define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */
837 #define PNG_TRANSFORM_EXPAND 0x0010 /* read only */
838 #define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */
839 #define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */
840 #define PNG_TRANSFORM_BGR 0x0080 /* read and write */
841 #define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */
842 #define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */
843 #define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */
844 #define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */
845 /* Added to libpng-1.2.34 */
846 #define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER
847 #define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */
848 /* Added to libpng-1.4.0 */
849 #define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */
850 /* Added to libpng-1.5.4 */
851 #define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */
852 #if INT_MAX >= 0x8000 /* else this might break */
853 #define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */
854 #endif
855 
856 /* Flags for MNG supported features */
857 #define PNG_FLAG_MNG_EMPTY_PLTE 0x01
858 #define PNG_FLAG_MNG_FILTER_64 0x04
859 #define PNG_ALL_MNG_FEATURES 0x05
860 
861 /* NOTE: prior to 1.5 these functions had no 'API' style declaration,
862  * this allowed the zlib default functions to be used on Windows
863  * platforms. In 1.5 the zlib default malloc (which just calls malloc and
864  * ignores the first argument) should be completely compatible with the
865  * following.
866  */
867 typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp,
869 typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp));
870 
871 /* Section 4: exported functions
872  * Here are the function definitions most commonly used. This is not
873  * the place to find out how to use libpng. See libpng-manual.txt for the
874  * full explanation, see example.c for the summary. This just provides
875  * a simple one line description of the use of each function.
876  *
877  * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in
878  * pngconf.h and in the *.dfn files in the scripts directory.
879  *
880  * PNG_EXPORT(ordinal, type, name, (args));
881  *
882  * ordinal: ordinal that is used while building
883  * *.def files. The ordinal value is only
884  * relevant when preprocessing png.h with
885  * the *.dfn files for building symbol table
886  * entries, and are removed by pngconf.h.
887  * type: return type of the function
888  * name: function name
889  * args: function arguments, with types
890  *
891  * When we wish to append attributes to a function prototype we use
892  * the PNG_EXPORTA() macro instead.
893  *
894  * PNG_EXPORTA(ordinal, type, name, (args), attributes);
895  *
896  * ordinal, type, name, and args: same as in PNG_EXPORT().
897  * attributes: function attributes
898  */
899 
900 /* Returns the version number of the library */
902 
903 /* Tell lib we have already handled the first <num_bytes> magic bytes.
904  * Handling more than 8 bytes from the beginning of the file is an error.
905  */
906 PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes));
907 
908 /* Check sig[start] through sig[start + num_to_check - 1] to see if it's a
909  * PNG file. Returns zero if the supplied bytes match the 8-byte PNG
910  * signature, and non-zero otherwise. Having num_to_check == 0 or
911  * start > 7 will always fail (ie return non-zero).
912  */
913 PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, size_t start,
914  size_t num_to_check));
915 
916 /* Simple signature checking function. This is the same as calling
917  * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).
918  */
919 #define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n))
920 
921 /* Allocate and initialize png_ptr struct for reading, and any other memory. */
922 PNG_EXPORTA(4, png_structp, png_create_read_struct,
923  (png_const_charp user_png_ver, png_voidp error_ptr,
924  png_error_ptr error_fn, png_error_ptr warn_fn),
925  PNG_ALLOCATED);
926 
927 /* Allocate and initialize png_ptr struct for writing, and any other memory */
928 PNG_EXPORTA(5, png_structp, png_create_write_struct,
929  (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
930  png_error_ptr warn_fn),
931  PNG_ALLOCATED);
932 
933 PNG_EXPORT(6, size_t, png_get_compression_buffer_size,
935 
936 PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr,
937  size_t size));
938 
939 /* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
940  * match up.
941  */
942 #ifdef PNG_SETJMP_SUPPORTED
943 /* This function returns the jmp_buf built in to *png_ptr. It must be
944  * supplied with an appropriate 'longjmp' function to use on that jmp_buf
945  * unless the default error function is overridden in which case NULL is
946  * acceptable. The size of the jmp_buf is checked against the actual size
947  * allocated by the library - the call will return NULL on a mismatch
948  * indicating an ABI mismatch.
949  */
950 PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr,
951  png_longjmp_ptr longjmp_fn, size_t jmp_buf_size));
952 # define png_jmpbuf(png_ptr) \
953  (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf))))
954 #else
955 # define png_jmpbuf(png_ptr) \
956  (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP)
957 #endif
958 /* This function should be used by libpng applications in place of
959  * longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it
960  * will use it; otherwise it will call PNG_ABORT(). This function was
961  * added in libpng-1.5.0.
962  */
963 PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val),
964  PNG_NORETURN);
965 
966 #ifdef PNG_READ_SUPPORTED
967 /* Reset the compression stream */
968 PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED);
969 #endif
970 
971 /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
972 #ifdef PNG_USER_MEM_SUPPORTED
973 PNG_EXPORTA(11, png_structp, png_create_read_struct_2,
974  (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
975  png_error_ptr warn_fn,
976  png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
977  PNG_ALLOCATED);
978 PNG_EXPORTA(12, png_structp, png_create_write_struct_2,
979  (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
980  png_error_ptr warn_fn,
981  png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
982  PNG_ALLOCATED);
983 #endif
984 
985 /* Write the PNG file signature. */
986 PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr));
987 
988 /* Write a PNG chunk - size, type, (optional) data, CRC. */
989 PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep
990  chunk_name, png_const_bytep data, size_t length));
991 
992 /* Write the start of a PNG chunk - length and chunk name. */
993 PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
994  png_const_bytep chunk_name, png_uint_32 length));
995 
996 /* Write the data of a PNG chunk started with png_write_chunk_start(). */
997 PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr,
998  png_const_bytep data, size_t length));
999 
1000 /* Finish a chunk started with png_write_chunk_start() (includes CRC). */
1001 PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
1002 
1003 /* Allocate and initialize the info structure */
1004 PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr),
1005  PNG_ALLOCATED);
1006 
1007 /* DEPRECATED: this function allowed init structures to be created using the
1008  * default allocation method (typically malloc). Use is deprecated in 1.6.0 and
1009  * the API will be removed in the future.
1010  */
1011 PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr,
1012  size_t png_info_struct_size), PNG_DEPRECATED);
1013 
1014 /* Writes all the PNG information before the image. */
1015 PNG_EXPORT(20, void, png_write_info_before_PLTE,
1017 PNG_EXPORT(21, void, png_write_info,
1019 
1020 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1021 /* Read the information before the actual image data. */
1022 PNG_EXPORT(22, void, png_read_info,
1024 #endif
1025 
1026 #ifdef PNG_TIME_RFC1123_SUPPORTED
1027  /* Convert to a US string format: there is no localization support in this
1028  * routine. The original implementation used a 29 character buffer in
1029  * png_struct, this will be removed in future versions.
1030  */
1031 #if PNG_LIBPNG_VER < 10700
1032 /* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */
1033 PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr,
1035 #endif
1036 PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29],
1037  png_const_timep ptime));
1038 #endif
1039 
1040 #ifdef PNG_CONVERT_tIME_SUPPORTED
1041 /* Convert from a struct tm to png_time */
1042 PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime,
1043  const struct tm * ttime));
1044 
1045 /* Convert from time_t to png_time. Uses gmtime() */
1046 PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime));
1047 #endif /* CONVERT_tIME */
1048 
1049 #ifdef PNG_READ_EXPAND_SUPPORTED
1050 /* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
1051 PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr));
1052 PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr));
1053 PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr));
1054 PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr));
1055 #endif
1056 
1057 #ifdef PNG_READ_EXPAND_16_SUPPORTED
1058 /* Expand to 16-bit channels, forces conversion of palette to RGB and expansion
1059  * of a tRNS chunk if present.
1060  */
1061 PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr));
1062 #endif
1063 
1064 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
1065 /* Use blue, green, red order for pixels. */
1066 PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr));
1067 #endif
1068 
1069 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
1070 /* Expand the grayscale to 24-bit RGB if necessary. */
1071 PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr));
1072 #endif
1073 
1074 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1075 /* Reduce RGB to grayscale. */
1076 #define PNG_ERROR_ACTION_NONE 1
1077 #define PNG_ERROR_ACTION_WARN 2
1078 #define PNG_ERROR_ACTION_ERROR 3
1079 #define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/
1080 
1081 PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr,
1082  int error_action, double red, double green))
1085 
1086 PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structrp
1087  png_ptr));
1088 #endif
1089 
1090 #ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
1091 PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth,
1092  png_colorp palette));
1093 #endif
1094 
1095 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
1096 /* How the alpha channel is interpreted - this affects how the color channels
1097  * of a PNG file are returned to the calling application when an alpha channel,
1098  * or a tRNS chunk in a palette file, is present.
1099  *
1100  * This has no effect on the way pixels are written into a PNG output
1101  * datastream. The color samples in a PNG datastream are never premultiplied
1102  * with the alpha samples.
1103  *
1104  * The default is to return data according to the PNG specification: the alpha
1105  * channel is a linear measure of the contribution of the pixel to the
1106  * corresponding composited pixel, and the color channels are unassociated
1107  * (not premultiplied). The gamma encoded color channels must be scaled
1108  * according to the contribution and to do this it is necessary to undo
1109  * the encoding, scale the color values, perform the composition and re-encode
1110  * the values. This is the 'PNG' mode.
1111  *
1112  * The alternative is to 'associate' the alpha with the color information by
1113  * storing color channel values that have been scaled by the alpha.
1114  * image. These are the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' modes
1115  * (the latter being the two common names for associated alpha color channels).
1116  *
1117  * For the 'OPTIMIZED' mode, a pixel is treated as opaque only if the alpha
1118  * value is equal to the maximum value.
1119  *
1120  * The final choice is to gamma encode the alpha channel as well. This is
1121  * broken because, in practice, no implementation that uses this choice
1122  * correctly undoes the encoding before handling alpha composition. Use this
1123  * choice only if other serious errors in the software or hardware you use
1124  * mandate it; the typical serious error is for dark halos to appear around
1125  * opaque areas of the composited PNG image because of arithmetic overflow.
1126  *
1127  * The API function png_set_alpha_mode specifies which of these choices to use
1128  * with an enumerated 'mode' value and the gamma of the required output:
1129  */
1130 #define PNG_ALPHA_PNG 0 /* according to the PNG standard */
1131 #define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */
1132 #define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */
1133 #define PNG_ALPHA_PREMULTIPLIED 1 /* as above */
1134 #define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */
1135 #define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */
1136 
1137 PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structrp png_ptr, int mode,
1138  double output_gamma))
1140  int mode, png_fixed_point output_gamma))
1141 #endif
1142 
1143 #if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED)
1144 /* The output_gamma value is a screen gamma in libpng terminology: it expresses
1145  * how to decode the output values, not how they are encoded.
1146  */
1147 #define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */
1148 #define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */
1149 #define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */
1150 #define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */
1151 #endif
1152 
1153 /* The following are examples of calls to png_set_alpha_mode to achieve the
1154  * required overall gamma correction and, where necessary, alpha
1155  * premultiplication.
1156  *
1157  * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
1158  * This is the default libpng handling of the alpha channel - it is not
1159  * pre-multiplied into the color components. In addition the call states
1160  * that the output is for a sRGB system and causes all PNG files without gAMA
1161  * chunks to be assumed to be encoded using sRGB.
1162  *
1163  * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
1164  * In this case the output is assumed to be something like an sRGB conformant
1165  * display preceded by a power-law lookup table of power 1.45. This is how
1166  * early Mac systems behaved.
1167  *
1168  * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
1169  * This is the classic Jim Blinn approach and will work in academic
1170  * environments where everything is done by the book. It has the shortcoming
1171  * of assuming that input PNG data with no gamma information is linear - this
1172  * is unlikely to be correct unless the PNG files where generated locally.
1173  * Most of the time the output precision will be so low as to show
1174  * significant banding in dark areas of the image.
1175  *
1176  * png_set_expand_16(pp);
1177  * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB);
1178  * This is a somewhat more realistic Jim Blinn inspired approach. PNG files
1179  * are assumed to have the sRGB encoding if not marked with a gamma value and
1180  * the output is always 16 bits per component. This permits accurate scaling
1181  * and processing of the data. If you know that your input PNG files were
1182  * generated locally you might need to replace PNG_DEFAULT_sRGB with the
1183  * correct value for your system.
1184  *
1185  * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);
1186  * If you just need to composite the PNG image onto an existing background
1187  * and if you control the code that does this you can use the optimization
1188  * setting. In this case you just copy completely opaque pixels to the
1189  * output. For pixels that are not completely transparent (you just skip
1190  * those) you do the composition math using png_composite or png_composite_16
1191  * below then encode the resultant 8-bit or 16-bit values to match the output
1192  * encoding.
1193  *
1194  * Other cases
1195  * If neither the PNG nor the standard linear encoding work for you because
1196  * of the software or hardware you use then you have a big problem. The PNG
1197  * case will probably result in halos around the image. The linear encoding
1198  * will probably result in a washed out, too bright, image (it's actually too
1199  * contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably
1200  * substantially reduce the halos. Alternatively try:
1201  *
1202  * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB);
1203  * This option will also reduce the halos, but there will be slight dark
1204  * halos round the opaque parts of the image where the background is light.
1205  * In the OPTIMIZED mode the halos will be light halos where the background
1206  * is dark. Take your pick - the halos are unavoidable unless you can get
1207  * your hardware/software fixed! (The OPTIMIZED approach is slightly
1208  * faster.)
1209  *
1210  * When the default gamma of PNG files doesn't match the output gamma.
1211  * If you have PNG files with no gamma information png_set_alpha_mode allows
1212  * you to provide a default gamma, but it also sets the output gamma to the
1213  * matching value. If you know your PNG files have a gamma that doesn't
1214  * match the output you can take advantage of the fact that
1215  * png_set_alpha_mode always sets the output gamma but only sets the PNG
1216  * default if it is not already set:
1217  *
1218  * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
1219  * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
1220  * The first call sets both the default and the output gamma values, the
1221  * second call overrides the output gamma without changing the default. This
1222  * is easier than achieving the same effect with png_set_gamma. You must use
1223  * PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will
1224  * fire if more than one call to png_set_alpha_mode and png_set_background is
1225  * made in the same read operation, however multiple calls with PNG_ALPHA_PNG
1226  * are ignored.
1227  */
1228 
1229 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
1230 PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr));
1231 #endif
1232 
1233 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
1234  defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
1235 PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr));
1236 #endif
1237 
1238 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
1239  defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
1240 PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr));
1241 #endif
1242 
1243 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
1244 /* Add a filler byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */
1245 PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler,
1246  int flags));
1247 /* The values of the PNG_FILLER_ defines should NOT be changed */
1248 # define PNG_FILLER_BEFORE 0
1249 # define PNG_FILLER_AFTER 1
1250 /* Add an alpha byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */
1251 PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr,
1252  png_uint_32 filler, int flags));
1253 #endif /* READ_FILLER || WRITE_FILLER */
1254 
1255 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
1256 /* Swap bytes in 16-bit depth files. */
1257 PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr));
1258 #endif
1259 
1260 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
1261 /* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */
1262 PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr));
1263 #endif
1264 
1265 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
1266  defined(PNG_WRITE_PACKSWAP_SUPPORTED)
1267 /* Swap packing order of pixels in bytes. */
1268 PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr));
1269 #endif
1270 
1271 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
1272 /* Converts files to legal bit depths. */
1273 PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p
1274  true_bits));
1275 #endif
1276 
1277 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
1278  defined(PNG_WRITE_INTERLACING_SUPPORTED)
1279 /* Have the code handle the interlacing. Returns the number of passes.
1280  * MUST be called before png_read_update_info or png_start_read_image,
1281  * otherwise it will not have the desired effect. Note that it is still
1282  * necessary to call png_read_row or png_read_rows png_get_image_height
1283  * times for each pass.
1284 */
1285 PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr));
1286 #endif
1287 
1288 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
1289 /* Invert monochrome files */
1290 PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr));
1291 #endif
1292 
1293 #ifdef PNG_READ_BACKGROUND_SUPPORTED
1294 /* Handle alpha and tRNS by replacing with a background color. Prior to
1295  * libpng-1.5.4 this API must not be called before the PNG file header has been
1296  * read. Doing so will result in unexpected behavior and possible warnings or
1297  * errors if the PNG file contains a bKGD chunk.
1298  */
1299 PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr,
1301  int need_expand, double background_gamma))
1304  int need_expand, png_fixed_point background_gamma))
1305 #endif
1306 #ifdef PNG_READ_BACKGROUND_SUPPORTED
1307 # define PNG_BACKGROUND_GAMMA_UNKNOWN 0
1308 # define PNG_BACKGROUND_GAMMA_SCREEN 1
1309 # define PNG_BACKGROUND_GAMMA_FILE 2
1310 # define PNG_BACKGROUND_GAMMA_UNIQUE 3
1311 #endif
1312 
1313 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
1314 /* Scale a 16-bit depth file down to 8-bit, accurately. */
1315 PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr));
1316 #endif
1317 
1318 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
1319 #define PNG_READ_16_TO_8_SUPPORTED /* Name prior to 1.5.4 */
1320 /* Strip the second byte of information from a 16-bit depth file. */
1321 PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr));
1322 #endif
1323 
1324 #ifdef PNG_READ_QUANTIZE_SUPPORTED
1325 /* Turn on quantizing, and reduce the palette to the number of colors
1326  * available.
1327  */
1328 PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr,
1329  png_colorp palette, int num_palette, int maximum_colors,
1330  png_const_uint_16p histogram, int full_quantize));
1331 #endif
1332 
1333 #ifdef PNG_READ_GAMMA_SUPPORTED
1334 /* The threshold on gamma processing is configurable but hard-wired into the
1335  * library. The following is the floating point variant.
1336  */
1337 #define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001)
1338 
1339 /* Handle gamma correction. Screen_gamma=(display_exponent).
1340  * NOTE: this API simply sets the screen and file gamma values. It will
1341  * therefore override the value for gamma in a PNG file if it is called after
1342  * the file header has been read - use with care - call before reading the PNG
1343  * file for best results!
1344  *
1345  * These routines accept the same gamma values as png_set_alpha_mode (described
1346  * above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either
1347  * API (floating point or fixed.) Notice, however, that the 'file_gamma' value
1348  * is the inverse of a 'screen gamma' value.
1349  */
1350 PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr,
1351  double screen_gamma, double override_file_gamma))
1353  png_fixed_point screen_gamma, png_fixed_point override_file_gamma))
1354 #endif
1355 
1356 #ifdef PNG_WRITE_FLUSH_SUPPORTED
1357 /* Set how many lines between output flushes - 0 for no flushing */
1358 PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows));
1359 /* Flush the current PNG output buffer */
1360 PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr));
1361 #endif
1362 
1363 /* Optional update palette with requested transformations */
1364 PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr));
1365 
1366 /* Optional call to update the users info structure */
1367 PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr,
1368  png_inforp info_ptr));
1369 
1370 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1371 /* Read one or more rows of image data. */
1372 PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row,
1374 #endif
1375 
1376 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1377 /* Read a row of data. */
1378 PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row,
1380 #endif
1381 
1382 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1383 /* Read the whole image into memory at once. */
1384 PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image));
1385 #endif
1386 
1387 /* Write a row of image data */
1388 PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr,
1389  png_const_bytep row));
1390 
1391 /* Write a few rows of image data: (*row) is not written; however, the type
1392  * is declared as writeable to maintain compatibility with previous versions
1393  * of libpng and to allow the 'display_row' array from read_rows to be passed
1394  * unchanged to write_rows.
1395  */
1396 PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row,
1398 
1399 /* Write the image data */
1400 PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image));
1401 
1402 /* Write the end of the PNG file. */
1403 PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr,
1404  png_inforp info_ptr));
1405 
1406 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1407 /* Read the end of the PNG file. */
1408 PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr));
1409 #endif
1410 
1411 /* Free any memory associated with the png_info_struct */
1412 PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr,
1413  png_infopp info_ptr_ptr));
1414 
1415 /* Free any memory associated with the png_struct and the png_info_structs */
1416 PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr,
1417  png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));
1418 
1419 /* Free any memory associated with the png_struct and the png_info_structs */
1420 PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr,
1421  png_infopp info_ptr_ptr));
1422 
1423 /* Set the libpng method of handling chunk CRC errors */
1424 PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action,
1425  int ancil_action));
1426 
1427 /* Values for png_set_crc_action() say how to handle CRC errors in
1428  * ancillary and critical chunks, and whether to use the data contained
1429  * therein. Note that it is impossible to "discard" data in a critical
1430  * chunk. For versions prior to 0.90, the action was always error/quit,
1431  * whereas in version 0.90 and later, the action for CRC errors in ancillary
1432  * chunks is warn/discard. These values should NOT be changed.
1433  *
1434  * value action:critical action:ancillary
1435  */
1436 #define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */
1437 #define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */
1438 #define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */
1439 #define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */
1440 #define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */
1441 #define PNG_CRC_NO_CHANGE 5 /* use current value use current value */
1442 
1443 #ifdef PNG_WRITE_SUPPORTED
1444 /* These functions give the user control over the scan-line filtering in
1445  * libpng and the compression methods used by zlib. These functions are
1446  * mainly useful for testing, as the defaults should work with most users.
1447  * Those users who are tight on memory or want faster performance at the
1448  * expense of compression can modify them. See the compression library
1449  * header file (zlib.h) for an explination of the compression functions.
1450  */
1451 
1452 /* Set the filtering method(s) used by libpng. Currently, the only valid
1453  * value for "method" is 0.
1454  */
1455 PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
1456  int filters));
1457 #endif /* WRITE */
1458 
1459 /* Flags for png_set_filter() to say which filters to use. The flags
1460  * are chosen so that they don't conflict with real filter types
1461  * below, in case they are supplied instead of the #defined constants.
1462  * These values should NOT be changed.
1463  */
1464 #define PNG_NO_FILTERS 0x00
1465 #define PNG_FILTER_NONE 0x08
1466 #define PNG_FILTER_SUB 0x10
1467 #define PNG_FILTER_UP 0x20
1468 #define PNG_FILTER_AVG 0x40
1469 #define PNG_FILTER_PAETH 0x80
1470 #define PNG_FAST_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP)
1471 #define PNG_ALL_FILTERS (PNG_FAST_FILTERS | PNG_FILTER_AVG | PNG_FILTER_PAETH)
1472 
1473 /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
1474  * These defines should NOT be changed.
1475  */
1476 #define PNG_FILTER_VALUE_NONE 0
1477 #define PNG_FILTER_VALUE_SUB 1
1478 #define PNG_FILTER_VALUE_UP 2
1479 #define PNG_FILTER_VALUE_AVG 3
1480 #define PNG_FILTER_VALUE_PAETH 4
1481 #define PNG_FILTER_VALUE_LAST 5
1482 
1483 #ifdef PNG_WRITE_SUPPORTED
1484 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */
1485 PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr,
1487  png_const_doublep filter_costs))
1491  png_const_fixed_point_p filter_costs))
1492 #endif /* WRITE_WEIGHTED_FILTER */
1493 
1494 /* The following are no longer used and will be removed from libpng-1.7: */
1495 #define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */
1496 #define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */
1497 #define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */
1498 #define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */
1499 
1500 /* Set the library compression level. Currently, valid values range from
1501  * 0 - 9, corresponding directly to the zlib compression levels 0 - 9
1502  * (0 - no compression, 9 - "maximal" compression). Note that tests have
1503  * shown that zlib compression levels 3-6 usually perform as well as level 9
1504  * for PNG images, and do considerably fewer caclulations. In the future,
1505  * these values may not correspond directly to the zlib compression levels.
1506  */
1507 #ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
1508 PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr,
1509  int level));
1510 
1511 PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr,
1512  int mem_level));
1513 
1514 PNG_EXPORT(71, void, png_set_compression_strategy, (png_structrp png_ptr,
1515  int strategy));
1516 
1517 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
1518  * smaller value of window_bits if it can do so safely.
1519  */
1520 PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr,
1521  int window_bits));
1522 
1523 PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr,
1524  int method));
1525 #endif /* WRITE_CUSTOMIZE_COMPRESSION */
1526 
1527 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
1528 /* Also set zlib parameters for compressing non-IDAT chunks */
1529 PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr,
1530  int level));
1531 
1532 PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr,
1533  int mem_level));
1534 
1535 PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr,
1536  int strategy));
1537 
1538 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
1539  * smaller value of window_bits if it can do so safely.
1540  */
1541 PNG_EXPORT(225, void, png_set_text_compression_window_bits,
1542  (png_structrp png_ptr, int window_bits));
1543 
1544 PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr,
1545  int method));
1546 #endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
1547 #endif /* WRITE */
1548 
1549 /* These next functions are called for input/output, memory, and error
1550  * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c,
1551  * and call standard C I/O routines such as fread(), fwrite(), and
1552  * fprintf(). These functions can be made to use other I/O routines
1553  * at run time for those applications that need to handle I/O in a
1554  * different manner by calling png_set_???_fn(). See libpng-manual.txt for
1555  * more information.
1556  */
1557 
1558 #ifdef PNG_STDIO_SUPPORTED
1559 /* Initialize the input/output for the PNG file to the default functions. */
1560 PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp));
1561 #endif
1562 
1563 /* Replace the (error and abort), and warning functions with user
1564  * supplied functions. If no messages are to be printed you must still
1565  * write and use replacement functions. The replacement error_fn should
1566  * still do a longjmp to the last setjmp location if you are using this
1567  * method of error handling. If error_fn or warning_fn is NULL, the
1568  * default function will be used.
1569  */
1570 
1571 PNG_EXPORT(75, void, png_set_error_fn, (png_structrp png_ptr,
1572  png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));
1573 
1574 /* Return the user pointer associated with the error functions */
1575 PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr));
1576 
1577 /* Replace the default data output functions with a user supplied one(s).
1578  * If buffered output is not used, then output_flush_fn can be set to NULL.
1579  * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time
1580  * output_flush_fn will be ignored (and thus can be NULL).
1581  * It is probably a mistake to use NULL for output_flush_fn if
1582  * write_data_fn is not also NULL unless you have built libpng with
1583  * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's
1584  * default flush function, which uses the standard *FILE structure, will
1585  * be used.
1586  */
1587 PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr,
1588  png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
1589 
1590 /* Replace the default data input function with a user supplied one. */
1591 PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr,
1592  png_rw_ptr read_data_fn));
1593 
1594 /* Return the user pointer associated with the I/O functions */
1596 
1597 PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr,
1598  png_read_status_ptr read_row_fn));
1599 
1600 PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr,
1601  png_write_status_ptr write_row_fn));
1602 
1603 #ifdef PNG_USER_MEM_SUPPORTED
1604 /* Replace the default memory allocation functions with user supplied one(s). */
1605 PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr,
1606  png_malloc_ptr malloc_fn, png_free_ptr free_fn));
1607 /* Return the user pointer associated with the memory functions */
1608 PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr));
1609 #endif
1610 
1611 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1612 PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr,
1613  png_user_transform_ptr read_user_transform_fn));
1614 #endif
1615 
1616 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1617 PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr,
1618  png_user_transform_ptr write_user_transform_fn));
1619 #endif
1620 
1621 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
1622 PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr,
1623  png_voidp user_transform_ptr, int user_transform_depth,
1624  int user_transform_channels));
1625 /* Return the user pointer associated with the user transform functions */
1626 PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr,
1628 #endif
1629 
1630 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
1631 /* Return information about the row currently being processed. Note that these
1632  * APIs do not fail but will return unexpected results if called outside a user
1633  * transform callback. Also note that when transforming an interlaced image the
1634  * row number is the row number within the sub-image of the interlace pass, so
1635  * the value will increase to the height of the sub-image (not the full image)
1636  * then reset to 0 for the next pass.
1637  *
1638  * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
1639  * find the output pixel (x,y) given an interlaced sub-image pixel
1640  * (row,col,pass). (See below for these macros.)
1641  */
1642 PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp));
1643 PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp));
1644 #endif
1645 
1646 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1647 /* This callback is called only for *unknown* chunks. If
1648  * PNG_HANDLE_AS_UNKNOWN_SUPPORTED is set then it is possible to set known
1649  * chunks to be treated as unknown, however in this case the callback must do
1650  * any processing required by the chunk (e.g. by calling the appropriate
1651  * png_set_ APIs.)
1652  *
1653  * There is no write support - on write, by default, all the chunks in the
1654  * 'unknown' list are written in the specified position.
1655  *
1656  * The integer return from the callback function is interpreted thus:
1657  *
1658  * negative: An error occurred; png_chunk_error will be called.
1659  * zero: The chunk was not handled, the chunk will be saved. A critical
1660  * chunk will cause an error at this point unless it is to be saved.
1661  * positive: The chunk was handled, libpng will ignore/discard it.
1662  *
1663  * See "INTERACTION WITH USER CHUNK CALLBACKS" below for important notes about
1664  * how this behavior will change in libpng 1.7
1665  */
1666 PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr,
1667  png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
1668 #endif
1669 
1670 #ifdef PNG_USER_CHUNKS_SUPPORTED
1671 PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr));
1672 #endif
1673 
1674 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
1675 /* Sets the function callbacks for the push reader, and a pointer to a
1676  * user-defined structure available to the callback functions.
1677  */
1678 PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr,
1679  png_voidp progressive_ptr, png_progressive_info_ptr info_fn,
1680  png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn));
1681 
1682 /* Returns the user pointer associated with the push read functions */
1683 PNG_EXPORT(91, png_voidp, png_get_progressive_ptr,
1685 
1686 /* Function to be called when data becomes available */
1687 PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
1689 
1690 /* A function which may be called *only* within png_process_data to stop the
1691  * processing of any more data. The function returns the number of bytes
1692  * remaining, excluding any that libpng has cached internally. A subsequent
1693  * call to png_process_data must supply these bytes again. If the argument
1694  * 'save' is set to true the routine will first save all the pending data and
1695  * will always return 0.
1696  */
1697 PNG_EXPORT(219, size_t, png_process_data_pause, (png_structrp, int save));
1698 
1699 /* A function which may be called *only* outside (after) a call to
1700  * png_process_data. It returns the number of bytes of data to skip in the
1701  * input. Normally it will return 0, but if it returns a non-zero value the
1702  * application must skip than number of bytes of input data and pass the
1703  * following data to the next call to png_process_data.
1704  */
1705 PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp));
1706 
1707 /* Function that combines rows. 'new_row' is a flag that should come from
1708  * the callback and be non-NULL if anything needs to be done; the library
1709  * stores its own version of the new data internally and ignores the passed
1710  * in value.
1711  */
1712 PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr,
1713  png_bytep old_row, png_const_bytep new_row));
1714 #endif /* PROGRESSIVE_READ */
1715 
1718 /* Added at libpng version 1.4.0 */
1721 
1722 /* Added at libpng version 1.2.4 */
1723 PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr,
1725 
1726 /* Frees a pointer allocated by png_malloc() */
1727 PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr));
1728 
1729 /* Free data that was allocated internally */
1730 PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr,
1731  png_inforp info_ptr, png_uint_32 free_me, int num));
1732 
1733 /* Reassign responsibility for freeing existing data, whether allocated
1734  * by libpng or by the application; this works on the png_info structure passed
1735  * in, it does not change the state for other png_info structures.
1736  *
1737  * It is unlikely that this function works correctly as of 1.6.0 and using it
1738  * may result either in memory leaks or double free of allocated data.
1739  */
1740 PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
1741  png_inforp info_ptr, int freer, png_uint_32 mask));
1742 
1743 /* Assignments for png_data_freer */
1744 #define PNG_DESTROY_WILL_FREE_DATA 1
1745 #define PNG_SET_WILL_FREE_DATA 1
1746 #define PNG_USER_WILL_FREE_DATA 2
1747 /* Flags for png_ptr->free_me and info_ptr->free_me */
1748 #define PNG_FREE_HIST 0x0008U
1749 #define PNG_FREE_ICCP 0x0010U
1750 #define PNG_FREE_SPLT 0x0020U
1751 #define PNG_FREE_ROWS 0x0040U
1752 #define PNG_FREE_PCAL 0x0080U
1753 #define PNG_FREE_SCAL 0x0100U
1754 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
1755 # define PNG_FREE_UNKN 0x0200U
1756 #endif
1757 /* PNG_FREE_LIST 0x0400U removed in 1.6.0 because it is ignored */
1758 #define PNG_FREE_PLTE 0x1000U
1759 #define PNG_FREE_TRNS 0x2000U
1760 #define PNG_FREE_TEXT 0x4000U
1761 #define PNG_FREE_EXIF 0x8000U /* Added at libpng-1.6.31 */
1762 #define PNG_FREE_ALL 0xffffU
1763 #define PNG_FREE_MUL 0x4220U /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
1764 
1765 #ifdef PNG_USER_MEM_SUPPORTED
1766 PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
1768 PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr,
1770 #endif
1771 
1772 #ifdef PNG_ERROR_TEXT_SUPPORTED
1773 /* Fatal error in PNG image of libpng - can't continue */
1774 PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr,
1776 
1777 /* The same, but the chunk name is prepended to the error string. */
1778 PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr,
1780 
1781 #else
1782 /* Fatal error in PNG image of libpng - can't continue */
1783 PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN);
1784 # define png_error(s1,s2) png_err(s1)
1785 # define png_chunk_error(s1,s2) png_err(s1)
1786 #endif
1787 
1788 #ifdef PNG_WARNINGS_SUPPORTED
1789 /* Non-fatal error in libpng. Can continue, but may have a problem. */
1790 PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr,
1791  png_const_charp warning_message));
1792 
1793 /* Non-fatal error in libpng, chunk name is prepended to message. */
1794 PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr,
1795  png_const_charp warning_message));
1796 #else
1797 # define png_warning(s1,s2) ((void)(s1))
1798 # define png_chunk_warning(s1,s2) ((void)(s1))
1799 #endif
1800 
1801 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
1802 /* Benign error in libpng. Can continue, but may have a problem.
1803  * User can choose whether to handle as a fatal error or as a warning. */
1804 PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr,
1805  png_const_charp warning_message));
1806 
1807 #ifdef PNG_READ_SUPPORTED
1808 /* Same, chunk name is prepended to message (only during read) */
1809 PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr,
1810  png_const_charp warning_message));
1811 #endif
1812 
1813 PNG_EXPORT(109, void, png_set_benign_errors,
1814  (png_structrp png_ptr, int allowed));
1815 #else
1816 # ifdef PNG_ALLOW_BENIGN_ERRORS
1817 # define png_benign_error png_warning
1818 # define png_chunk_benign_error png_chunk_warning
1819 # else
1820 # define png_benign_error png_error
1821 # define png_chunk_benign_error png_chunk_error
1822 # endif
1823 #endif
1824 
1825 /* The png_set_<chunk> functions are for storing values in the png_info_struct.
1826  * Similarly, the png_get_<chunk> calls are used to read values from the
1827  * png_info_struct, either storing the parameters in the passed variables, or
1828  * setting pointers into the png_info_struct where the data is stored. The
1829  * png_get_<chunk> functions return a non-zero value if the data was available
1830  * in info_ptr, or return zero and do not change any of the parameters if the
1831  * data was not available.
1832  *
1833  * These functions should be used instead of directly accessing png_info
1834  * to avoid problems with future changes in the size and internal layout of
1835  * png_info_struct.
1836  */
1837 /* Returns "flag" if chunk data is valid in info_ptr. */
1838 PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr,
1840 
1841 /* Returns number of bytes needed to hold a transformed row. */
1842 PNG_EXPORT(111, size_t, png_get_rowbytes, (png_const_structrp png_ptr,
1844 
1845 #ifdef PNG_INFO_IMAGE_SUPPORTED
1846 /* Returns row_pointers, which is an array of pointers to scanlines that was
1847  * returned from png_read_png().
1848  */
1849 PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr,
1851 
1852 /* Set row_pointers, which is an array of pointers to scanlines for use
1853  * by png_write_png().
1854  */
1855 PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr,
1856  png_inforp info_ptr, png_bytepp row_pointers));
1857 #endif
1858 
1859 /* Returns number of color channels in image. */
1860 PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr,
1862 
1863 #ifdef PNG_EASY_ACCESS_SUPPORTED
1864 /* Returns image width in pixels. */
1865 PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr,
1867 
1868 /* Returns image height in pixels. */
1869 PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr,
1871 
1872 /* Returns image bit_depth. */
1873 PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr,
1875 
1876 /* Returns image color_type. */
1877 PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr,
1879 
1880 /* Returns image filter_type. */
1881 PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr,
1883 
1884 /* Returns image interlace_type. */
1885 PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr,
1887 
1888 /* Returns image compression_type. */
1889 PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr,
1891 
1892 /* Returns image resolution in pixels per meter, from pHYs chunk data. */
1893 PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter,
1895 PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter,
1897 PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter,
1899 
1900 /* Returns pixel aspect ratio, computed from pHYs chunk data. */
1901 PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio,
1905 
1906 /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
1907 PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels,
1909 PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels,
1911 PNG_EXPORT(128, png_int_32, png_get_x_offset_microns,
1913 PNG_EXPORT(129, png_int_32, png_get_y_offset_microns,
1915 
1916 #endif /* EASY_ACCESS */
1917 
1918 #ifdef PNG_READ_SUPPORTED
1919 /* Returns pointer to signature string read from PNG header */
1920 PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr,
1922 #endif
1923 
1924 #ifdef PNG_bKGD_SUPPORTED
1925 PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr,
1926  png_inforp info_ptr, png_color_16p *background));
1927 #endif
1928 
1929 #ifdef PNG_bKGD_SUPPORTED
1930 PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr,
1931  png_inforp info_ptr, png_const_color_16p background));
1932 #endif
1933 
1934 #ifdef PNG_cHRM_SUPPORTED
1936  png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x,
1937  double *red_y, double *green_x, double *green_y, double *blue_x,
1938  double *blue_y))
1940  png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z,
1941  double *green_X, double *green_Y, double *green_Z, double *blue_X,
1942  double *blue_Y, double *blue_Z))
1943 PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed,
1945  png_fixed_point *int_white_x, png_fixed_point *int_white_y,
1946  png_fixed_point *int_red_x, png_fixed_point *int_red_y,
1947  png_fixed_point *int_green_x, png_fixed_point *int_green_y,
1948  png_fixed_point *int_blue_x, png_fixed_point *int_blue_y))
1955  png_fixed_point *int_blue_Z))
1956 #endif
1957 
1958 #ifdef PNG_cHRM_SUPPORTED
1959 PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr,
1961  double white_x, double white_y, double red_x, double red_y, double green_x,
1962  double green_y, double blue_x, double blue_y))
1964  png_inforp info_ptr, double red_X, double red_Y, double red_Z,
1965  double green_X, double green_Y, double green_Z, double blue_X,
1966  double blue_Y, double blue_Z))
1967 PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr,
1968  png_inforp info_ptr, png_fixed_point int_white_x,
1969  png_fixed_point int_white_y, png_fixed_point int_red_x,
1970  png_fixed_point int_red_y, png_fixed_point int_green_x,
1971  png_fixed_point int_green_y, png_fixed_point int_blue_x,
1972  png_fixed_point int_blue_y))
1978  png_fixed_point int_blue_Z))
1979 #endif
1980 
1981 #ifdef PNG_eXIf_SUPPORTED
1982 PNG_EXPORT(246, png_uint_32, png_get_eXIf, (png_const_structrp png_ptr,
1984 PNG_EXPORT(247, void, png_set_eXIf, (png_const_structrp png_ptr,
1986 
1987 PNG_EXPORT(248, png_uint_32, png_get_eXIf_1, (png_const_structrp png_ptr,
1989 PNG_EXPORT(249, void, png_set_eXIf_1, (png_const_structrp png_ptr,
1991 #endif
1992 
1993 #ifdef PNG_gAMA_SUPPORTED
1995  png_const_inforp info_ptr, double *file_gamma))
1998  png_fixed_point *int_file_gamma))
1999 #endif
2000 
2001 #ifdef PNG_gAMA_SUPPORTED
2002 PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr,
2003  png_inforp info_ptr, double file_gamma))
2005  png_inforp info_ptr, png_fixed_point int_file_gamma))
2006 #endif
2007 
2008 #ifdef PNG_hIST_SUPPORTED
2009 PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr,
2010  png_inforp info_ptr, png_uint_16p *hist));
2011 PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr,
2013 #endif
2014 
2015 PNG_EXPORT(143, png_uint_32, png_get_IHDR, (png_const_structrp png_ptr,
2017  int *bit_depth, int *color_type, int *interlace_method,
2018  int *compression_method, int *filter_method));
2019 
2020 PNG_EXPORT(144, void, png_set_IHDR, (png_const_structrp png_ptr,
2022  int color_type, int interlace_method, int compression_method,
2023  int filter_method));
2024 
2025 #ifdef PNG_oFFs_SUPPORTED
2026 PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr,
2027  png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,
2028  int *unit_type));
2029 #endif
2030 
2031 #ifdef PNG_oFFs_SUPPORTED
2032 PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr,
2033  png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y,
2034  int unit_type));
2035 #endif
2036 
2037 #ifdef PNG_pCAL_SUPPORTED
2038 PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr,
2039  png_inforp info_ptr, png_charp *purpose, png_int_32 *X0,
2040  png_int_32 *X1, int *type, int *nparams, png_charp *units,
2041  png_charpp *params));
2042 #endif
2043 
2044 #ifdef PNG_pCAL_SUPPORTED
2045 PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr,
2046  png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1,
2047  int type, int nparams, png_const_charp units, png_charpp params));
2048 #endif
2049 
2050 #ifdef PNG_pHYs_SUPPORTED
2051 PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr,
2053  int *unit_type));
2054 #endif
2055 
2056 #ifdef PNG_pHYs_SUPPORTED
2057 PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr,
2058  png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));
2059 #endif
2060 
2061 PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr,
2062  png_inforp info_ptr, png_colorp *palette, int *num_palette));
2063 
2064 PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr,
2065  png_inforp info_ptr, png_const_colorp palette, int num_palette));
2066 
2067 #ifdef PNG_sBIT_SUPPORTED
2068 PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr,
2069  png_inforp info_ptr, png_color_8p *sig_bit));
2070 #endif
2071 
2072 #ifdef PNG_sBIT_SUPPORTED
2073 PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr,
2075 #endif
2076 
2077 #ifdef PNG_sRGB_SUPPORTED
2078 PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr,
2079  png_const_inforp info_ptr, int *file_srgb_intent));
2080 #endif
2081 
2082 #ifdef PNG_sRGB_SUPPORTED
2083 PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr,
2084  png_inforp info_ptr, int srgb_intent));
2085 PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr,
2086  png_inforp info_ptr, int srgb_intent));
2087 #endif
2088 
2089 #ifdef PNG_iCCP_SUPPORTED
2090 PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr,
2091  png_inforp info_ptr, png_charpp name, int *compression_type,
2092  png_bytepp profile, png_uint_32 *proflen));
2093 #endif
2094 
2095 #ifdef PNG_iCCP_SUPPORTED
2096 PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr,
2097  png_inforp info_ptr, png_const_charp name, int compression_type,
2098  png_const_bytep profile, png_uint_32 proflen));
2099 #endif
2100 
2101 #ifdef PNG_sPLT_SUPPORTED
2102 PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr,
2103  png_inforp info_ptr, png_sPLT_tpp entries));
2104 #endif
2105 
2106 #ifdef PNG_sPLT_SUPPORTED
2107 PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr,
2108  png_inforp info_ptr, png_const_sPLT_tp entries, int nentries));
2109 #endif
2110 
2111 #ifdef PNG_TEXT_SUPPORTED
2112 /* png_get_text also returns the number of text chunks in *num_text */
2113 PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr,
2114  png_inforp info_ptr, png_textp *text_ptr, int *num_text));
2115 #endif
2116 
2117 /* Note while png_set_text() will accept a structure whose text,
2118  * language, and translated keywords are NULL pointers, the structure
2119  * returned by png_get_text will always contain regular
2120  * zero-terminated C strings. They might be empty strings but
2121  * they will never be NULL pointers.
2122  */
2123 
2124 #ifdef PNG_TEXT_SUPPORTED
2125 PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr,
2126  png_inforp info_ptr, png_const_textp text_ptr, int num_text));
2127 #endif
2128 
2129 #ifdef PNG_tIME_SUPPORTED
2130 PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr,
2131  png_inforp info_ptr, png_timep *mod_time));
2132 #endif
2133 
2134 #ifdef PNG_tIME_SUPPORTED
2135 PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr,
2136  png_inforp info_ptr, png_const_timep mod_time));
2137 #endif
2138 
2139 #ifdef PNG_tRNS_SUPPORTED
2140 PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr,
2141  png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans,
2142  png_color_16p *trans_color));
2143 #endif
2144 
2145 #ifdef PNG_tRNS_SUPPORTED
2146 PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr,
2147  png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans,
2148  png_const_color_16p trans_color));
2149 #endif
2150 
2151 #ifdef PNG_sCAL_SUPPORTED
2153  png_const_inforp info_ptr, int *unit, double *width, double *height))
2154 #if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
2155  defined(PNG_FLOATING_POINT_SUPPORTED)
2156 /* NOTE: this API is currently implemented using floating point arithmetic,
2157  * consequently it can only be used on systems with floating point support.
2158  * In any case the range of values supported by png_fixed_point is small and it
2159  * is highly recommended that png_get_sCAL_s be used instead.
2160  */
2164 #endif
2165 PNG_EXPORT(169, png_uint_32, png_get_sCAL_s,
2167  png_charpp swidth, png_charpp sheight));
2168 
2169 PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr,
2170  png_inforp info_ptr, int unit, double width, double height))
2174 PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
2175  png_inforp info_ptr, int unit,
2176  png_const_charp swidth, png_const_charp sheight));
2177 #endif /* sCAL */
2178 
2179 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
2180 /* Provide the default handling for all unknown chunks or, optionally, for
2181  * specific unknown chunks.
2182  *
2183  * NOTE: prior to 1.6.0 the handling specified for particular chunks on read was
2184  * ignored and the default was used, the per-chunk setting only had an effect on
2185  * write. If you wish to have chunk-specific handling on read in code that must
2186  * work on earlier versions you must use a user chunk callback to specify the
2187  * desired handling (keep or discard.)
2188  *
2189  * The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below. The
2190  * parameter is interpreted as follows:
2191  *
2192  * READ:
2193  * PNG_HANDLE_CHUNK_AS_DEFAULT:
2194  * Known chunks: do normal libpng processing, do not keep the chunk (but
2195  * see the comments below about PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
2196  * Unknown chunks: for a specific chunk use the global default, when used
2197  * as the default discard the chunk data.
2198  * PNG_HANDLE_CHUNK_NEVER:
2199  * Discard the chunk data.
2200  * PNG_HANDLE_CHUNK_IF_SAFE:
2201  * Keep the chunk data if the chunk is not critical else raise a chunk
2202  * error.
2203  * PNG_HANDLE_CHUNK_ALWAYS:
2204  * Keep the chunk data.
2205  *
2206  * If the chunk data is saved it can be retrieved using png_get_unknown_chunks,
2207  * below. Notice that specifying "AS_DEFAULT" as a global default is equivalent
2208  * to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks
2209  * it simply resets the behavior to the libpng default.
2210  *
2211  * INTERACTION WITH USER CHUNK CALLBACKS:
2212  * The per-chunk handling is always used when there is a png_user_chunk_ptr
2213  * callback and the callback returns 0; the chunk is then always stored *unless*
2214  * it is critical and the per-chunk setting is other than ALWAYS. Notice that
2215  * the global default is *not* used in this case. (In effect the per-chunk
2216  * value is incremented to at least IF_SAFE.)
2217  *
2218  * IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and
2219  * per-chunk defaults will be honored. If you want to preserve the current
2220  * behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE
2221  * as the default - if you don't do this libpng 1.6 will issue a warning.
2222  *
2223  * If you want unhandled unknown chunks to be discarded in libpng 1.6 and
2224  * earlier simply return '1' (handled).
2225  *
2226  * PNG_HANDLE_AS_UNKNOWN_SUPPORTED:
2227  * If this is *not* set known chunks will always be handled by libpng and
2228  * will never be stored in the unknown chunk list. Known chunks listed to
2229  * png_set_keep_unknown_chunks will have no effect. If it is set then known
2230  * chunks listed with a keep other than AS_DEFAULT will *never* be processed
2231  * by libpng, in addition critical chunks must either be processed by the
2232  * callback or saved.
2233  *
2234  * The IHDR and IEND chunks must not be listed. Because this turns off the
2235  * default handling for chunks that would otherwise be recognized the
2236  * behavior of libpng transformations may well become incorrect!
2237  *
2238  * WRITE:
2239  * When writing chunks the options only apply to the chunks specified by
2240  * png_set_unknown_chunks (below), libpng will *always* write known chunks
2241  * required by png_set_ calls and will always write the core critical chunks
2242  * (as required for PLTE).
2243  *
2244  * Each chunk in the png_set_unknown_chunks list is looked up in the
2245  * png_set_keep_unknown_chunks list to find the keep setting, this is then
2246  * interpreted as follows:
2247  *
2248  * PNG_HANDLE_CHUNK_AS_DEFAULT:
2249  * Write safe-to-copy chunks and write other chunks if the global
2250  * default is set to _ALWAYS, otherwise don't write this chunk.
2251  * PNG_HANDLE_CHUNK_NEVER:
2252  * Do not write the chunk.
2253  * PNG_HANDLE_CHUNK_IF_SAFE:
2254  * Write the chunk if it is safe-to-copy, otherwise do not write it.
2255  * PNG_HANDLE_CHUNK_ALWAYS:
2256  * Write the chunk.
2257  *
2258  * Note that the default behavior is effectively the opposite of the read case -
2259  * in read unknown chunks are not stored by default, in write they are written
2260  * by default. Also the behavior of PNG_HANDLE_CHUNK_IF_SAFE is very different
2261  * - on write the safe-to-copy bit is checked, on read the critical bit is
2262  * checked and on read if the chunk is critical an error will be raised.
2263  *
2264  * num_chunks:
2265  * ===========
2266  * If num_chunks is positive, then the "keep" parameter specifies the manner
2267  * for handling only those chunks appearing in the chunk_list array,
2268  * otherwise the chunk list array is ignored.
2269  *
2270  * If num_chunks is 0 the "keep" parameter specifies the default behavior for
2271  * unknown chunks, as described above.
2272  *
2273  * If num_chunks is negative, then the "keep" parameter specifies the manner
2274  * for handling all unknown chunks plus all chunks recognized by libpng
2275  * except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to
2276  * be processed by libpng.
2277  */
2278 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
2279 PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
2280  int keep, png_const_bytep chunk_list, int num_chunks));
2281 #endif /* HANDLE_AS_UNKNOWN */
2282 
2283 /* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned;
2284  * the result is therefore true (non-zero) if special handling is required,
2285  * false for the default handling.
2286  */
2287 PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr,
2288  png_const_bytep chunk_name));
2289 #endif /* SET_UNKNOWN_CHUNKS */
2290 
2291 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
2292 PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr,
2294  int num_unknowns));
2295  /* NOTE: prior to 1.6.0 this routine set the 'location' field of the added
2296  * unknowns to the location currently stored in the png_struct. This is
2297  * invariably the wrong value on write. To fix this call the following API
2298  * for each chunk in the list with the correct location. If you know your
2299  * code won't be compiled on earlier versions you can rely on
2300  * png_set_unknown_chunks(write-ptr, png_get_unknown_chunks(read-ptr)) doing
2301  * the correct thing.
2302  */
2303 
2304 PNG_EXPORT(175, void, png_set_unknown_chunk_location,
2306 
2307 PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structrp png_ptr,
2309 #endif
2310 
2311 /* Png_free_data() will turn off the "valid" flag for anything it frees.
2312  * If you need to turn it off for a chunk that your application has freed,
2313  * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);
2314  */
2315 PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr,
2316  png_inforp info_ptr, int mask));
2317 
2318 #ifdef PNG_INFO_IMAGE_SUPPORTED
2319 /* The "params" pointer is currently not used and is for future expansion. */
2320 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
2321 PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr,
2322  int transforms, png_voidp params));
2323 #endif
2324 #ifdef PNG_WRITE_SUPPORTED
2325 PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr,
2326  int transforms, png_voidp params));
2327 #endif
2328 #endif
2329 
2338 
2339 #ifdef PNG_MNG_FEATURES_SUPPORTED
2340 PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr,
2341  png_uint_32 mng_features_permitted));
2342 #endif
2343 
2344 /* For use in png_set_keep_unknown, added to version 1.2.6 */
2345 #define PNG_HANDLE_CHUNK_AS_DEFAULT 0
2346 #define PNG_HANDLE_CHUNK_NEVER 1
2347 #define PNG_HANDLE_CHUNK_IF_SAFE 2
2348 #define PNG_HANDLE_CHUNK_ALWAYS 3
2349 #define PNG_HANDLE_CHUNK_LAST 4
2350 
2351 /* Strip the prepended error numbers ("#nnn ") from error and warning
2352  * messages before passing them to the error or warning handler.
2353  */
2354 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
2355 PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr,
2356  png_uint_32 strip_mode));
2357 #endif
2358 
2359 /* Added in libpng-1.2.6 */
2360 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
2361 PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr,
2362  png_uint_32 user_width_max, png_uint_32 user_height_max));
2363 PNG_EXPORT(187, png_uint_32, png_get_user_width_max,
2365 PNG_EXPORT(188, png_uint_32, png_get_user_height_max,
2367 /* Added in libpng-1.4.0 */
2368 PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr,
2369  png_uint_32 user_chunk_cache_max));
2370 PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max,
2372 /* Added in libpng-1.4.1 */
2373 PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr,
2374  png_alloc_size_t user_chunk_cache_max));
2375 PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max,
2377 #endif
2378 
2379 #if defined(PNG_INCH_CONVERSIONS_SUPPORTED)
2380 PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch,
2382 
2383 PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch,
2385 
2386 PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch,
2388 
2389 PNG_FP_EXPORT(196, float, png_get_x_offset_inches,
2391 #ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
2394 #endif
2395 
2396 PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structrp png_ptr,
2398 #ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
2401 #endif
2402 
2403 # ifdef PNG_pHYs_SUPPORTED
2404 PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr,
2406  int *unit_type));
2407 # endif /* pHYs */
2408 #endif /* INCH_CONVERSIONS */
2409 
2410 /* Added in libpng-1.4.0 */
2411 #ifdef PNG_IO_STATE_SUPPORTED
2412 PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr));
2413 
2414 /* Removed from libpng 1.6; use png_get_io_chunk_type. */
2415 PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr),
2417 
2420 
2421 /* The flags returned by png_get_io_state() are the following: */
2422 # define PNG_IO_NONE 0x0000 /* no I/O at this moment */
2423 # define PNG_IO_READING 0x0001 /* currently reading */
2424 # define PNG_IO_WRITING 0x0002 /* currently writing */
2425 # define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */
2426 # define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */
2427 # define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */
2428 # define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */
2429 # define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */
2430 # define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */
2431 #endif /* IO_STATE */
2432 
2433 /* Interlace support. The following macros are always defined so that if
2434  * libpng interlace handling is turned off the macros may be used to handle
2435  * interlaced images within the application.
2436  */
2437 #define PNG_INTERLACE_ADAM7_PASSES 7
2438 
2439 /* Two macros to return the first row and first column of the original,
2440  * full, image which appears in a given pass. 'pass' is in the range 0
2441  * to 6 and the result is in the range 0 to 7.
2442  */
2443 #define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7)
2444 #define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7)
2445 
2446 /* A macro to return the offset between pixels in the output row for a pair of
2447  * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that
2448  * follows. Note that ROW_OFFSET is the offset from one row to the next whereas
2449  * COL_OFFSET is from one column to the next, within a row.
2450  */
2451 #define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8)
2452 #define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1))
2453 
2454 /* Two macros to help evaluate the number of rows or columns in each
2455  * pass. This is expressed as a shift - effectively log2 of the number or
2456  * rows or columns in each 8x8 tile of the original image.
2457  */
2458 #define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
2459 #define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
2460 
2461 /* Hence two macros to determine the number of rows or columns in a given
2462  * pass of an image given its height or width. In fact these macros may
2463  * return non-zero even though the sub-image is empty, because the other
2464  * dimension may be empty for a small image.
2465  */
2466 #define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
2467  -1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
2468 #define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
2469  -1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
2470 
2471 /* For the reader row callbacks (both progressive and sequential) it is
2472  * necessary to find the row in the output image given a row in an interlaced
2473  * image, so two more macros:
2474  */
2475 #define PNG_ROW_FROM_PASS_ROW(y_in, pass) \
2476  (((y_in)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
2477 #define PNG_COL_FROM_PASS_COL(x_in, pass) \
2478  (((x_in)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
2479 
2480 /* Two macros which return a boolean (0 or 1) saying whether the given row
2481  * or column is in a particular pass. These use a common utility macro that
2482  * returns a mask for a given pass - the offset 'off' selects the row or
2483  * column version. The mask has the appropriate bit set for each column in
2484  * the tile.
2485  */
2486 #define PNG_PASS_MASK(pass,off) ( \
2487  ((0x110145AF>>(((7-(off))-(pass))<<2)) & 0xF) | \
2488  ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0))
2489 
2490 #define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
2491  ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
2492 #define PNG_COL_IN_INTERLACE_PASS(x, pass) \
2493  ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
2494 
2495 #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
2496 /* With these routines we avoid an integer divide, which will be slower on
2497  * most machines. However, it does take more operations than the corresponding
2498  * divide method, so it may be slower on a few RISC systems. There are two
2499  * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
2500  *
2501  * Note that the rounding factors are NOT supposed to be the same! 128 and
2502  * 32768 are correct for the NODIV code; 127 and 32767 are correct for the
2503  * standard method.
2504  *
2505  * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]
2506  */
2507 
2508  /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */
2509 
2510 # define png_composite(composite, fg, alpha, bg) \
2511  { \
2512  png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \
2513  * (png_uint_16)(alpha) \
2514  + (png_uint_16)(bg)*(png_uint_16)(255 \
2515  - (png_uint_16)(alpha)) + 128); \
2516  (composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); \
2517  }
2518 
2519 # define png_composite_16(composite, fg, alpha, bg) \
2520  { \
2521  png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
2522  * (png_uint_32)(alpha) \
2523  + (png_uint_32)(bg)*(65535 \
2524  - (png_uint_32)(alpha)) + 32768); \
2525  (composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); \
2526  }
2527 
2528 #else /* Standard method using integer division */
2529 
2530 # define png_composite(composite, fg, alpha, bg) \
2531  (composite) = \
2532  (png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) + \
2533  (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
2534  127) / 255))
2535 
2536 # define png_composite_16(composite, fg, alpha, bg) \
2537  (composite) = \
2538  (png_uint_16)(0xffff & (((png_uint_32)(fg) * (png_uint_32)(alpha) + \
2539  (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \
2540  32767) / 65535))
2541 #endif /* READ_COMPOSITE_NODIV */
2542 
2543 #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
2545 PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf));
2546 PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf));
2547 #endif
2548 
2549 PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr,
2550  png_const_bytep buf));
2551 /* No png_get_int_16 -- may be added if there's a real need for it. */
2552 
2553 /* Place a 32-bit number into a buffer in PNG byte order (big-endian). */
2554 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
2555 PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i));
2556 #endif
2557 #ifdef PNG_SAVE_INT_32_SUPPORTED
2558 PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i));
2559 #endif
2560 
2561 /* Place a 16-bit number into a buffer in PNG byte order.
2562  * The parameter is declared unsigned int, not png_uint_16,
2563  * just to avoid potential problems on pre-ANSI C compilers.
2564  */
2565 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
2566 PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i));
2567 /* No png_save_int_16 -- may be added if there's a real need for it. */
2568 #endif
2569 
2570 #ifdef PNG_USE_READ_MACROS
2571 /* Inline macros to do direct reads of bytes from the input buffer.
2572  * The png_get_int_32() routine assumes we are using two's complement
2573  * format for negative values, which is almost certainly true.
2574  */
2575 # define PNG_get_uint_32(buf) \
2576  (((png_uint_32)(*(buf)) << 24) + \
2577  ((png_uint_32)(*((buf) + 1)) << 16) + \
2578  ((png_uint_32)(*((buf) + 2)) << 8) + \
2579  ((png_uint_32)(*((buf) + 3))))
2580 
2581  /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the
2582  * function) incorrectly returned a value of type png_uint_32.
2583  */
2584 # define PNG_get_uint_16(buf) \
2585  ((png_uint_16) \
2586  (((unsigned int)(*(buf)) << 8) + \
2587  ((unsigned int)(*((buf) + 1)))))
2588 
2589 # define PNG_get_int_32(buf) \
2590  ((png_int_32)((*(buf) & 0x80) \
2591  ? -((png_int_32)(((png_get_uint_32(buf)^0xffffffffU)+1U)&0x7fffffffU)) \
2592  : (png_int_32)png_get_uint_32(buf)))
2593 
2594 /* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h,
2595  * but defining a macro name prefixed with PNG_PREFIX.
2596  */
2597 # ifndef PNG_PREFIX
2598 # define png_get_uint_32(buf) PNG_get_uint_32(buf)
2599 # define png_get_uint_16(buf) PNG_get_uint_16(buf)
2600 # define png_get_int_32(buf) PNG_get_int_32(buf)
2601 # endif
2602 #else
2603 # ifdef PNG_PREFIX
2604  /* No macros; revert to the (redefined) function */
2605 # define PNG_get_uint_32 (png_get_uint_32)
2606 # define PNG_get_uint_16 (png_get_uint_16)
2607 # define PNG_get_int_32 (png_get_int_32)
2608 # endif
2609 #endif
2610 
2611 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
2612 PNG_EXPORT(242, void, png_set_check_for_invalid_index,
2613  (png_structrp png_ptr, int allowed));
2614 # ifdef PNG_GET_PALETTE_MAX_SUPPORTED
2615 PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
2617 # endif
2618 #endif /* CHECK_FOR_INVALID_INDEX */
2619 
2620 /*******************************************************************************
2621  * Section 5: SIMPLIFIED API
2622  *******************************************************************************
2623  *
2624  * Please read the documentation in libpng-manual.txt (TODO: write said
2625  * documentation) if you don't understand what follows.
2626  *
2627  * The simplified API hides the details of both libpng and the PNG file format
2628  * itself. It allows PNG files to be read into a very limited number of
2629  * in-memory bitmap formats or to be written from the same formats. If these
2630  * formats do not accommodate your needs then you can, and should, use the more
2631  * sophisticated APIs above - these support a wide variety of in-memory formats
2632  * and a wide variety of sophisticated transformations to those formats as well
2633  * as a wide variety of APIs to manipulate ancillary information.
2634  *
2635  * To read a PNG file using the simplified API:
2636  *
2637  * 1) Declare a 'png_image' structure (see below) on the stack, set the
2638  * version field to PNG_IMAGE_VERSION and the 'opaque' pointer to NULL
2639  * (this is REQUIRED, your program may crash if you don't do it.)
2640  * 2) Call the appropriate png_image_begin_read... function.
2641  * 3) Set the png_image 'format' member to the required sample format.
2642  * 4) Allocate a buffer for the image and, if required, the color-map.
2643  * 5) Call png_image_finish_read to read the image and, if required, the
2644  * color-map into your buffers.
2645  *
2646  * There are no restrictions on the format of the PNG input itself; all valid
2647  * color types, bit depths, and interlace methods are acceptable, and the
2648  * input image is transformed as necessary to the requested in-memory format
2649  * during the png_image_finish_read() step. The only caveat is that if you
2650  * request a color-mapped image from a PNG that is full-color or makes
2651  * complex use of an alpha channel the transformation is extremely lossy and the
2652  * result may look terrible.
2653  *
2654  * To write a PNG file using the simplified API:
2655  *
2656  * 1) Declare a 'png_image' structure on the stack and memset() it to all zero.
2657  * 2) Initialize the members of the structure that describe the image, setting
2658  * the 'format' member to the format of the image samples.
2659  * 3) Call the appropriate png_image_write... function with a pointer to the
2660  * image and, if necessary, the color-map to write the PNG data.
2661  *
2662  * png_image is a structure that describes the in-memory format of an image
2663  * when it is being read or defines the in-memory format of an image that you
2664  * need to write:
2665  */
2666 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) || \
2667  defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
2668 
2669 #define PNG_IMAGE_VERSION 1
2670 
2671 typedef struct png_control *png_controlp;
2672 typedef struct
2673 {
2674  png_controlp opaque; /* Initialize to NULL, free with png_image_free */
2675  png_uint_32 version; /* Set to PNG_IMAGE_VERSION */
2676  png_uint_32 width; /* Image width in pixels (columns) */
2677  png_uint_32 height; /* Image height in pixels (rows) */
2678  png_uint_32 format; /* Image format as defined below */
2679  png_uint_32 flags; /* A bit mask containing informational flags */
2681  /* Number of entries in the color-map */
2682 
2683  /* In the event of an error or warning the following field will be set to a
2684  * non-zero value and the 'message' field will contain a '\0' terminated
2685  * string with the libpng error or warning message. If both warnings and
2686  * an error were encountered, only the error is recorded. If there
2687  * are multiple warnings, only the first one is recorded.
2688  *
2689  * The upper 30 bits of this value are reserved, the low two bits contain
2690  * a value as follows:
2691  */
2692 # define PNG_IMAGE_WARNING 1
2693 # define PNG_IMAGE_ERROR 2
2694  /*
2695  * The result is a two-bit code such that a value more than 1 indicates
2696  * a failure in the API just called:
2697  *
2698  * 0 - no warning or error
2699  * 1 - warning
2700  * 2 - error
2701  * 3 - error preceded by warning
2702  */
2703 # define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1)
2704 
2706 
2707  char message[64];
2708 } png_image, *png_imagep;
2709 
2710 /* The samples of the image have one to four channels whose components have
2711  * original values in the range 0 to 1.0:
2712  *
2713  * 1: A single gray or luminance channel (G).
2714  * 2: A gray/luminance channel and an alpha channel (GA).
2715  * 3: Three red, green, blue color channels (RGB).
2716  * 4: Three color channels and an alpha channel (RGBA).
2717  *
2718  * The components are encoded in one of two ways:
2719  *
2720  * a) As a small integer, value 0..255, contained in a single byte. For the
2721  * alpha channel the original value is simply value/255. For the color or
2722  * luminance channels the value is encoded according to the sRGB specification
2723  * and matches the 8-bit format expected by typical display devices.
2724  *
2725  * The color/gray channels are not scaled (pre-multiplied) by the alpha
2726  * channel and are suitable for passing to color management software.
2727  *
2728  * b) As a value in the range 0..65535, contained in a 2-byte integer. All
2729  * channels can be converted to the original value by dividing by 65535; all
2730  * channels are linear. Color channels use the RGB encoding (RGB end-points) of
2731  * the sRGB specification. This encoding is identified by the
2732  * PNG_FORMAT_FLAG_LINEAR flag below.
2733  *
2734  * When the simplified API needs to convert between sRGB and linear colorspaces,
2735  * the actual sRGB transfer curve defined in the sRGB specification (see the
2736  * article at <https://en.wikipedia.org/wiki/SRGB>) is used, not the gamma=1/2.2
2737  * approximation used elsewhere in libpng.
2738  *
2739  * When an alpha channel is present it is expected to denote pixel coverage
2740  * of the color or luminance channels and is returned as an associated alpha
2741  * channel: the color/gray channels are scaled (pre-multiplied) by the alpha
2742  * value.
2743  *
2744  * The samples are either contained directly in the image data, between 1 and 8
2745  * bytes per pixel according to the encoding, or are held in a color-map indexed
2746  * by bytes in the image data. In the case of a color-map the color-map entries
2747  * are individual samples, encoded as above, and the image data has one byte per
2748  * pixel to select the relevant sample from the color-map.
2749  */
2750 
2751 /* PNG_FORMAT_*
2752  *
2753  * #defines to be used in png_image::format. Each #define identifies a
2754  * particular layout of sample data and, if present, alpha values. There are
2755  * separate defines for each of the two component encodings.
2756  *
2757  * A format is built up using single bit flag values. All combinations are
2758  * valid. Formats can be built up from the flag values or you can use one of
2759  * the predefined values below. When testing formats always use the FORMAT_FLAG
2760  * macros to test for individual features - future versions of the library may
2761  * add new flags.
2762  *
2763  * When reading or writing color-mapped images the format should be set to the
2764  * format of the entries in the color-map then png_image_{read,write}_colormap
2765  * called to read or write the color-map and set the format correctly for the
2766  * image data. Do not set the PNG_FORMAT_FLAG_COLORMAP bit directly!
2767  *
2768  * NOTE: libpng can be built with particular features disabled. If you see
2769  * compiler errors because the definition of one of the following flags has been
2770  * compiled out it is because libpng does not have the required support. It is
2771  * possible, however, for the libpng configuration to enable the format on just
2772  * read or just write; in that case you may see an error at run time. You can
2773  * guard against this by checking for the definition of the appropriate
2774  * "_SUPPORTED" macro, one of:
2775  *
2776  * PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED
2777  */
2778 #define PNG_FORMAT_FLAG_ALPHA 0x01U /* format with an alpha channel */
2779 #define PNG_FORMAT_FLAG_COLOR 0x02U /* color format: otherwise grayscale */
2780 #define PNG_FORMAT_FLAG_LINEAR 0x04U /* 2-byte channels else 1-byte */
2781 #define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */
2782 
2783 #ifdef PNG_FORMAT_BGR_SUPPORTED
2784 # define PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */
2785 #endif
2786 
2787 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
2788 # define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */
2789 #endif
2790 
2791 #define PNG_FORMAT_FLAG_ASSOCIATED_ALPHA 0x40U /* alpha channel is associated */
2792 
2793 /* Commonly used formats have predefined macros.
2794  *
2795  * First the single byte (sRGB) formats:
2796  */
2797 #define PNG_FORMAT_GRAY 0
2798 #define PNG_FORMAT_GA PNG_FORMAT_FLAG_ALPHA
2799 #define PNG_FORMAT_AG (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST)
2800 #define PNG_FORMAT_RGB PNG_FORMAT_FLAG_COLOR
2801 #define PNG_FORMAT_BGR (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR)
2802 #define PNG_FORMAT_RGBA (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA)
2803 #define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST)
2804 #define PNG_FORMAT_BGRA (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA)
2805 #define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST)
2806 
2807 /* Then the linear 2-byte formats. When naming these "Y" is used to
2808  * indicate a luminance (gray) channel.
2809  */
2810 #define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR
2811 #define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA)
2812 #define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR)
2813 #define PNG_FORMAT_LINEAR_RGB_ALPHA \
2814  (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA)
2815 
2816 /* With color-mapped formats the image data is one byte for each pixel, the byte
2817  * is an index into the color-map which is formatted as above. To obtain a
2818  * color-mapped format it is sufficient just to add the PNG_FOMAT_FLAG_COLORMAP
2819  * to one of the above definitions, or you can use one of the definitions below.
2820  */
2821 #define PNG_FORMAT_RGB_COLORMAP (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP)
2822 #define PNG_FORMAT_BGR_COLORMAP (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP)
2823 #define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP)
2824 #define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP)
2825 #define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP)
2826 #define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP)
2827 
2828 /* PNG_IMAGE macros
2829  *
2830  * These are convenience macros to derive information from a png_image
2831  * structure. The PNG_IMAGE_SAMPLE_ macros return values appropriate to the
2832  * actual image sample values - either the entries in the color-map or the
2833  * pixels in the image. The PNG_IMAGE_PIXEL_ macros return corresponding values
2834  * for the pixels and will always return 1 for color-mapped formats. The
2835  * remaining macros return information about the rows in the image and the
2836  * complete image.
2837  *
2838  * NOTE: All the macros that take a png_image::format parameter are compile time
2839  * constants if the format parameter is, itself, a constant. Therefore these
2840  * macros can be used in array declarations and case labels where required.
2841  * Similarly the macros are also pre-processor constants (sizeof is not used) so
2842  * they can be used in #if tests.
2843  *
2844  * First the information about the samples.
2845  */
2846 #define PNG_IMAGE_SAMPLE_CHANNELS(fmt)\
2847  (((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1)
2848  /* Return the total number of channels in a given format: 1..4 */
2849 
2850 #define PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)\
2851  ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1)
2852  /* Return the size in bytes of a single component of a pixel or color-map
2853  * entry (as appropriate) in the image: 1 or 2.
2854  */
2855 
2856 #define PNG_IMAGE_SAMPLE_SIZE(fmt)\
2857  (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt))
2858  /* This is the size of the sample data for one sample. If the image is
2859  * color-mapped it is the size of one color-map entry (and image pixels are
2860  * one byte in size), otherwise it is the size of one image pixel.
2861  */
2862 
2863 #define PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt)\
2864  (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256)
2865  /* The maximum size of the color-map required by the format expressed in a
2866  * count of components. This can be used to compile-time allocate a
2867  * color-map:
2868  *
2869  * png_uint_16 colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(linear_fmt)];
2870  *
2871  * png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)];
2872  *
2873  * Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro below to use the
2874  * information from one of the png_image_begin_read_ APIs and dynamically
2875  * allocate the required memory.
2876  */
2877 
2878 /* Corresponding information about the pixels */
2879 #define PNG_IMAGE_PIXEL_(test,fmt)\
2880  (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt))
2881 
2882 #define PNG_IMAGE_PIXEL_CHANNELS(fmt)\
2883  PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt)
2884  /* The number of separate channels (components) in a pixel; 1 for a
2885  * color-mapped image.
2886  */
2887 
2888 #define PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)\
2889  PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt)
2890  /* The size, in bytes, of each component in a pixel; 1 for a color-mapped
2891  * image.
2892  */
2893 
2894 #define PNG_IMAGE_PIXEL_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt)
2895  /* The size, in bytes, of a complete pixel; 1 for a color-mapped image. */
2896 
2897 /* Information about the whole row, or whole image */
2898 #define PNG_IMAGE_ROW_STRIDE(image)\
2899  (PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width)
2900  /* Return the total number of components in a single row of the image; this
2901  * is the minimum 'row stride', the minimum count of components between each
2902  * row. For a color-mapped image this is the minimum number of bytes in a
2903  * row.
2904  *
2905  * WARNING: this macro overflows for some images with more than one component
2906  * and very large image widths. libpng will refuse to process an image where
2907  * this macro would overflow.
2908  */
2909 
2910 #define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\
2911  (PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride))
2912  /* Return the size, in bytes, of an image buffer given a png_image and a row
2913  * stride - the number of components to leave space for in each row.
2914  *
2915  * WARNING: this macro overflows a 32-bit integer for some large PNG images,
2916  * libpng will refuse to process an image where such an overflow would occur.
2917  */
2918 
2919 #define PNG_IMAGE_SIZE(image)\
2920  PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image))
2921  /* Return the size, in bytes, of the image in memory given just a png_image;
2922  * the row stride is the minimum stride required for the image.
2923  */
2924 
2925 #define PNG_IMAGE_COLORMAP_SIZE(image)\
2926  (PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries)
2927  /* Return the size, in bytes, of the color-map of this image. If the image
2928  * format is not a color-map format this will return a size sufficient for
2929  * 256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if
2930  * you don't want to allocate a color-map in this case.
2931  */
2932 
2933 /* PNG_IMAGE_FLAG_*
2934  *
2935  * Flags containing additional information about the image are held in the
2936  * 'flags' field of png_image.
2937  */
2938 #define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01
2939  /* This indicates that the RGB values of the in-memory bitmap do not
2940  * correspond to the red, green and blue end-points defined by sRGB.
2941  */
2942 
2943 #define PNG_IMAGE_FLAG_FAST 0x02
2944  /* On write emphasise speed over compression; the resultant PNG file will be
2945  * larger but will be produced significantly faster, particular for large
2946  * images. Do not use this option for images which will be distributed, only
2947  * used it when producing intermediate files that will be read back in
2948  * repeatedly. For a typical 24-bit image the option will double the read
2949  * speed at the cost of increasing the image size by 25%, however for many
2950  * more compressible images the PNG file can be 10 times larger with only a
2951  * slight speed gain.
2952  */
2953 
2954 #define PNG_IMAGE_FLAG_16BIT_sRGB 0x04
2955  /* On read if the image is a 16-bit per component image and there is no gAMA
2956  * or sRGB chunk assume that the components are sRGB encoded. Notice that
2957  * images output by the simplified API always have gamma information; setting
2958  * this flag only affects the interpretation of 16-bit images from an
2959  * external source. It is recommended that the application expose this flag
2960  * to the user; the user can normally easily recognize the difference between
2961  * linear and sRGB encoding. This flag has no effect on write - the data
2962  * passed to the write APIs must have the correct encoding (as defined
2963  * above.)
2964  *
2965  * If the flag is not set (the default) input 16-bit per component data is
2966  * assumed to be linear.
2967  *
2968  * NOTE: the flag can only be set after the png_image_begin_read_ call,
2969  * because that call initializes the 'flags' field.
2970  */
2971 
2972 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
2973 /* READ APIs
2974  * ---------
2975  *
2976  * The png_image passed to the read APIs must have been initialized by setting
2977  * the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.)
2978  */
2979 #ifdef PNG_STDIO_SUPPORTED
2980 PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image,
2981  const char *file_name));
2982  /* The named file is opened for read and the image header is filled in
2983  * from the PNG header in the file.
2984  */
2985 
2986 PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image,
2987  FILE* file));
2988  /* The PNG header is read from the stdio FILE object. */
2989 #endif /* STDIO */
2990 
2991 PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image,
2992  png_const_voidp memory, size_t size));
2993  /* The PNG header is read from the given memory buffer. */
2994 
2995 PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image,
2996  png_const_colorp background, void *buffer, png_int_32 row_stride,
2997  void *colormap));
2998  /* Finish reading the image into the supplied buffer and clean up the
2999  * png_image structure.
3000  *
3001  * row_stride is the step, in byte or 2-byte units as appropriate,
3002  * between adjacent rows. A positive stride indicates that the top-most row
3003  * is first in the buffer - the normal top-down arrangement. A negative
3004  * stride indicates that the bottom-most row is first in the buffer.
3005  *
3006  * background need only be supplied if an alpha channel must be removed from
3007  * a png_byte format and the removal is to be done by compositing on a solid
3008  * color; otherwise it may be NULL and any composition will be done directly
3009  * onto the buffer. The value is an sRGB color to use for the background,
3010  * for grayscale output the green channel is used.
3011  *
3012  * background must be supplied when an alpha channel must be removed from a
3013  * single byte color-mapped output format, in other words if:
3014  *
3015  * 1) The original format from png_image_begin_read_from_* had
3016  * PNG_FORMAT_FLAG_ALPHA set.
3017  * 2) The format set by the application does not.
3018  * 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and
3019  * PNG_FORMAT_FLAG_LINEAR *not* set.
3020  *
3021  * For linear output removing the alpha channel is always done by compositing
3022  * on black and background is ignored.
3023  *
3024  * colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set. It must
3025  * be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE.
3026  * image->colormap_entries will be updated to the actual number of entries
3027  * written to the colormap; this may be less than the original value.
3028  */
3029 
3030 PNG_EXPORT(238, void, png_image_free, (png_imagep image));
3031  /* Free any data allocated by libpng in image->opaque, setting the pointer to
3032  * NULL. May be called at any time after the structure is initialized.
3033  */
3034 #endif /* SIMPLIFIED_READ */
3035 
3036 #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
3037 /* WRITE APIS
3038  * ----------
3039  * For write you must initialize a png_image structure to describe the image to
3040  * be written. To do this use memset to set the whole structure to 0 then
3041  * initialize fields describing your image.
3042  *
3043  * version: must be set to PNG_IMAGE_VERSION
3044  * opaque: must be initialized to NULL
3045  * width: image width in pixels
3046  * height: image height in rows
3047  * format: the format of the data (image and color-map) you wish to write
3048  * flags: set to 0 unless one of the defined flags applies; set
3049  * PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB for color format images where the RGB
3050  * values do not correspond to the colors in sRGB.
3051  * colormap_entries: set to the number of entries in the color-map (0 to 256)
3052  */
3053 #ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
3054 PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image,
3055  const char *file, int convert_to_8bit, const void *buffer,
3056  png_int_32 row_stride, const void *colormap));
3057  /* Write the image to the named file. */
3058 
3059 PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
3060  int convert_to_8_bit, const void *buffer, png_int_32 row_stride,
3061  const void *colormap));
3062  /* Write the image to the given (FILE*). */
3063 #endif /* SIMPLIFIED_WRITE_STDIO */
3064 
3065 /* With all write APIs if image is in one of the linear formats with 16-bit
3066  * data then setting convert_to_8_bit will cause the output to be an 8-bit PNG
3067  * gamma encoded according to the sRGB specification, otherwise a 16-bit linear
3068  * encoded PNG file is written.
3069  *
3070  * With color-mapped data formats the colormap parameter point to a color-map
3071  * with at least image->colormap_entries encoded in the specified format. If
3072  * the format is linear the written PNG color-map will be converted to sRGB
3073  * regardless of the convert_to_8_bit flag.
3074  *
3075  * With all APIs row_stride is handled as in the read APIs - it is the spacing
3076  * from one row to the next in component sized units (1 or 2 bytes) and if
3077  * negative indicates a bottom-up row layout in the buffer. If row_stride is
3078  * zero, libpng will calculate it for you from the image width and number of
3079  * channels.
3080  *
3081  * Note that the write API does not support interlacing, sub-8-bit pixels or
3082  * most ancillary chunks. If you need to write text chunks (e.g. for copyright
3083  * notices) you need to use one of the other APIs.
3084  */
3085 
3086 PNG_EXPORT(245, int, png_image_write_to_memory, (png_imagep image, void *memory,
3087  png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8_bit,
3088  const void *buffer, png_int_32 row_stride, const void *colormap));
3089  /* Write the image to the given memory buffer. The function both writes the
3090  * whole PNG data stream to *memory and updates *memory_bytes with the count
3091  * of bytes written.
3092  *
3093  * 'memory' may be NULL. In this case *memory_bytes is not read however on
3094  * success the number of bytes which would have been written will still be
3095  * stored in *memory_bytes. On failure *memory_bytes will contain 0.
3096  *
3097  * If 'memory' is not NULL it must point to memory[*memory_bytes] of
3098  * writeable memory.
3099  *
3100  * If the function returns success memory[*memory_bytes] (if 'memory' is not
3101  * NULL) contains the written PNG data. *memory_bytes will always be less
3102  * than or equal to the original value.
3103  *
3104  * If the function returns false and *memory_bytes was not changed an error
3105  * occurred during write. If *memory_bytes was changed, or is not 0 if
3106  * 'memory' was NULL, the write would have succeeded but for the memory
3107  * buffer being too small. *memory_bytes contains the required number of
3108  * bytes and will be bigger that the original value.
3109  */
3110 
3111 #define png_image_write_get_memory_size(image, size, convert_to_8_bit, buffer,\
3112  row_stride, colormap)\
3113  png_image_write_to_memory(&(image), 0, &(size), convert_to_8_bit, buffer,\
3114  row_stride, colormap)
3115  /* Return the amount of memory in 'size' required to compress this image.
3116  * The png_image structure 'image' must be filled in as in the above
3117  * function and must not be changed before the actual write call, the buffer
3118  * and all other parameters must also be identical to that in the final
3119  * write call. The 'size' variable need not be initialized.
3120  *
3121  * NOTE: the macro returns true/false, if false is returned 'size' will be
3122  * set to zero and the write failed and probably will fail if tried again.
3123  */
3124 
3125 /* You can pre-allocate the buffer by making sure it is of sufficient size
3126  * regardless of the amount of compression achieved. The buffer size will
3127  * always be bigger than the original image and it will never be filled. The
3128  * following macros are provided to assist in allocating the buffer.
3129  */
3130 #define PNG_IMAGE_DATA_SIZE(image) (PNG_IMAGE_SIZE(image)+(image).height)
3131  /* The number of uncompressed bytes in the PNG byte encoding of the image;
3132  * uncompressing the PNG IDAT data will give this number of bytes.
3133  *
3134  * NOTE: while PNG_IMAGE_SIZE cannot overflow for an image in memory this
3135  * macro can because of the extra bytes used in the PNG byte encoding. You
3136  * need to avoid this macro if your image size approaches 2^30 in width or
3137  * height. The same goes for the remainder of these macros; they all produce
3138  * bigger numbers than the actual in-memory image size.
3139  */
3140 #ifndef PNG_ZLIB_MAX_SIZE
3141 # define PNG_ZLIB_MAX_SIZE(b) ((b)+(((b)+7U)>>3)+(((b)+63U)>>6)+11U)
3142  /* An upper bound on the number of compressed bytes given 'b' uncompressed
3143  * bytes. This is based on deflateBounds() in zlib; different
3144  * implementations of zlib compression may conceivably produce more data so
3145  * if your zlib implementation is not zlib itself redefine this macro
3146  * appropriately.
3147  */
3148 #endif
3149 
3150 #define PNG_IMAGE_COMPRESSED_SIZE_MAX(image)\
3151  PNG_ZLIB_MAX_SIZE((png_alloc_size_t)PNG_IMAGE_DATA_SIZE(image))
3152  /* An upper bound on the size of the data in the PNG IDAT chunks. */
3153 
3154 #define PNG_IMAGE_PNG_SIZE_MAX_(image, image_size)\
3155  ((8U/*sig*/+25U/*IHDR*/+16U/*gAMA*/+44U/*cHRM*/+12U/*IEND*/+\
3156  (((image).format&PNG_FORMAT_FLAG_COLORMAP)?/*colormap: PLTE, tRNS*/\
3157  12U+3U*(image).colormap_entries/*PLTE data*/+\
3158  (((image).format&PNG_FORMAT_FLAG_ALPHA)?\
3159  12U/*tRNS*/+(image).colormap_entries:0U):0U)+\
3160  12U)+(12U*((image_size)/PNG_ZBUF_SIZE))/*IDAT*/+(image_size))
3161  /* A helper for the following macro; if your compiler cannot handle the
3162  * following macro use this one with the result of
3163  * PNG_IMAGE_COMPRESSED_SIZE_MAX(image) as the second argument (most
3164  * compilers should handle this just fine.)
3165  */
3166 
3167 #define PNG_IMAGE_PNG_SIZE_MAX(image)\
3168  PNG_IMAGE_PNG_SIZE_MAX_(image, PNG_IMAGE_COMPRESSED_SIZE_MAX(image))
3169  /* An upper bound on the total length of the PNG data stream for 'image'.
3170  * The result is of type png_alloc_size_t, on 32-bit systems this may
3171  * overflow even though PNG_IMAGE_DATA_SIZE does not overflow; the write will
3172  * run out of buffer space but return a corrected size which should work.
3173  */
3174 #endif /* SIMPLIFIED_WRITE */
3175 /*******************************************************************************
3176  * END OF SIMPLIFIED API
3177  ******************************************************************************/
3178 #endif /* SIMPLIFIED_{READ|WRITE} */
3179 
3180 /*******************************************************************************
3181  * Section 6: IMPLEMENTATION OPTIONS
3182  *******************************************************************************
3183  *
3184  * Support for arbitrary implementation-specific optimizations. The API allows
3185  * particular options to be turned on or off. 'Option' is the number of the
3186  * option and 'onoff' is 0 (off) or non-0 (on). The value returned is given
3187  * by the PNG_OPTION_ defines below.
3188  *
3189  * HARDWARE: normally hardware capabilities, such as the Intel SSE instructions,
3190  * are detected at run time, however sometimes it may be impossible
3191  * to do this in user mode, in which case it is necessary to discover
3192  * the capabilities in an OS specific way. Such capabilities are
3193  * listed here when libpng has support for them and must be turned
3194  * ON by the application if present.
3195  *
3196  * SOFTWARE: sometimes software optimizations actually result in performance
3197  * decrease on some architectures or systems, or with some sets of
3198  * PNG images. 'Software' options allow such optimizations to be
3199  * selected at run time.
3200  */
3201 #ifdef PNG_SET_OPTION_SUPPORTED
3202 #ifdef PNG_ARM_NEON_API_SUPPORTED
3203 # define PNG_ARM_NEON 0 /* HARDWARE: ARM Neon SIMD instructions supported */
3204 #endif
3205 #define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */
3206 #define PNG_SKIP_sRGB_CHECK_PROFILE 4 /* SOFTWARE: Check ICC profile for sRGB */
3207 #ifdef PNG_MIPS_MSA_API_SUPPORTED
3208 # define PNG_MIPS_MSA 6 /* HARDWARE: MIPS Msa SIMD instructions supported */
3209 #endif
3210 #define PNG_IGNORE_ADLER32 8
3211 #ifdef PNG_POWERPC_VSX_API_SUPPORTED
3212 # define PNG_POWERPC_VSX 10 /* HARDWARE: PowerPC VSX SIMD instructions supported */
3213 #endif
3214 #define PNG_OPTION_NEXT 12 /* Next option - numbers must be even */
3215 
3216 /* Return values: NOTE: there are four values and 'off' is *not* zero */
3217 #define PNG_OPTION_UNSET 0 /* Unset - defaults to off */
3218 #define PNG_OPTION_INVALID 1 /* Option number out of range */
3219 #define PNG_OPTION_OFF 2
3220 #define PNG_OPTION_ON 3
3221 
3222 PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option,
3223  int onoff));
3224 #endif /* SET_OPTION */
3225 
3226 /*******************************************************************************
3227  * END OF HARDWARE AND SOFTWARE OPTIONS
3228  ******************************************************************************/
3229 
3230 /* Maintainer: Put new public prototypes here ^, in libpng.3, in project
3231  * defs, and in scripts/symbols.def.
3232  */
3233 
3234 /* The last ordinal number (this is the *last* one already used; the next
3235  * one to use is one more than this.)
3236  */
3237 #ifdef PNG_EXPORT_LAST_ORDINAL
3238  PNG_EXPORT_LAST_ORDINAL(249);
3239 #endif
3240 
3241 #ifdef __cplusplus
3242 }
3243 #endif
3244 
3245 #endif /* PNG_VERSION_INFO_ONLY */
3246 /* Do not put anything past this line */
3247 #endif /* PNG_H */
#define png_get_uint_16(buf)
Definition: png.h:2599
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point * int_red_Z
Definition: png.h:1949
png_const_structrp png_const_inforp double double * red_Y
Definition: png.h:1939
PNG_FP_EXPORT(32, void, png_set_rgb_to_gray,(png_structrp png_ptr, int error_action, double red, double green)) PNG_FIXED_EXPORT(33
GLint level
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_green_Y
Definition: png.h:1949
Definition: tftpd.h:59
png_byte blue
Definition: png.h:504
struct png_time_struct png_time
static const char filler[0x1000]
Definition: loader.c:167
png_charp text
Definition: png.h:570
png_uint_32 width
Definition: png.h:2676
struct png_sPLT_entry_struct png_sPLT_entry
#define PNG_NORETURN
Definition: pngconf.h:436
const char * png_const_charp
Definition: pngconf.h:590
#define png_get_uint_32(buf)
Definition: png.h:2598
png_get_io_chunk_type
Definition: png.h:2418
png_byte red
Definition: png.h:502
int compression
Definition: png.h:564
png_set_alpha_mode_fixed
Definition: png.h:1139
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
const png_unknown_chunk * png_const_unknown_chunkp
Definition: png.h:639
png_controlp opaque
Definition: png.h:2674
png_const_charp PNGAPI png_get_header_ver(png_const_structrp png_ptr)
Definition: png.c:844
png_const_structrp png_const_inforp double double double double * green_X
Definition: png.h:1939
const png_sPLT_t * png_const_sPLT_tp
Definition: png.h:541
png_set_sCAL_fixed
Definition: png.h:2171
static const WCHAR exif[]
char * png_libpng_version_1_6_37
Definition: png.h:431
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed,(png_const_structrp png_ptr, png_const_inforp info_ptr, png_fixed_point *int_white_x, png_fixed_point *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point *int_blue_x, png_fixed_point *int_blue_y)) PNG_FIXED_EXPORT(231
png_uint_16 blue
Definition: png.h:493
png_byte * png_bytep
Definition: pngconf.h:579
png_get_cHRM_XYZ
Definition: png.h:1939
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
png_uint_16 gray
Definition: png.h:494
const png_sPLT_entry * png_const_sPLT_entryp
Definition: png.h:525
GLuint buffer
Definition: glext.h:5915
png_const_charp PNGAPI png_get_copyright(png_const_structrp png_ptr)
Definition: png.c:811
png_byte green
Definition: png.h:503
png_byte red
Definition: png.h:480
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point *int_blue_Z png_const_structrp png_inforp double double double double double double double double double blue_Z png_set_cHRM_XYZ_fixed
Definition: png.h:1973
png_structrp png_const_color_16p int background_gamma_code
Definition: png.h:1302
png_uint_32 flags
Definition: png.h:2679
char * png_charp
Definition: pngconf.h:589
png_struct * png_structp
Definition: png.h:441
png_byte ** png_bytepp
Definition: pngconf.h:606
png_uint_32 warning_or_error
Definition: png.h:2705
png_uint_16 frequency
Definition: png.h:522
png_set_gamma_fixed
Definition: png.h:1352
png_charp lang
Definition: png.h:574
static char memory[1024 *256]
Definition: process.c:116
png_color ** png_colorpp
Definition: png.h:486
png_voidp PNGAPI png_get_io_ptr(png_const_structrp png_ptr)
Definition: png.c:686
png_text * png_textp
Definition: png.h:579
png_sPLT_t * png_sPLT_tp
Definition: png.h:540
void display_row(char *data, int off, int len)
Definition: iptest.cpp:39
png_color_16 ** png_color_16pp
Definition: png.h:498
png_const_structrp png_const_inforp double double double double double double * green_Z
Definition: png.h:1939
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point * int_red_X
Definition: png.h:1949
png_info ** png_infopp
Definition: png.h:456
#define PNG_ALLOCATED
Definition: pngconf.h:439
png_uint_16 blue
Definition: png.h:520
const png_color_8 * png_const_color_8p
Definition: png.h:509
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_green_X
Definition: png.h:1949
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
PNG_EXPORT(1, png_uint_32, png_access_version_number,(void))
GLenum GLint GLuint mask
Definition: glext.h:6028
void error_message(HWND hwnd, const char *msg)
Definition: main.cpp:785
png_byte hour
Definition: png.h:605
#define PNG_DEPRECATED
Definition: pngpriv.h:332
GLenum const GLfloat * params
Definition: glext.h:5645
const png_time * png_const_timep
Definition: png.h:610
png_unknown_chunk * png_unknown_chunkp
Definition: png.h:638
#define PNGARG(arglist)
Definition: pngconf.h:94
png_structrp int png_fixed_point red
Definition: png.h:1083
static PVOID ptr
Definition: dispmode.c:27
png_uint_32 width
Definition: png.h:756
#define PNGCAPI
Definition: pngconf.h:255
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:927
png_charp key
Definition: png.h:569
png_const_structrp png_const_inforp int * unit
Definition: png.h:2161
struct png_color_8_struct png_color_8
png_byte second
Definition: png.h:607
png_color_8 * png_color_8p
Definition: png.h:508
Definition: getopt.h:108
const png_struct *PNG_RESTRICT png_const_structrp
Definition: png.h:470
png_uint_32 format
Definition: png.h:2678
png_byte color_type
Definition: png.h:758
png_uint_16 green
Definition: png.h:492
png_const_structrp png_const_inforp double double double * red_Z
Definition: png.h:1939
png_const_structrp png_const_inforp double double double double double double double double * blue_Y
Definition: png.h:1939
png_byte depth
Definition: png.h:536
const png_info *PNG_RESTRICT png_const_inforp
Definition: png.h:472
png_byte channels
Definition: png.h:760
png_uint_32
Definition: png.h:1939
GLuint GLfloat * val
Definition: glext.h:7180
struct png_image * png_imagep
struct png_text_struct png_text
png_const_charp PNGAPI png_get_header_version(png_const_structrp png_ptr)
Definition: png.c:852
png_structrp png_fixed_point screen_gamma
Definition: png.h:1352
png_int_32 png_fixed_point
Definition: pngconf.h:574
png_byte minute
Definition: png.h:606
const png_color * png_const_colorp
Definition: png.h:485
png_uint_32 version
Definition: png.h:2675
struct png_sPLT_struct png_sPLT_t
GLsizeiptr size
Definition: glext.h:5919
PNG_EXPORTA(4, png_structp, png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn), PNG_ALLOCATED)
const png_byte * png_const_bytep
Definition: pngconf.h:580
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
const png_uint_16 * png_const_uint_16p
Definition: pngconf.h:586
png_row_info * png_row_infop
Definition: png.h:764
struct png_color_16_struct png_color_16
typedef PNG_CALLBACK(void, *png_error_ptr,(png_structp, png_const_charp))
png_unknown_chunk ** png_unknown_chunkpp
Definition: png.h:640
ed2 num_bytes
Definition: write.c:2846
int JSAMPARRAY int int num_rows
Definition: jpegint.h:412
static FILE * out
Definition: regtests2xml.c:44
png_sPLT_t ** png_sPLT_tpp
Definition: png.h:542
GLclampf green
Definition: gl.h:1740
GLuint GLuint num
Definition: glext.h:9618
png_const_structrp png_const_inforp info_ptr
Definition: png.h:1939
const png_double * png_const_doublep
Definition: pngpriv.h:374
char ** png_charpp
Definition: pngconf.h:612
png_byte pixel_depth
Definition: png.h:761
png_get_sCAL_fixed
Definition: png.h:2161
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
png_int_32 nentries
Definition: png.h:538
GLbitfield flags
Definition: glext.h:7161
method
Definition: dragdrop.c:53
png_get_pixel_aspect_ratio_fixed
Definition: png.h:1903
png_struct *PNG_RESTRICT png_structrp
Definition: png.h:469
png_const_charp PNGAPI png_get_libpng_ver(png_const_structrp png_ptr)
Definition: png.c:837
png_sPLT_entry * png_sPLT_entryp
Definition: png.h:524
size_t size
Definition: png.h:626
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean flag
Definition: glfuncs.h:52
png_byte location
Definition: png.h:634
#define png_get_int_32(buf)
Definition: png.h:2600
png_get_gAMA_fixed
Definition: png.h:1996
png_uint_16 red
Definition: png.h:518
png_set_background_fixed
Definition: png.h:1302
const png_info * png_const_infop
Definition: png.h:455
Definition: time.h:76
png_time * png_timep
Definition: png.h:609
GLenum mode
Definition: glext.h:6217
const png_color_16 * png_const_color_16p
Definition: png.h:497
static HPALETTE palette
Definition: clipboard.c:1345
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_blue_X
Definition: png.h:1949
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point * int_red_Y
Definition: png.h:1949
png_structrp png_ptr
Definition: png.h:1083
png_byte index
Definition: png.h:490
png_structrp int error_action
Definition: png.h:1083
png_structrp png_const_color_16p int int need_expand
Definition: png.h:1302
png_byte day
Definition: png.h:604
png_uint_16 * png_uint_16p
Definition: pngconf.h:585
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_get_cHRM_XYZ_fixed
Definition: png.h:1949
png_color * png_colorp
Definition: png.h:484
png_set_rgb_to_gray_fixed
Definition: png.h:1083
png_row_info ** png_row_infopp
Definition: png.h:765
__kernel_time_t time_t
Definition: linux.h:252
png_const_structrp png_const_inforp double double double double double double double * blue_X
Definition: png.h:1939
struct png_unknown_chunk_t png_unknown_chunk
GLuint start
Definition: gl.h:1545
struct png_control * png_controlp
Definition: png.h:2671
PNG_FUNCTION(void,(PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef)
png_uint_16 alpha
Definition: png.h:521
#define PNG_RESTRICT
Definition: pngconf.h:445
size_t png_alloc_size_t
Definition: pngconf.h:557
size_t itxt_length
Definition: png.h:573
png_const_structrp png_const_inforp png_fixed_point *int_file_gamma png_set_gAMA_fixed
Definition: png.h:2004
png_set_filter_heuristics_fixed
Definition: png.h:1488
png_uint_32 height
Definition: png.h:2677
png_byte month
Definition: png.h:603
png_structrp png_const_color_16p background_color
Definition: png.h:1302
static LPCWSTR file_name
Definition: protocol.c:147
png_charp lang_key
Definition: png.h:576
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point *int_blue_Z png_set_cHRM_XYZ
Definition: png.h:1963
png_uint_16 green
Definition: png.h:519
png_charp name
Definition: png.h:535
png_byte alpha
Definition: png.h:506
png_sPLT_entry ** png_sPLT_entrypp
Definition: png.h:526
png_structrp int int num_weights
Definition: png.h:1488
Definition: name.c:38
png_uint_32 colormap_entries
Definition: png.h:2680
struct png_row_info_struct png_row_info
png_const_structrp png_const_inforp double double double double double * green_Y
Definition: png.h:1939
Definition: png.h:516
const png_struct * png_const_structp
Definition: png.h:440
png_uint_16 red
Definition: png.h:491
png_info *PNG_RESTRICT png_inforp
Definition: png.h:471
#define profile
Definition: kernel32.h:12
PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name,(png_structrp png_ptr), PNG_DEPRECATED) PNG_EXPORT(216
static const char * onoff(int bool)
Definition: cmds.c:777
png_byte * data
Definition: png.h:625
long jmp_buf[100]
Definition: of.h:11
png_text ** png_textpp
Definition: png.h:581
size_t text_length
Definition: png.h:572
png_color_16 * png_color_16p
Definition: png.h:496
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_blue_Y
Definition: png.h:1949
png_color_8 ** png_color_8pp
Definition: png.h:510
png_byte gray
Definition: png.h:505
GLfloat units
Definition: glext.h:11727
png_structrp int int png_const_fixed_point_p filter_weights
Definition: png.h:1488
png_structrp int heuristic_method
Definition: png.h:1488
png_sPLT_entryp entries
Definition: png.h:537
size_t rowbytes
Definition: png.h:757
png_info * png_infop
Definition: png.h:454
png_const_structrp png_const_inforp double * red_X
Definition: png.h:1939
const png_text * png_const_textp
Definition: png.h:580
png_uint_16 year
Definition: png.h:602
png_byte green
Definition: png.h:481
png_const_structrp png_const_inforp double double double double double double double double double *blue_Z png_const_structrp png_const_inforp png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point png_fixed_point * int_green_Z
Definition: png.h:1949
png_get_x_offset_inches_fixed
Definition: png.h:2392
png_byte bit_depth
Definition: png.h:759
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78
png_byte blue
Definition: png.h:482
struct png_color_struct png_color
png_struct ** png_structpp
Definition: png.h:442
png_uint_32 PNGAPI png_access_version_number(void)
Definition: png.c:986
png_time ** png_timepp
Definition: png.h:611
Definition: fci.c:126
const png_fixed_point * png_const_fixed_point_p
Definition: pngconf.h:592
png_const_structrp png_const_inforp info_ptr png_get_y_offset_inches_fixed
Definition: png.h:2399