ReactOS 0.4.15-dev-8222-g9164419
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.39 - November 20, 2022
5 *
6 * Copyright (c) 2018-2022 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.39, November 2022:
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-2022 The PNG Reference Library Authors.
31 * * Copyright (c) 2018-2022 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.39 16 10639 16.so.16.39[.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.39"
282#define PNG_HEADER_VERSION_STRING " libpng version 1.6.39 - November 20, 2022\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 39
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 10639 /* 1.6.39 */
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
368extern "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 */
431typedef char* png_libpng_version_1_6_39;
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 */
440typedef const png_struct * png_const_structp;
441typedef png_struct * png_structp;
442typedef png_struct * * png_structpp;
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 */
453typedef struct png_info_def png_info;
454typedef png_info * png_infop;
455typedef const png_info * png_const_infop;
456typedef 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 */
478typedef struct png_color_struct
480 png_byte red;
481 png_byte green;
482 png_byte blue;
484typedef png_color * png_colorp;
486typedef png_color * * png_colorpp;
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 */
498typedef png_color_16 * * png_color_16pp;
500typedef struct png_color_8_struct
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 */
508typedef png_color_8 * png_color_8p;
509typedef const png_color_8 * png_const_color_8p;
510typedef png_color_8 * * png_color_8pp;
511
512/*
513 * The following two structures are used for the in-core representation
514 * of sPLT chunks.
515 */
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 */
533typedef struct png_sPLT_struct
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 */
540typedef png_sPLT_t * png_sPLT_tp;
541typedef const png_sPLT_t * png_const_sPLT_tp;
542typedef png_sPLT_t * * png_sPLT_tpp;
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 */
562typedef 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 */
579typedef png_text * png_textp;
580typedef const png_text * png_const_textp;
581typedef png_text * * png_textpp;
582#endif
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 */
600typedef struct png_time_struct
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) */
609typedef png_time * png_timep;
610typedef const png_time * png_const_timep;
611typedef 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.
620 * The data in the structure is set by libpng on read and used on write.
621 */
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 */
641#endif
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
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)
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
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
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
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
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 */
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 */
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 */
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 */
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 */
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 */
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) */
763
765typedef png_row_info * * png_row_infopp;
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 */
775typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp));
776typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, size_t));
777typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp));
778typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32,
779 int));
780typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32,
781 int));
782
783#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
784typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop));
785typedef 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 */
797typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep,
798 png_uint_32, int));
799#endif
801#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
802 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
803typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop,
804 png_bytep));
805#endif
806
807#ifdef PNG_USER_CHUNKS_SUPPORTED
808typedef 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 */
828PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef);
829#endif
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
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 */
867typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp,
869typedef 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 */
906PNG_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 */
913PNG_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. */
922PNG_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),
926
927/* Allocate and initialize png_ptr struct for writing, and any other memory */
928PNG_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),
932
933PNG_EXPORT(6, size_t, png_get_compression_buffer_size,
935
936PNG_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 */
950PNG_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 */
963PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val),
966#ifdef PNG_READ_SUPPORTED
967/* Reset the compression stream */
968PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED);
969#endif
971/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
972#ifdef PNG_USER_MEM_SUPPORTED
973PNG_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),
978PNG_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),
983#endif
984
985/* Write the PNG file signature. */
986PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr));
987
988/* Write a PNG chunk - size, type, (optional) data, CRC. */
989PNG_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. */
993PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
995
996/* Write the data of a PNG chunk started with png_write_chunk_start(). */
997PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr,
999
1000/* Finish a chunk started with png_write_chunk_start() (includes CRC). */
1001PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
1002
1003/* Allocate and initialize the info structure */
1004PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr),
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 */
1011PNG_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. */
1015PNG_EXPORT(20, void, png_write_info_before_PLTE,
1017PNG_EXPORT(21, void, png_write_info,
1020#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1021/* Read the information before the actual image data. */
1022PNG_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.
1031#if PNG_LIBPNG_VER < 10700
1032/* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */
1033PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr,
1035#endif
1036PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29],
1037 png_const_timep ptime));
1038#endif
1040#ifdef PNG_CONVERT_tIME_SUPPORTED
1041/* Convert from a struct tm to png_time */
1042PNG_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() */
1046PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime));
1047#endif /* CONVERT_tIME */
1049#ifdef PNG_READ_EXPAND_SUPPORTED
1050/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
1051PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr));
1052PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr));
1053PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr));
1054PNG_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 */
1061PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr));
1062#endif
1064#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
1065/* Use blue, green, red order for pixels. */
1066PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr));
1067#endif
1069#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
1070/* Expand the grayscale to 24-bit RGB if necessary. */
1071PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr));
1072#endif
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*/
1081PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr,
1082 int error_action, double red, double green))
1085
1086PNG_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
1091PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth,
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:
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 */
1137PNG_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.
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.
1228
1229#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
1230PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr));
1231#endif
1233#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
1234 defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
1235PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr));
1236#endif
1238#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
1239 defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
1240PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr));
1241#endif
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. */
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. */
1251PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr,
1252 png_uint_32 filler, int flags));
1253#endif /* READ_FILLER || WRITE_FILLER */
1255#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
1256/* Swap bytes in 16-bit depth files. */
1257PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr));
1258#endif
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. */
1262PNG_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. */
1268PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr));
1269#endif
1271#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
1272/* Converts files to legal bit depths. */
1273PNG_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*/
1285PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr));
1286#endif
1288#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
1289/* Invert monochrome files */
1290PNG_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 */
1299PNG_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
1313#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
1314/* Scale a 16-bit depth file down to 8-bit, accurately. */
1315PNG_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. */
1321PNG_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 */
1328PNG_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.
1350PNG_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
1356#ifdef PNG_WRITE_FLUSH_SUPPORTED
1357/* Set how many lines between output flushes - 0 for no flushing */
1358PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows));
1359/* Flush the current PNG output buffer */
1360PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr));
1361#endif
1362
1363/* Optional update palette with requested transformations */
1364PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr));
1365
1366/* Optional call to update the users info structure */
1367PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr,
1370#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1371/* Read one or more rows of image data. */
1372PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row,
1374#endif
1376#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1377/* Read a row of data. */
1378PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row,
1380#endif
1382#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1383/* Read the whole image into memory at once. */
1384PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image));
1385#endif
1386
1387/* Write a row of image data */
1388PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr,
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 */
1396PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row,
1398
1399/* Write the image data */
1400PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image));
1401
1402/* Write the end of the PNG file. */
1403PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr,
1406#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1407/* Read the end of the PNG file. */
1408PNG_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 */
1412PNG_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 */
1416PNG_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 */
1420PNG_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 */
1424PNG_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.
1434 * value action:critical action:ancillary
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 explanation 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 */
1455PNG_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.
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.
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
1483#ifdef PNG_WRITE_SUPPORTED
1484#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */
1485PNG_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 */
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 calculations. In the future,
1505 * these values may not correspond directly to the zlib compression levels.
1506 */
1507#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
1508PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr,
1509 int level));
1510
1511PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr,
1512 int mem_level));
1513
1514PNG_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 */
1520PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr,
1521 int window_bits));
1522
1523PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr,
1524 int method));
1525#endif /* WRITE_CUSTOMIZE_COMPRESSION */
1527#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
1528/* Also set zlib parameters for compressing non-IDAT chunks */
1529PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr,
1530 int level));
1531
1532PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr,
1533 int mem_level));
1534
1535PNG_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 */
1541PNG_EXPORT(225, void, png_set_text_compression_window_bits,
1542 (png_structrp png_ptr, int window_bits));
1543
1544PNG_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 */
1558#ifdef PNG_STDIO_SUPPORTED
1559/* Initialize the input/output for the PNG file to the default functions. */
1560PNG_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
1571PNG_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 */
1575PNG_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 */
1587PNG_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. */
1591PNG_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
1597PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr,
1598 png_read_status_ptr read_row_fn));
1599
1600PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr,
1601 png_write_status_ptr write_row_fn));
1603#ifdef PNG_USER_MEM_SUPPORTED
1604/* Replace the default memory allocation functions with user supplied one(s). */
1605PNG_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 */
1608PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr));
1609#endif
1610
1611#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1612PNG_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
1617PNG_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
1622PNG_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 */
1626PNG_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 */
1642PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp));
1643PNG_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 */
1666PNG_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
1671PNG_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 */
1678PNG_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 */
1683PNG_EXPORT(91, png_voidp, png_get_progressive_ptr,
1685
1686/* Function to be called when data becomes available */
1687PNG_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 */
1697PNG_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 */
1705PNG_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 */
1712PNG_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 */
1723PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr,
1725
1726/* Frees a pointer allocated by png_malloc() */
1728
1729/* Free data that was allocated internally */
1730PNG_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 */
1740PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
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
1766PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
1768PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr,
1770#endif
1772#ifdef PNG_ERROR_TEXT_SUPPORTED
1773/* Fatal error in PNG image of libpng - can't continue */
1774PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr,
1776
1777/* The same, but the chunk name is prepended to the error string. */
1778PNG_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 */
1783PNG_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
1788#ifdef PNG_WARNINGS_SUPPORTED
1789/* Non-fatal error in libpng. Can continue, but may have a problem. */
1790PNG_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. */
1794PNG_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. */
1804PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr,
1805 png_const_charp warning_message));
1807#ifdef PNG_READ_SUPPORTED
1808/* Same, chunk name is prepended to message (only during read) */
1809PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr,
1810 png_const_charp warning_message));
1811#endif
1812
1813PNG_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. */
1838PNG_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. */
1842PNG_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 */
1849PNG_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 */
1855PNG_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. */
1860PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr,
1863#ifdef PNG_EASY_ACCESS_SUPPORTED
1864/* Returns image width in pixels. */
1865PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr,
1867
1868/* Returns image height in pixels. */
1869PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr,
1871
1872/* Returns image bit_depth. */
1873PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr,
1875
1876/* Returns image color_type. */
1877PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr,
1879
1880/* Returns image filter_type. */
1881PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr,
1883
1884/* Returns image interlace_type. */
1885PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr,
1887
1888/* Returns image compression_type. */
1889PNG_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. */
1893PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter,
1895PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter,
1897PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter,
1899
1900/* Returns pixel aspect ratio, computed from pHYs chunk data. */
1901PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio,
1905
1906/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
1907PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels,
1909PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels,
1911PNG_EXPORT(128, png_int_32, png_get_x_offset_microns,
1913PNG_EXPORT(129, png_int_32, png_get_y_offset_microns,
1915
1916#endif /* EASY_ACCESS */
1918#ifdef PNG_READ_SUPPORTED
1919/* Returns pointer to signature string read from PNG header */
1920PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr,
1922#endif
1923
1924#ifdef PNG_bKGD_SUPPORTED
1926 png_inforp info_ptr, png_color_16p *background));
1927#endif
1928
1929#ifdef PNG_bKGD_SUPPORTED
1930PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr,
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))
1943PNG_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
1959PNG_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))
1967PNG_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
1984PNG_EXPORT(247, void, png_set_eXIf, (png_const_structrp png_ptr,
1987PNG_EXPORT(248, png_uint_32, png_get_eXIf_1, (png_const_structrp png_ptr,
1989PNG_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
2002PNG_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
2011PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr,
2013#endif
2014
2017 int *bit_depth, int *color_type, int *interlace_method,
2018 int *compression_method, int *filter_method));
2019
2020PNG_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
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
2032PNG_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
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
2045PNG_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
2053 int *unit_type));
2054#endif
2055
2056#ifdef PNG_pHYs_SUPPORTED
2057PNG_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
2062 png_inforp info_ptr, png_colorp *palette, int *num_palette));
2063
2064PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr,
2066
2067#ifdef PNG_sBIT_SUPPORTED
2069 png_inforp info_ptr, png_color_8p *sig_bit));
2070#endif
2071
2072#ifdef PNG_sBIT_SUPPORTED
2073PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr,
2075#endif
2076
2077#ifdef PNG_sRGB_SUPPORTED
2079 png_const_inforp info_ptr, int *file_srgb_intent));
2080#endif
2081
2082#ifdef PNG_sRGB_SUPPORTED
2083PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr,
2084 png_inforp info_ptr, int srgb_intent));
2085PNG_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
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
2096PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr,
2097 png_inforp info_ptr, png_const_charp name, int compression_type,
2099#endif
2100
2101#ifdef PNG_sPLT_SUPPORTED
2102PNG_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
2107PNG_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
2111#ifdef PNG_TEXT_SUPPORTED
2112/* png_get_text also returns the number of text chunks in *num_text */
2113PNG_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.
2123
2124#ifdef PNG_TEXT_SUPPORTED
2125PNG_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
2131 png_inforp info_ptr, png_timep *mod_time));
2132#endif
2133
2134#ifdef PNG_tIME_SUPPORTED
2135PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr,
2137#endif
2138
2139#ifdef PNG_tRNS_SUPPORTED
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
2146PNG_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.
2164#endif
2165PNG_EXPORT(169, png_uint_32, png_get_sCAL_s,
2167 png_charpp swidth, png_charpp sheight));
2169PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr,
2170 png_inforp info_ptr, int unit, double width, double height))
2174PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
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
2279PNG_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 */
2287PNG_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
2292PNG_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
2304PNG_EXPORT(175, void, png_set_unknown_chunk_location,
2306
2307PNG_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 */
2315PNG_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
2321PNG_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
2325PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr,
2326 int transforms, png_voidp params));
2327#endif
2328#endif
2338
2339#ifdef PNG_MNG_FEATURES_SUPPORTED
2340PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr,
2341 png_uint_32 mng_features_permitted));
2342#endif
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
2355PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr,
2356 png_uint_32 strip_mode));
2357#endif
2359/* Added in libpng-1.2.6 */
2360#ifdef PNG_SET_USER_LIMITS_SUPPORTED
2361PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr,
2362 png_uint_32 user_width_max, png_uint_32 user_height_max));
2363PNG_EXPORT(187, png_uint_32, png_get_user_width_max,
2365PNG_EXPORT(188, png_uint_32, png_get_user_height_max,
2367/* Added in libpng-1.4.0 */
2368PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr,
2369 png_uint_32 user_chunk_cache_max));
2370PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max,
2372/* Added in libpng-1.4.1 */
2373PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr,
2374 png_alloc_size_t user_chunk_cache_max));
2375PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max,
2377#endif
2378
2379#if defined(PNG_INCH_CONVERSIONS_SUPPORTED)
2380PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch,
2382
2383PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch,
2385
2386PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch,
2388
2389PNG_FP_EXPORT(196, float, png_get_x_offset_inches,
2391#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
2394#endif
2395
2396PNG_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
2404PNG_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 */
2410/* Added in libpng-1.4.0 */
2411#ifdef PNG_IO_STATE_SUPPORTED
2413
2414/* Removed from libpng 1.6; use png_get_io_chunk_type. */
2415PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr),
2417
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.
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:
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))
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 */
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 */
2543#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
2545PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf));
2547#endif
2548
2549PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr,
2551/* No png_get_int_16 -- may be added if there's a real need for it. */
2553/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */
2554#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
2555PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i));
2556#endif
2557#ifdef PNG_SAVE_INT_32_SUPPORTED
2558PNG_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
2566PNG_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.
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
2612PNG_EXPORT(242, void, png_set_check_for_invalid_index,
2613 (png_structrp png_ptr, int allowed));
2614# ifdef PNG_GET_PALETTE_MAX_SUPPORTED
2615PNG_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)
2669#define PNG_IMAGE_VERSION 1
2670
2671typedef struct png_control *png_controlp;
2672typedef struct
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 */
2680 png_uint_32 colormap_entries;
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
2703# define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1)
2705 png_uint_32 warning_or_error;
2706
2707 char message[64];
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:
2776 * PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED
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.
2795 * First the single byte (sRGB) formats:
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.
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.
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.
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.
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
2980PNG_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
2986PNG_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
2991PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image,
2993 /* The PNG header is read from the given memory buffer. */
2994
2995PNG_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
3030PNG_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
3054PNG_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
3059PNG_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
3086PNG_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.
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 */
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
3222PNG_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 */
static const char * onoff(int bool)
Definition: cmds.c:777
_JBTYPE jmp_buf[_JBLEN]
Definition: setjmp.h:186
void error_message(HWND hwnd, const char *msg)
Definition: main.cpp:783
static const WCHAR version[]
Definition: asmname.c:66
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
method
Definition: dragdrop.c:54
__kernel_time_t time_t
Definition: linux.h:252
GLuint start
Definition: gl.h:1545
GLint level
Definition: gl.h:1546
GLclampf green
Definition: gl.h:1740
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
GLuint buffer
Definition: glext.h:5915
GLenum GLint GLuint mask
Definition: glext.h:6028
GLenum mode
Definition: glext.h:6217
GLenum const GLfloat * params
Definition: glext.h:5645
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLfloat units
Definition: glext.h:11727
GLbitfield flags
Definition: glext.h:7161
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
GLuint GLfloat * val
Definition: glext.h:7180
GLuint GLuint num
Definition: glext.h:9618
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
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
void display_row(char *data, int off, int len)
Definition: iptest.cpp:39
int JSAMPARRAY int int num_rows
Definition: jpegint.h:421
#define profile
Definition: kernel32.h:12
static const WCHAR exif[]
static PVOID ptr
Definition: dispmode.c:27
static const char filler[0x1000]
Definition: loader.c:167
static char memory[1024 *256]
Definition: process.c:116
static LPCWSTR file_name
Definition: protocol.c:147
static HPALETTE palette
Definition: clipboard.c:1345
png_voidp PNGAPI png_get_io_ptr(png_const_structrp png_ptr)
Definition: png.c:686
png_const_charp PNGAPI png_get_copyright(png_const_structrp png_ptr)
Definition: png.c:811
png_const_charp PNGAPI png_get_header_ver(png_const_structrp png_ptr)
Definition: png.c:844
png_const_charp PNGAPI png_get_libpng_ver(png_const_structrp png_ptr)
Definition: png.c:837
png_const_charp PNGAPI png_get_header_version(png_const_structrp png_ptr)
Definition: png.c:852
png_uint_32 PNGAPI png_access_version_number(void)
Definition: png.c:986
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:1960
#define png_get_uint_16(buf)
Definition: png.h:2596
png_unknown_chunk * png_unknown_chunkp
Definition: png.h:635
png_struct * png_structp
Definition: png.h:438
png_structrp png_fixed_point screen_gamma
Definition: png.h:1350
png_set_rgb_to_gray_fixed
Definition: png.h:1080
png_const_structrp png_const_inforp double * red_X
Definition: png.h:1937
png_const_structrp png_const_inforp double double double double double double double double * blue_Y
Definition: png.h:1939
png_color * png_colorp
Definition: png.h:481
png_sPLT_t ** png_sPLT_tpp
Definition: png.h:539
png_get_cHRM_XYZ
Definition: png.h:1936
png_get_x_offset_inches_fixed
Definition: png.h:2389
png_const_structrp png_const_inforp int * unit
Definition: png.h:2159
struct png_row_info_struct png_row_info
png_structrp png_const_color_16p int background_gamma_code
Definition: png.h:1300
png_get_io_chunk_type
Definition: png.h:2415
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:1951
png_info ** png_infopp
Definition: png.h:453
const png_text * png_const_textp
Definition: png.h:577
png_color ** png_colorpp
Definition: png.h:483
png_set_alpha_mode_fixed
Definition: png.h:1136
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:1950
png_text * png_textp
Definition: png.h:576
#define png_get_int_32(buf)
Definition: png.h:2597
png_structrp png_ptr
Definition: png.h:1080
const png_color_8 * png_const_color_8p
Definition: png.h:506
png_const_structrp png_const_inforp double double double double double double * green_Z
Definition: png.h:1938
png_uint_32
Definition: png.h:1936
png_color_8 ** png_color_8pp
Definition: png.h:507
png_const_structrp png_const_inforp double double double * red_Z
Definition: png.h:1937
png_unknown_chunk ** png_unknown_chunkpp
Definition: png.h:637
struct png_control * png_controlp
Definition: png.h:2668
png_sPLT_entry ** png_sPLT_entrypp
Definition: png.h:523
png_text ** png_textpp
Definition: png.h:578
char * png_libpng_version_1_6_39
Definition: png.h:428
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:1970
png_time * png_timep
Definition: png.h:606
png_row_info ** png_row_infopp
Definition: png.h:762
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:1948
png_set_filter_heuristics_fixed
Definition: png.h:1485
png_row_info * png_row_infop
Definition: png.h:761
const png_struct * png_const_structp
Definition: png.h:437
struct png_sPLT_struct png_sPLT_t
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:1948
png_structrp int int num_weights
Definition: png.h:1486
png_const_structrp png_const_inforp double double double double double * green_Y
Definition: png.h:1938
png_const_structrp png_const_inforp double double double double * green_X
Definition: png.h:1938
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:1951
png_set_sCAL_fixed
Definition: png.h:2168
png_structrp int png_fixed_point red
Definition: png.h:1081
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:1946
png_const_structrp png_const_inforp double double * red_Y
Definition: png.h:1937
struct png_image * png_imagep
png_color_16 ** png_color_16pp
Definition: png.h:495
png_sPLT_entry * png_sPLT_entryp
Definition: png.h:521
png_const_structrp png_const_inforp png_fixed_point *int_file_gamma png_set_gAMA_fixed
Definition: png.h:2001
struct png_text_struct png_text
png_get_gAMA_fixed
Definition: png.h:1993
struct png_time_struct png_time
struct png_unknown_chunk_t png_unknown_chunk
png_set_background_fixed
Definition: png.h:1299
png_color_16 * png_color_16p
Definition: png.h:493
struct png_sPLT_entry_struct png_sPLT_entry
png_const_structrp png_const_inforp info_ptr png_get_y_offset_inches_fixed
Definition: png.h:2396
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:1950
struct png_color_struct png_color
png_const_structrp png_const_inforp double double double double double double double * blue_X
Definition: png.h:1938
#define png_get_uint_32(buf)
Definition: png.h:2595
const png_sPLT_entry * png_const_sPLT_entryp
Definition: png.h:522
png_get_pixel_aspect_ratio_fixed
Definition: png.h:1900
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
png_sPLT_t * png_sPLT_tp
Definition: png.h:537
struct png_color_8_struct png_color_8
png_get_sCAL_fixed
Definition: png.h:2158
png_structrp int heuristic_method
Definition: png.h:1486
const png_time * png_const_timep
Definition: png.h:607
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_structrp int error_action
Definition: png.h:1081
const png_info * png_const_infop
Definition: png.h:452
const png_struct *PNG_RESTRICT png_const_structrp
Definition: png.h:467
png_struct ** png_structpp
Definition: png.h:439
png_const_structrp png_const_inforp int png_fixed_point * width
Definition: png.h:2160
const png_info *PNG_RESTRICT png_const_inforp
Definition: png.h:469
png_set_gamma_fixed
Definition: png.h:1349
png_structrp int int png_const_fixed_point_p filter_weights
Definition: png.h:1487
png_info * png_infop
Definition: png.h:451
const png_unknown_chunk * png_const_unknown_chunkp
Definition: png.h:636
png_structrp png_const_color_16p int int need_expand
Definition: png.h:1301
const png_sPLT_t * png_const_sPLT_tp
Definition: png.h:538
png_structrp png_const_color_16p background_color
Definition: png.h:1300
png_info *PNG_RESTRICT png_inforp
Definition: png.h:468
png_time ** png_timepp
Definition: png.h:608
struct png_color_16_struct png_color_16
const png_color * png_const_colorp
Definition: png.h:482
png_struct *PNG_RESTRICT png_structrp
Definition: png.h:466
png_color_8 * png_color_8p
Definition: png.h:505
png_const_structrp png_const_inforp info_ptr
Definition: png.h:1937
const png_color_16 * png_const_color_16p
Definition: png.h:494
#define PNG_NORETURN
Definition: pngconf.h:436
#define PNG_FUNCTION(type, name, args, attributes)
Definition: pngconf.h:287
#define PNG_EXPORTA(ordinal, type, name, args, attributes)
Definition: pngconf.h:300
char * png_charp
Definition: pngconf.h:589
png_int_32 png_fixed_point
Definition: pngconf.h:574
const png_byte * png_const_bytep
Definition: pngconf.h:580
const png_uint_16 * png_const_uint_16p
Definition: pngconf.h:586
char ** png_charpp
Definition: pngconf.h:612
size_t png_alloc_size_t
Definition: pngconf.h:557
#define PNG_CALLBACK(type, name, args)
Definition: pngconf.h:319
png_byte * png_bytep
Definition: pngconf.h:579
#define PNGCAPI
Definition: pngconf.h:255
#define PNGARG(arglist)
Definition: pngconf.h:94
png_byte ** png_bytepp
Definition: pngconf.h:606
png_uint_16 * png_uint_16p
Definition: pngconf.h:585
const png_fixed_point * png_const_fixed_point_p
Definition: pngconf.h:592
#define PNG_EXPORT(ordinal, type, name, args)
Definition: pngconf.h:310
#define PNG_ALLOCATED
Definition: pngconf.h:439
const char * png_const_charp
Definition: pngconf.h:590
#define PNG_REMOVED(ordinal, type, name, args, attributes)
Definition: pngconf.h:315
#define PNG_RESTRICT
Definition: pngconf.h:445
#define PNG_FIXED_EXPORT(ordinal, type, name, args)
Definition: pngpriv.h:387
#define PNG_DEPRECATED
Definition: pngpriv.h:338
#define PNG_FP_EXPORT(ordinal, type, name, args)
Definition: pngpriv.h:375
const png_double * png_const_doublep
Definition: pngpriv.h:380
static FILE * out
Definition: regtests2xml.c:44
Definition: fci.c:127
Definition: tftpd.h:60
Definition: name.c:39
Definition: getopt.h:109
png_uint_16 red
Definition: png.h:488
png_byte index
Definition: png.h:487
png_uint_16 gray
Definition: png.h:491
png_uint_16 green
Definition: png.h:489
png_uint_16 blue
Definition: png.h:490
png_byte green
Definition: png.h:500
png_byte gray
Definition: png.h:502
png_byte blue
Definition: png.h:501
png_byte red
Definition: png.h:499
png_byte alpha
Definition: png.h:503
png_byte blue
Definition: png.h:479
png_byte red
Definition: png.h:477
png_byte green
Definition: png.h:478
png_uint_32 width
Definition: png.h:753
png_byte color_type
Definition: png.h:755
png_byte bit_depth
Definition: png.h:756
png_byte pixel_depth
Definition: png.h:758
png_byte channels
Definition: png.h:757
size_t rowbytes
Definition: png.h:754
Definition: png.h:514
png_uint_16 red
Definition: png.h:515
png_uint_16 blue
Definition: png.h:517
png_uint_16 green
Definition: png.h:516
png_uint_16 alpha
Definition: png.h:518
png_uint_16 frequency
Definition: png.h:519
png_sPLT_entryp entries
Definition: png.h:534
png_byte depth
Definition: png.h:533
png_int_32 nentries
Definition: png.h:535
png_charp name
Definition: png.h:532
png_charp text
Definition: png.h:567
png_charp lang_key
Definition: png.h:573
size_t text_length
Definition: png.h:569
png_charp lang
Definition: png.h:571
png_charp key
Definition: png.h:566
int compression
Definition: png.h:561
size_t itxt_length
Definition: png.h:570
png_byte month
Definition: png.h:600
png_uint_16 year
Definition: png.h:599
png_byte hour
Definition: png.h:602
png_byte second
Definition: png.h:604
png_byte minute
Definition: png.h:603
png_byte day
Definition: png.h:601
png_byte * data
Definition: png.h:622
size_t size
Definition: png.h:623
png_byte location
Definition: png.h:631
Definition: time.h:68
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:888