2 /* png.h - header file for PNG reference library
4 * libpng version 1.5.12 - July 11, 2012
5 * Copyright (c) 1998-2012 Glenn Randers-Pehrson
6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
9 * This code is released under the libpng license (See LICENSE, below)
11 * Authors and maintainers:
12 * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
13 * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger
14 * libpng versions 0.97, January 1998, through 1.5.12 - July 11, 2012: Glenn
15 * See also "Contributing Authors", below.
17 * Note about libpng version numbers:
19 * Due to various miscommunications, unforeseen code incompatibilities
20 * and occasional factors outside the authors' control, version numbering
21 * on the library has not always been consistent and straightforward.
22 * The following table summarizes matters since version 0.89c, which was
23 * the first widely used release:
25 * source png.h png.h shared-lib
26 * version string int version
27 * ------- ------ ----- ----------
28 * 0.89c "1.0 beta 3" 0.89 89 1.0.89
29 * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90]
30 * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95]
31 * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96]
32 * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97]
33 * 0.97c 0.97 97 2.0.97
36 * 0.99a-m 0.99 99 2.0.99
37 * 1.00 1.00 100 2.1.0 [100 should be 10000]
38 * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000]
39 * 1.0.1 png.h string is 10001 2.1.0
40 * 1.0.1a-e identical to the 10002 from here on, the shared library
41 * 1.0.2 source version) 10002 is 2.V where V is the source code
42 * 1.0.2a-b 10003 version, except as noted.
47 * 1.0.5 (+ 2 patches) 10005
49 * 1.0.5e-r 10100 (not source compatible)
50 * 1.0.5s-v 10006 (not binary compatible)
51 * 1.0.6 (+ 3 patches) 10006 (still binary incompatible)
52 * 1.0.6d-f 10007 (still binary incompatible)
54 * 1.0.6h 10007 10.6h (testing xy.z so-numbering)
56 * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0)
57 * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible)
58 * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible)
59 * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible)
60 * 1.0.7 1 10007 (still compatible)
61 * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4
62 * 1.0.8rc1 1 10008 2.1.0.8rc1
63 * 1.0.8 1 10008 2.1.0.8
64 * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6
65 * 1.0.9rc1 1 10009 2.1.0.9rc1
66 * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10
67 * 1.0.9rc2 1 10009 2.1.0.9rc2
68 * 1.0.9 1 10009 2.1.0.9
69 * 1.0.10beta1 1 10010 2.1.0.10beta1
70 * 1.0.10rc1 1 10010 2.1.0.10rc1
71 * 1.0.10 1 10010 2.1.0.10
72 * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3
73 * 1.0.11rc1 1 10011 2.1.0.11rc1
74 * 1.0.11 1 10011 2.1.0.11
75 * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2
76 * 1.0.12rc1 2 10012 2.1.0.12rc1
77 * 1.0.12 2 10012 2.1.0.12
78 * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned)
79 * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2
80 * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5
81 * 1.2.0rc1 3 10200 3.1.2.0rc1
82 * 1.2.0 3 10200 3.1.2.0
83 * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4
84 * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2
85 * 1.2.1 3 10201 3.1.2.1
86 * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6
87 * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1
88 * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1
89 * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1
90 * 1.0.13 10 10013 10.so.0.1.0.13
91 * 1.2.2 12 10202 12.so.0.1.2.2
92 * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6
93 * 1.2.3 12 10203 12.so.0.1.2.3
94 * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3
95 * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1
96 * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1
97 * 1.0.14 10 10014 10.so.0.1.0.14
98 * 1.2.4 13 10204 12.so.0.1.2.4
99 * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2
100 * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3
101 * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3
102 * 1.0.15 10 10015 10.so.0.1.0.15
103 * 1.2.5 13 10205 12.so.0.1.2.5
104 * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4
105 * 1.0.16 10 10016 10.so.0.1.0.16
106 * 1.2.6 13 10206 12.so.0.1.2.6
107 * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2
108 * 1.0.17rc1 10 10017 12.so.0.1.0.17rc1
109 * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1
110 * 1.0.17 10 10017 12.so.0.1.0.17
111 * 1.2.7 13 10207 12.so.0.1.2.7
112 * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5
113 * 1.0.18rc1-5 10 10018 12.so.0.1.0.18rc1-5
114 * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5
115 * 1.0.18 10 10018 12.so.0.1.0.18
116 * 1.2.8 13 10208 12.so.0.1.2.8
117 * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3
118 * 1.2.9beta4-11 13 10209 12.so.0.9[.0]
119 * 1.2.9rc1 13 10209 12.so.0.9[.0]
120 * 1.2.9 13 10209 12.so.0.9[.0]
121 * 1.2.10beta1-7 13 10210 12.so.0.10[.0]
122 * 1.2.10rc1-2 13 10210 12.so.0.10[.0]
123 * 1.2.10 13 10210 12.so.0.10[.0]
124 * 1.4.0beta1-5 14 10400 14.so.0.0[.0]
125 * 1.2.11beta1-4 13 10211 12.so.0.11[.0]
126 * 1.4.0beta7-8 14 10400 14.so.0.0[.0]
127 * 1.2.11 13 10211 12.so.0.11[.0]
128 * 1.2.12 13 10212 12.so.0.12[.0]
129 * 1.4.0beta9-14 14 10400 14.so.0.0[.0]
130 * 1.2.13 13 10213 12.so.0.13[.0]
131 * 1.4.0beta15-36 14 10400 14.so.0.0[.0]
132 * 1.4.0beta37-87 14 10400 14.so.14.0[.0]
133 * 1.4.0rc01 14 10400 14.so.14.0[.0]
134 * 1.4.0beta88-109 14 10400 14.so.14.0[.0]
135 * 1.4.0rc02-08 14 10400 14.so.14.0[.0]
136 * 1.4.0 14 10400 14.so.14.0[.0]
137 * 1.4.1beta01-03 14 10401 14.so.14.1[.0]
138 * 1.4.1rc01 14 10401 14.so.14.1[.0]
139 * 1.4.1beta04-12 14 10401 14.so.14.1[.0]
140 * 1.4.1 14 10401 14.so.14.1[.0]
141 * 1.4.2 14 10402 14.so.14.2[.0]
142 * 1.4.3 14 10403 14.so.14.3[.0]
143 * 1.4.4 14 10404 14.so.14.4[.0]
144 * 1.5.0beta01-58 15 10500 15.so.15.0[.0]
145 * 1.5.0rc01-07 15 10500 15.so.15.0[.0]
146 * 1.5.0 15 10500 15.so.15.0[.0]
147 * 1.5.1beta01-11 15 10501 15.so.15.1[.0]
148 * 1.5.1rc01-02 15 10501 15.so.15.1[.0]
149 * 1.5.1 15 10501 15.so.15.1[.0]
150 * 1.5.2beta01-03 15 10502 15.so.15.2[.0]
151 * 1.5.2rc01-03 15 10502 15.so.15.2[.0]
152 * 1.5.2 15 10502 15.so.15.2[.0]
153 * 1.5.3beta01-10 15 10503 15.so.15.3[.0]
154 * 1.5.3rc01-02 15 10503 15.so.15.3[.0]
155 * 1.5.3beta11 15 10503 15.so.15.3[.0]
157 * 1.5.4beta01-08 15 10504 15.so.15.4[.0]
158 * 1.5.4rc01 15 10504 15.so.15.4[.0]
159 * 1.5.4 15 10504 15.so.15.4[.0]
160 * 1.5.5beta01-08 15 10505 15.so.15.5[.0]
161 * 1.5.5rc01 15 10505 15.so.15.5[.0]
162 * 1.5.5 15 10505 15.so.15.5[.0]
163 * 1.5.6beta01-07 15 10506 15.so.15.6[.0]
164 * 1.5.6rc01-03 15 10506 15.so.15.6[.0]
165 * 1.5.6 15 10506 15.so.15.6[.0]
166 * 1.5.7beta01-05 15 10507 15.so.15.7[.0]
167 * 1.5.7rc01-03 15 10507 15.so.15.7[.0]
168 * 1.5.7 15 10507 15.so.15.7[.0]
169 * 1.5.8beta01 15 10508 15.so.15.8[.0]
170 * 1.5.8rc01 15 10508 15.so.15.8[.0]
171 * 1.5.8 15 10508 15.so.15.8[.0]
172 * 1.5.9beta01-02 15 10509 15.so.15.9[.0]
173 * 1.5.9rc01 15 10509 15.so.15.9[.0]
174 * 1.5.9 15 10509 15.so.15.9[.0]
175 * 1.5.10beta01-05 15 10510 15.so.15.10[.0]
176 * 1.5.10 15 10510 15.so.15.10[.0]
177 * 1.5.11beta01 15 10511 15.so.15.11[.0]
178 * 1.5.11rc01-05 15 10511 15.so.15.11[.0]
179 * 1.5.11 15 10511 15.so.15.11[.0]
180 * 1.5.12 15 10512 15.so.15.12[.0]
182 * Henceforth the source version will match the shared-library major
183 * and minor numbers; the shared-library major version number will be
184 * used for changes in backward compatibility, as it is intended. The
185 * PNG_LIBPNG_VER macro, which is not used within libpng but is available
186 * for applications, is an unsigned integer of the form xyyzz corresponding
187 * to the source version x.y.z (leading zeros in y and z). Beta versions
188 * were given the previous public release number plus a letter, until
189 * version 1.0.6j; from then on they were given the upcoming public
190 * release number plus "betaNN" or "rcNN".
192 * Binary incompatibility exists only when applications make direct access
193 * to the info_ptr or png_ptr members through png.h, and the compiled
194 * application is loaded with a different version of the library.
196 * DLLNUM will change each time there are forward or backward changes
197 * in binary compatibility (e.g., when a new feature is added).
199 * See libpng-manual.txt or libpng.3 for more information. The PNG
200 * specification is available as a W3C Recommendation and as an ISO
201 * Specification, <http://www.w3.org/TR/2003/REC-PNG-20031110/
205 * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
207 * If you modify libpng you may insert additional notices immediately following
210 * This code is released under the libpng license.
212 * libpng versions 1.2.6, August 15, 2004, through 1.5.12, July 11, 2012, are
213 * Copyright (c) 2004, 2006-2012 Glenn Randers-Pehrson, and are
214 * distributed according to the same disclaimer and license as libpng-1.2.5
215 * with the following individual added to the list of Contributing Authors:
219 * libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are
220 * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are
221 * distributed according to the same disclaimer and license as libpng-1.0.6
222 * with the following individuals added to the list of Contributing Authors:
224 * Simon-Pierre Cadieux
228 * and with the following additions to the disclaimer:
230 * There is no warranty against interference with your enjoyment of the
231 * library or against infringement. There is no warranty that our
232 * efforts or the library will fulfill any of your particular purposes
233 * or needs. This library is provided with all faults, and the entire
234 * risk of satisfactory quality, performance, accuracy, and effort is with
237 * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
238 * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson, and are
239 * distributed according to the same disclaimer and license as libpng-0.96,
240 * with the following individuals added to the list of Contributing Authors:
243 * Glenn Randers-Pehrson
246 * libpng versions 0.89, June 1996, through 0.96, May 1997, are
247 * Copyright (c) 1996, 1997 Andreas Dilger
248 * Distributed according to the same disclaimer and license as libpng-0.88,
249 * with the following individuals added to the list of Contributing Authors:
258 * libpng versions 0.5, May 1995, through 0.88, January 1996, are
259 * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
261 * For the purposes of this copyright and license, "Contributing Authors"
262 * is defined as the following set of individuals:
270 * The PNG Reference Library is supplied "AS IS". The Contributing Authors
271 * and Group 42, Inc. disclaim all warranties, expressed or implied,
272 * including, without limitation, the warranties of merchantability and of
273 * fitness for any purpose. The Contributing Authors and Group 42, Inc.
274 * assume no liability for direct, indirect, incidental, special, exemplary,
275 * or consequential damages, which may result from the use of the PNG
276 * Reference Library, even if advised of the possibility of such damage.
278 * Permission is hereby granted to use, copy, modify, and distribute this
279 * source code, or portions hereof, for any purpose, without fee, subject
280 * to the following restrictions:
282 * 1. The origin of this source code must not be misrepresented.
284 * 2. Altered versions must be plainly marked as such and must not
285 * be misrepresented as being the original source.
287 * 3. This Copyright notice may not be removed or altered from
288 * any source or altered source distribution.
290 * The Contributing Authors and Group 42, Inc. specifically permit, without
291 * fee, and encourage the use of this source code as a component to
292 * supporting the PNG file format in commercial products. If you use this
293 * source code in a product, acknowledgment is not required but would be
298 * A "png_get_copyright" function is available, for convenient use in "about"
299 * boxes and the like:
301 * printf("%s", png_get_copyright(NULL));
303 * Also, the PNG logo (in PNG format, of course) is supplied in the
304 * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
308 * Libpng is OSI Certified Open Source Software. OSI Certified is a
309 * certification mark of the Open Source Initiative.
313 * The contributing authors would like to thank all those who helped
314 * with testing, bug fixes, and patience. This wouldn't have been
315 * possible without all of you.
317 * Thanks to Frank J. T. Wojcik for helping with the documentation.
321 * Y2K compliance in libpng:
322 * =========================
326 * Since the PNG Development group is an ad-hoc body, we can't make
327 * an official declaration.
329 * This is your unofficial assurance that libpng from version 0.71 and
330 * upward through 1.5.12 are Y2K compliant. It is my belief that
331 * earlier versions were also Y2K compliant.
333 * Libpng only has two year fields. One is a 2-byte unsigned integer
334 * that will hold years up to 65535. The other holds the date in text
335 * format, and will hold years up to 9999.
338 * "png_uint_16 year" in png_time_struct.
341 * "char time_buffer[29]" in png_struct. This will be no
342 * longer used in libpng-1.6.0 and will be removed from libpng-1.7.0.
344 * There are seven time-related functions:
345 * png.c: png_convert_to_rfc_1123() in png.c
346 * (formerly png_convert_to_rfc_1152() in error)
347 * png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
348 * png_convert_from_time_t() in pngwrite.c
349 * png_get_tIME() in pngget.c
350 * png_handle_tIME() in pngrutil.c, called in pngread.c
351 * png_set_tIME() in pngset.c
352 * png_write_tIME() in pngwutil.c, called in pngwrite.c
354 * All handle dates properly in a Y2K environment. The
355 * png_convert_from_time_t() function calls gmtime() to convert from system
356 * clock time, which returns (year - 1900), which we properly convert to
357 * the full 4-digit year. There is a possibility that applications using
358 * libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
359 * function, or that they are incorrectly passing only a 2-digit year
360 * instead of "year - 1900" into the png_convert_from_struct_tm() function,
361 * but this is not under our control. The libpng documentation has always
362 * stated that it works with 4-digit years, and the APIs have been
363 * documented as such.
365 * The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned
366 * integer to hold the year, and can hold years as large as 65535.
368 * zlib, upon which libpng depends, is also Y2K compliant. It contains
369 * no date-related code.
371 * Glenn Randers-Pehrson
373 * PNG Development Group
379 /* This is not the place to learn how to use libpng. The file libpng-manual.txt
380 * describes how to use libpng, and the file example.c summarizes it
381 * with some code on which to build. This file is useful for looking
382 * at the actual function definitions and structure components.
384 * If you just need to read a PNG file and don't want to read the documentation
385 * skip to the end of this file and read the section entitled 'simplified API'.
388 /* Version information for png.h - this should match the version in png.c */
389 #define PNG_LIBPNG_VER_STRING "1.5.12"
390 #define PNG_HEADER_VERSION_STRING \
391 " libpng version 1.5.12 - July 11, 2012\n"
393 #define PNG_LIBPNG_VER_SONUM 15
394 #define PNG_LIBPNG_VER_DLLNUM 15
396 /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
397 #define PNG_LIBPNG_VER_MAJOR 1
398 #define PNG_LIBPNG_VER_MINOR 5
399 #define PNG_LIBPNG_VER_RELEASE 12
401 /* This should match the numeric part of the final component of
402 * PNG_LIBPNG_VER_STRING, omitting any leading zero:
405 #define PNG_LIBPNG_VER_BUILD 0
408 #define PNG_LIBPNG_BUILD_ALPHA 1
409 #define PNG_LIBPNG_BUILD_BETA 2
410 #define PNG_LIBPNG_BUILD_RC 3
411 #define PNG_LIBPNG_BUILD_STABLE 4
412 #define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7
414 /* Release-Specific Flags */
415 #define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with
416 PNG_LIBPNG_BUILD_STABLE only */
417 #define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with
418 PNG_LIBPNG_BUILD_SPECIAL */
419 #define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
420 PNG_LIBPNG_BUILD_PRIVATE */
422 #define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE
424 /* Careful here. At one time, Guy wanted to use 082, but that would be octal.
425 * We must not include leading zeros.
426 * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
427 * version 1.0.0 was mis-numbered 100 instead of 10000). From
428 * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release
430 #define PNG_LIBPNG_VER 10512 /* 1.5.12 */
432 /* Library configuration: these options cannot be changed after
433 * the library has been built.
436 /* If pnglibconf.h is missing, you can
437 * copy scripts/pnglibconf.h.prebuilt to pnglibconf.h
439 # include "pnglibconf.h"
442 #ifndef PNG_VERSION_INFO_ONLY
443 # ifndef PNG_BUILDING_SYMBOL_TABLE
445 * Standard header files (not needed for the version info or while
446 * building symbol table -- see scripts/pnglibconf.dfa)
448 # ifdef PNG_SETJMP_SUPPORTED
452 /* Need the time information for converting tIME chunks, it
455 # ifdef PNG_CONVERT_tIME_SUPPORTED
456 /* "time.h" functions are not supported on all operating systems */
461 /* Machine specific configuration. */
462 # include "pngconf.h"
466 * Added at libpng-1.2.8
468 * Ref MSDN: Private as priority over Special
469 * VS_FF_PRIVATEBUILD File *was not* built using standard release
470 * procedures. If this value is given, the StringFileInfo block must
471 * contain a PrivateBuild string.
473 * VS_FF_SPECIALBUILD File *was* built by the original company using
474 * standard release procedures but is a variation of the standard
475 * file of the same version number. If this value is given, the
476 * StringFileInfo block must contain a SpecialBuild string.
479 #ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */
480 # define PNG_LIBPNG_BUILD_TYPE \
481 (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE)
483 # ifdef PNG_LIBPNG_SPECIALBUILD
484 # define PNG_LIBPNG_BUILD_TYPE \
485 (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL)
487 # define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)
491 #ifndef PNG_VERSION_INFO_ONLY
493 /* Inhibit C++ name-mangling for libpng functions but not for system calls. */
496 #endif /* __cplusplus */
498 /* Version information for C files, stored in png.c. This had better match
501 #define png_libpng_ver png_get_header_ver(NULL)
503 /* This file is arranged in several sections:
505 * 1. Any configuration options that can be specified by for the application
506 * code when it is built. (Build time configuration is in pnglibconf.h)
507 * 2. Type definitions (base types are defined in pngconf.h), structure
509 * 3. Exported library functions.
511 * The library source code has additional files (principally pngpriv.h) that
512 * allow configuration of the library.
514 /* Section 1: run time configuration
515 * See pnglibconf.h for build time configuration
517 * Run time configuration allows the application to choose between
518 * implementations of certain arithmetic APIs. The default is set
519 * at build time and recorded in pnglibconf.h, but it is safe to
520 * override these (and only these) settings. Note that this won't
521 * change what the library does, only application code, and the
522 * settings can (and probably should) be made on a per-file basis
523 * by setting the #defines before including png.h
525 * Use macros to read integers from PNG data or use the exported
527 * PNG_USE_READ_MACROS: use the macros (see below) Note that
528 * the macros evaluate their argument multiple times.
529 * PNG_NO_USE_READ_MACROS: call the relevant library function.
531 * Use the alternative algorithm for compositing alpha samples that
532 * does not use division?
533 * PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division'
535 * PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm.
537 * How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is
539 * PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error
540 * APIs to png_warning.
541 * Otherwise the calls are mapped to png_error.
544 /* Section 2: type definitions, including structures and compile time
546 * See pngconf.h for base types that vary by machine/system
549 /* This triggers a compiler error in png.c, if png.c and png.h
550 * do not agree upon the version number.
552 typedef char* png_libpng_version_1_5_12;
554 /* Three color definitions. The order of the red, green, and blue, (and the
555 * exact size) is not important, although the size of the fields need to
556 * be png_byte or png_uint_16 (as defined below).
558 typedef struct png_color_struct
564 typedef png_color FAR * png_colorp;
565 typedef PNG_CONST png_color FAR * png_const_colorp;
566 typedef png_color FAR * FAR * png_colorpp;
568 typedef struct png_color_16_struct
570 png_byte index; /* used for palette files */
571 png_uint_16 red; /* for use in red green blue files */
574 png_uint_16 gray; /* for use in grayscale files */
576 typedef png_color_16 FAR * png_color_16p;
577 typedef PNG_CONST png_color_16 FAR * png_const_color_16p;
578 typedef png_color_16 FAR * FAR * png_color_16pp;
580 typedef struct png_color_8_struct
582 png_byte red; /* for use in red green blue files */
585 png_byte gray; /* for use in grayscale files */
586 png_byte alpha; /* for alpha channel files */
588 typedef png_color_8 FAR * png_color_8p;
589 typedef PNG_CONST png_color_8 FAR * png_const_color_8p;
590 typedef png_color_8 FAR * FAR * png_color_8pp;
593 * The following two structures are used for the in-core representation
596 typedef struct png_sPLT_entry_struct
602 png_uint_16 frequency;
604 typedef png_sPLT_entry FAR * png_sPLT_entryp;
605 typedef PNG_CONST png_sPLT_entry FAR * png_const_sPLT_entryp;
606 typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;
608 /* When the depth of the sPLT palette is 8 bits, the color and alpha samples
609 * occupy the LSB of their respective members, and the MSB of each member
610 * is zero-filled. The frequency member always occupies the full 16 bits.
613 typedef struct png_sPLT_struct
615 png_charp name; /* palette name */
616 png_byte depth; /* depth of palette samples */
617 png_sPLT_entryp entries; /* palette entries */
618 png_int_32 nentries; /* number of palette entries */
620 typedef png_sPLT_t FAR * png_sPLT_tp;
621 typedef PNG_CONST png_sPLT_t FAR * png_const_sPLT_tp;
622 typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;
624 #ifdef PNG_TEXT_SUPPORTED
625 /* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,
626 * and whether that contents is compressed or not. The "key" field
627 * points to a regular zero-terminated C string. The "text" fields can be a
628 * regular C string, an empty string, or a NULL pointer.
629 * However, the structure returned by png_get_text() will always contain
630 * the "text" field as a regular zero-terminated C string (possibly
631 * empty), never a NULL pointer, so it can be safely used in printf() and
632 * other string-handling functions. Note that the "itxt_length", "lang", and
633 * "lang_key" members of the structure only exist when the library is built
634 * with iTXt chunk support. Prior to libpng-1.4.0 the library was built by
635 * default without iTXt support. Also note that when iTXt *is* supported,
636 * the "lang" and "lang_key" fields contain NULL pointers when the
637 * "compression" field contains * PNG_TEXT_COMPRESSION_NONE or
638 * PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the
639 * same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag"
640 * which is always 0 or 1, or its "compression method" which is always 0.
642 typedef struct png_text_struct
644 int compression; /* compression value:
649 png_charp key; /* keyword, 1-79 character description of "text" */
650 png_charp text; /* comment, may be an empty string (ie "")
652 png_size_t text_length; /* length of the text string */
653 png_size_t itxt_length; /* length of the itxt string */
654 png_charp lang; /* language code, 0-79 characters
656 png_charp lang_key; /* keyword translated UTF-8 string, 0 or more
657 chars or a NULL pointer */
659 typedef png_text FAR * png_textp;
660 typedef PNG_CONST png_text FAR * png_const_textp;
661 typedef png_text FAR * FAR * png_textpp;
664 /* Supported compression types for text in PNG files (tEXt, and zTXt).
665 * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */
666 #define PNG_TEXT_COMPRESSION_NONE_WR -3
667 #define PNG_TEXT_COMPRESSION_zTXt_WR -2
668 #define PNG_TEXT_COMPRESSION_NONE -1
669 #define PNG_TEXT_COMPRESSION_zTXt 0
670 #define PNG_ITXT_COMPRESSION_NONE 1
671 #define PNG_ITXT_COMPRESSION_zTXt 2
672 #define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */
674 /* png_time is a way to hold the time in an machine independent way.
675 * Two conversions are provided, both from time_t and struct tm. There
676 * is no portable way to convert to either of these structures, as far
677 * as I know. If you know of a portable way, send it to me. As a side
678 * note - PNG has always been Year 2000 compliant!
680 typedef struct png_time_struct
682 png_uint_16 year; /* full year, as in, 1995 */
683 png_byte month; /* month of year, 1 - 12 */
684 png_byte day; /* day of month, 1 - 31 */
685 png_byte hour; /* hour of day, 0 - 23 */
686 png_byte minute; /* minute of hour, 0 - 59 */
687 png_byte second; /* second of minute, 0 - 60 (for leap seconds) */
689 typedef png_time FAR * png_timep;
690 typedef PNG_CONST png_time FAR * png_const_timep;
691 typedef png_time FAR * FAR * png_timepp;
693 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \
694 defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
695 /* png_unknown_chunk is a structure to hold queued chunks for which there is
696 * no specific support. The idea is that we can use this to queue
697 * up private chunks for output even though the library doesn't actually
698 * know about their semantics.
700 typedef struct png_unknown_chunk_t
706 /* libpng-using applications should NOT directly modify this byte. */
707 png_byte location; /* mode of operation at read time */
712 typedef png_unknown_chunk FAR * png_unknown_chunkp;
713 typedef PNG_CONST png_unknown_chunk FAR * png_const_unknown_chunkp;
714 typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;
717 /* Values for the unknown chunk location byte */
719 #define PNG_HAVE_IHDR 0x01
720 #define PNG_HAVE_PLTE 0x02
721 #define PNG_AFTER_IDAT 0x08
723 /* The complete definition of png_info has, as of libpng-1.5.0,
724 * been moved into a separate header file that is not accessible to
725 * applications. Read libpng-manual.txt or libpng.3 for more info.
727 typedef struct png_info_def png_info;
728 typedef png_info FAR * png_infop;
729 typedef PNG_CONST png_info FAR * png_const_infop;
730 typedef png_info FAR * FAR * png_infopp;
732 /* Maximum positive integer used in PNG is (2^31)-1 */
733 #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
734 #define PNG_UINT_32_MAX ((png_uint_32)(-1))
735 #define PNG_SIZE_MAX ((png_size_t)(-1))
737 /* These are constants for fixed point values encoded in the
738 * PNG specification manner (x100000)
740 #define PNG_FP_1 100000
741 #define PNG_FP_HALF 50000
742 #define PNG_FP_MAX ((png_fixed_point)0x7fffffffL)
743 #define PNG_FP_MIN (-PNG_FP_MAX)
745 /* These describe the color_type field in png_info. */
746 /* color type masks */
747 #define PNG_COLOR_MASK_PALETTE 1
748 #define PNG_COLOR_MASK_COLOR 2
749 #define PNG_COLOR_MASK_ALPHA 4
751 /* color types. Note that not all combinations are legal */
752 #define PNG_COLOR_TYPE_GRAY 0
753 #define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
754 #define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
755 #define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
756 #define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
758 #define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA
759 #define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA
761 /* This is for compression type. PNG 1.0-1.2 only define the single type. */
762 #define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */
763 #define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE
765 /* This is for filter type. PNG 1.0-1.2 only define the single type. */
766 #define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */
767 #define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */
768 #define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE
770 /* These are for the interlacing type. These values should NOT be changed. */
771 #define PNG_INTERLACE_NONE 0 /* Non-interlaced image */
772 #define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */
773 #define PNG_INTERLACE_LAST 2 /* Not a valid value */
775 /* These are for the oFFs chunk. These values should NOT be changed. */
776 #define PNG_OFFSET_PIXEL 0 /* Offset in pixels */
777 #define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */
778 #define PNG_OFFSET_LAST 2 /* Not a valid value */
780 /* These are for the pCAL chunk. These values should NOT be changed. */
781 #define PNG_EQUATION_LINEAR 0 /* Linear transformation */
782 #define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */
783 #define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */
784 #define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */
785 #define PNG_EQUATION_LAST 4 /* Not a valid value */
787 /* These are for the sCAL chunk. These values should NOT be changed. */
788 #define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */
789 #define PNG_SCALE_METER 1 /* meters per pixel */
790 #define PNG_SCALE_RADIAN 2 /* radians per pixel */
791 #define PNG_SCALE_LAST 3 /* Not a valid value */
793 /* These are for the pHYs chunk. These values should NOT be changed. */
794 #define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */
795 #define PNG_RESOLUTION_METER 1 /* pixels/meter */
796 #define PNG_RESOLUTION_LAST 2 /* Not a valid value */
798 /* These are for the sRGB chunk. These values should NOT be changed. */
799 #define PNG_sRGB_INTENT_PERCEPTUAL 0
800 #define PNG_sRGB_INTENT_RELATIVE 1
801 #define PNG_sRGB_INTENT_SATURATION 2
802 #define PNG_sRGB_INTENT_ABSOLUTE 3
803 #define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */
805 /* This is for text chunks */
806 #define PNG_KEYWORD_MAX_LENGTH 79
808 /* Maximum number of entries in PLTE/sPLT/tRNS arrays */
809 #define PNG_MAX_PALETTE_LENGTH 256
811 /* These determine if an ancillary chunk's data has been successfully read
812 * from the PNG header, or if the application has filled in the corresponding
813 * data in the info_struct to be written into the output file. The values
814 * of the PNG_INFO_<chunk> defines should NOT be changed.
816 #define PNG_INFO_gAMA 0x0001
817 #define PNG_INFO_sBIT 0x0002
818 #define PNG_INFO_cHRM 0x0004
819 #define PNG_INFO_PLTE 0x0008
820 #define PNG_INFO_tRNS 0x0010
821 #define PNG_INFO_bKGD 0x0020
822 #define PNG_INFO_hIST 0x0040
823 #define PNG_INFO_pHYs 0x0080
824 #define PNG_INFO_oFFs 0x0100
825 #define PNG_INFO_tIME 0x0200
826 #define PNG_INFO_pCAL 0x0400
827 #define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */
828 #define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */
829 #define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */
830 #define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */
831 #define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */
833 /* This is used for the transformation routines, as some of them
834 * change these values for the row. It also should enable using
835 * the routines for other purposes.
837 typedef struct png_row_info_struct
839 png_uint_32 width; /* width of row */
840 png_size_t rowbytes; /* number of bytes in row */
841 png_byte color_type; /* color type of row */
842 png_byte bit_depth; /* bit depth of row */
843 png_byte channels; /* number of channels (1, 2, 3, or 4) */
844 png_byte pixel_depth; /* bits per pixel (depth * channels) */
847 typedef png_row_info FAR * png_row_infop;
848 typedef png_row_info FAR * FAR * png_row_infopp;
850 /* The complete definition of png_struct has, as of libpng-1.5.0,
851 * been moved into a separate header file that is not accessible to
852 * applications. Read libpng-manual.txt or libpng.3 for more info.
854 typedef struct png_struct_def png_struct;
855 typedef PNG_CONST png_struct FAR * png_const_structp;
856 typedef png_struct FAR * png_structp;
858 /* These are the function types for the I/O functions and for the functions
859 * that allow the user to override the default I/O functions with his or her
860 * own. The png_error_ptr type should match that of user-supplied warning
861 * and error functions, while the png_rw_ptr type should match that of the
862 * user read/write data functions. Note that the 'write' function must not
863 * modify the buffer it is passed. The 'read' function, on the other hand, is
864 * expected to return the read data in the buffer.
866 typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp));
867 typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t));
868 typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp));
869 typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32,
871 typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32,
874 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
875 typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop));
876 typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop));
878 /* The following callback receives png_uint_32 row_number, int pass for the
879 * png_bytep data of the row. When transforming an interlaced image the
880 * row number is the row number within the sub-image of the interlace pass, so
881 * the value will increase to the height of the sub-image (not the full image)
882 * then reset to 0 for the next pass.
884 * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
885 * find the output pixel (x,y) given an interlaced sub-image pixel
886 * (row,col,pass). (See below for these macros.)
888 typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep,
892 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
893 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
894 typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop,
898 #ifdef PNG_USER_CHUNKS_SUPPORTED
899 typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp,
900 png_unknown_chunkp));
902 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
903 typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp));
906 #ifdef PNG_SETJMP_SUPPORTED
907 /* This must match the function definition in <setjmp.h>, and the application
908 * must include this before png.h to obtain the definition of jmp_buf. The
909 * function is required to be PNG_NORETURN, but this is not checked. If the
910 * function does return the application will crash via an abort() or similar
913 * If you get a warning here while building the library you may need to make
914 * changes to ensure that pnglibconf.h records the calling convention used by
915 * your compiler. This may be very difficult - try using a different compiler
916 * to build the library!
918 PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef);
921 /* Transform masks for the high-level interface */
922 #define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */
923 #define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */
924 #define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */
925 #define PNG_TRANSFORM_PACKING 0x0004 /* read and write */
926 #define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */
927 #define PNG_TRANSFORM_EXPAND 0x0010 /* read only */
928 #define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */
929 #define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */
930 #define PNG_TRANSFORM_BGR 0x0080 /* read and write */
931 #define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */
932 #define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */
933 #define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */
934 #define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */
935 /* Added to libpng-1.2.34 */
936 #define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER
937 #define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */
938 /* Added to libpng-1.4.0 */
939 #define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */
940 /* Added to libpng-1.5.4 */
941 #define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */
942 #define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */
944 /* Flags for MNG supported features */
945 #define PNG_FLAG_MNG_EMPTY_PLTE 0x01
946 #define PNG_FLAG_MNG_FILTER_64 0x04
947 #define PNG_ALL_MNG_FEATURES 0x05
949 /* NOTE: prior to 1.5 these functions had no 'API' style declaration,
950 * this allowed the zlib default functions to be used on Windows
951 * platforms. In 1.5 the zlib default malloc (which just calls malloc and
952 * ignores the first argument) should be completely compatible with the
955 typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp,
957 typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp));
959 typedef png_struct FAR * FAR * png_structpp;
961 /* Section 3: exported functions
962 * Here are the function definitions most commonly used. This is not
963 * the place to find out how to use libpng. See libpng-manual.txt for the
964 * full explanation, see example.c for the summary. This just provides
965 * a simple one line description of the use of each function.
967 * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in
968 * pngconf.h and in the *.dfn files in the scripts directory.
970 * PNG_EXPORT(ordinal, type, name, (args));
972 * ordinal: ordinal that is used while building
973 * *.def files. The ordinal value is only
974 * relevant when preprocessing png.h with
975 * the *.dfn files for building symbol table
976 * entries, and are removed by pngconf.h.
977 * type: return type of the function
978 * name: function name
979 * args: function arguments, with types
981 * When we wish to append attributes to a function prototype we use
982 * the PNG_EXPORTA() macro instead.
984 * PNG_EXPORTA(ordinal, type, name, (args), attributes);
986 * ordinal, type, name, and args: same as in PNG_EXPORT().
987 * attributes: function attributes
990 /* Returns the version number of the library */
991 PNG_EXPORT(1, png_uint_32, png_access_version_number, (void));
993 /* Tell lib we have already handled the first <num_bytes> magic bytes.
994 * Handling more than 8 bytes from the beginning of the file is an error.
996 PNG_EXPORT(2, void, png_set_sig_bytes, (png_structp png_ptr, int num_bytes));
998 /* Check sig[start] through sig[start + num_to_check - 1] to see if it's a
999 * PNG file. Returns zero if the supplied bytes match the 8-byte PNG
1000 * signature, and non-zero otherwise. Having num_to_check == 0 or
1001 * start > 7 will always fail (ie return non-zero).
1003 PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start,
1004 png_size_t num_to_check));
1006 /* Simple signature checking function. This is the same as calling
1007 * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).
1009 #define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n))
1011 /* Allocate and initialize png_ptr struct for reading, and any other memory. */
1012 PNG_EXPORTA(4, png_structp, png_create_read_struct,
1013 (png_const_charp user_png_ver, png_voidp error_ptr,
1014 png_error_ptr error_fn, png_error_ptr warn_fn),
1017 /* Allocate and initialize png_ptr struct for writing, and any other memory */
1018 PNG_EXPORTA(5, png_structp, png_create_write_struct,
1019 (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
1020 png_error_ptr warn_fn),
1023 PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size,
1024 (png_const_structp png_ptr));
1026 PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structp png_ptr,
1029 /* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
1032 #ifdef PNG_SETJMP_SUPPORTED
1033 /* This function returns the jmp_buf built in to *png_ptr. It must be
1034 * supplied with an appropriate 'longjmp' function to use on that jmp_buf
1035 * unless the default error function is overridden in which case NULL is
1036 * acceptable. The size of the jmp_buf is checked against the actual size
1037 * allocated by the library - the call will return NULL on a mismatch
1038 * indicating an ABI mismatch.
1040 PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structp png_ptr,
1041 png_longjmp_ptr longjmp_fn, size_t jmp_buf_size));
1042 # define png_jmpbuf(png_ptr) \
1043 (*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf)))
1045 # define png_jmpbuf(png_ptr) \
1046 (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP)
1048 /* This function should be used by libpng applications in place of
1049 * longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it
1050 * will use it; otherwise it will call PNG_ABORT(). This function was
1051 * added in libpng-1.5.0.
1053 PNG_EXPORTA(9, void, png_longjmp, (png_structp png_ptr, int val),
1056 #ifdef PNG_READ_SUPPORTED
1057 /* Reset the compression stream */
1058 PNG_EXPORT(10, int, png_reset_zstream, (png_structp png_ptr));
1061 /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
1062 #ifdef PNG_USER_MEM_SUPPORTED
1063 PNG_EXPORTA(11, png_structp, png_create_read_struct_2,
1064 (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
1065 png_error_ptr warn_fn,
1066 png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
1068 PNG_EXPORTA(12, png_structp, png_create_write_struct_2,
1069 (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
1070 png_error_ptr warn_fn,
1071 png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
1075 /* Write the PNG file signature. */
1076 PNG_EXPORT(13, void, png_write_sig, (png_structp png_ptr));
1078 /* Write a PNG chunk - size, type, (optional) data, CRC. */
1079 PNG_EXPORT(14, void, png_write_chunk, (png_structp png_ptr, png_const_bytep
1080 chunk_name, png_const_bytep data, png_size_t length));
1082 /* Write the start of a PNG chunk - length and chunk name. */
1083 PNG_EXPORT(15, void, png_write_chunk_start, (png_structp png_ptr,
1084 png_const_bytep chunk_name, png_uint_32 length));
1086 /* Write the data of a PNG chunk started with png_write_chunk_start(). */
1087 PNG_EXPORT(16, void, png_write_chunk_data, (png_structp png_ptr,
1088 png_const_bytep data, png_size_t length));
1090 /* Finish a chunk started with png_write_chunk_start() (includes CRC). */
1091 PNG_EXPORT(17, void, png_write_chunk_end, (png_structp png_ptr));
1093 /* Allocate and initialize the info structure */
1094 PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_structp png_ptr),
1097 PNG_EXPORT(19, void, png_info_init_3, (png_infopp info_ptr,
1098 png_size_t png_info_struct_size));
1100 /* Writes all the PNG information before the image. */
1101 PNG_EXPORT(20, void, png_write_info_before_PLTE,
1102 (png_structp png_ptr, png_infop info_ptr));
1103 PNG_EXPORT(21, void, png_write_info,
1104 (png_structp png_ptr, png_infop info_ptr));
1106 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1107 /* Read the information before the actual image data. */
1108 PNG_EXPORT(22, void, png_read_info,
1109 (png_structp png_ptr, png_infop info_ptr));
1112 #ifdef PNG_TIME_RFC1123_SUPPORTED
1113 PNG_EXPORT(23, png_const_charp, png_convert_to_rfc1123,
1114 (png_structp png_ptr,
1115 png_const_timep ptime));
1118 #ifdef PNG_CONVERT_tIME_SUPPORTED
1119 /* Convert from a struct tm to png_time */
1120 PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime,
1121 PNG_CONST struct tm FAR * ttime));
1123 /* Convert from time_t to png_time. Uses gmtime() */
1124 PNG_EXPORT(25, void, png_convert_from_time_t,
1125 (png_timep ptime, time_t ttime));
1126 #endif /* PNG_CONVERT_tIME_SUPPORTED */
1128 #ifdef PNG_READ_EXPAND_SUPPORTED
1129 /* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
1130 PNG_EXPORT(26, void, png_set_expand, (png_structp png_ptr));
1131 PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structp png_ptr));
1132 PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structp png_ptr));
1133 PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structp png_ptr));
1136 #ifdef PNG_READ_EXPAND_16_SUPPORTED
1137 /* Expand to 16-bit channels, forces conversion of palette to RGB and expansion
1138 * of a tRNS chunk if present.
1140 PNG_EXPORT(221, void, png_set_expand_16, (png_structp png_ptr));
1143 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
1144 /* Use blue, green, red order for pixels. */
1145 PNG_EXPORT(30, void, png_set_bgr, (png_structp png_ptr));
1148 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
1149 /* Expand the grayscale to 24-bit RGB if necessary. */
1150 PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structp png_ptr));
1153 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1154 /* Reduce RGB to grayscale. */
1155 #define PNG_ERROR_ACTION_NONE 1
1156 #define PNG_ERROR_ACTION_WARN 2
1157 #define PNG_ERROR_ACTION_ERROR 3
1158 #define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/
1160 PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structp png_ptr,
1161 int error_action, double red, double green));
1162 PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structp png_ptr,
1163 int error_action, png_fixed_point red, png_fixed_point green));
1165 PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structp
1169 #ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
1170 PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth,
1171 png_colorp palette));
1174 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
1175 /* How the alpha channel is interpreted - this affects how the color channels of
1176 * a PNG file are returned when an alpha channel, or tRNS chunk in a palette
1179 * This has no effect on the way pixels are written into a PNG output
1180 * datastream. The color samples in a PNG datastream are never premultiplied
1181 * with the alpha samples.
1183 * The default is to return data according to the PNG specification: the alpha
1184 * channel is a linear measure of the contribution of the pixel to the
1185 * corresponding composited pixel. The gamma encoded color channels must be
1186 * scaled according to the contribution and to do this it is necessary to undo
1187 * the encoding, scale the color values, perform the composition and reencode
1188 * the values. This is the 'PNG' mode.
1190 * The alternative is to 'associate' the alpha with the color information by
1191 * storing color channel values that have been scaled by the alpha. The
1192 * advantage is that the color channels can be resampled (the image can be
1193 * scaled) in this form. The disadvantage is that normal practice is to store
1194 * linear, not (gamma) encoded, values and this requires 16-bit channels for
1195 * still images rather than the 8-bit channels that are just about sufficient if
1196 * gamma encoding is used. In addition all non-transparent pixel values,
1197 * including completely opaque ones, must be gamma encoded to produce the final
1198 * image. This is the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' mode (the
1199 * latter being the two common names for associated alpha color channels.)
1201 * Since it is not necessary to perform arithmetic on opaque color values so
1202 * long as they are not to be resampled and are in the final color space it is
1203 * possible to optimize the handling of alpha by storing the opaque pixels in
1204 * the PNG format (adjusted for the output color space) while storing partially
1205 * opaque pixels in the standard, linear, format. The accuracy required for
1206 * standard alpha composition is relatively low, because the pixels are
1207 * isolated, therefore typically the accuracy loss in storing 8-bit linear
1208 * values is acceptable. (This is not true if the alpha channel is used to
1209 * simulate transparency over large areas - use 16 bits or the PNG mode in
1210 * this case!) This is the 'OPTIMIZED' mode. For this mode a pixel is
1211 * treated as opaque only if the alpha value is equal to the maximum value.
1213 * The final choice is to gamma encode the alpha channel as well. This is
1214 * broken because, in practice, no implementation that uses this choice
1215 * correctly undoes the encoding before handling alpha composition. Use this
1216 * choice only if other serious errors in the software or hardware you use
1217 * mandate it; the typical serious error is for dark halos to appear around
1218 * opaque areas of the composited PNG image because of arithmetic overflow.
1220 * The API function png_set_alpha_mode specifies which of these choices to use
1221 * with an enumerated 'mode' value and the gamma of the required output:
1223 #define PNG_ALPHA_PNG 0 /* according to the PNG standard */
1224 #define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */
1225 #define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */
1226 #define PNG_ALPHA_PREMULTIPLIED 1 /* as above */
1227 #define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */
1228 #define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */
1230 PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structp png_ptr, int mode,
1231 double output_gamma));
1232 PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structp png_ptr,
1233 int mode, png_fixed_point output_gamma));
1236 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED)
1237 /* The output_gamma value is a screen gamma in libpng terminology: it expresses
1238 * how to decode the output values, not how they are encoded. The values used
1239 * correspond to the normal numbers used to describe the overall gamma of a
1240 * computer display system; for example 2.2 for an sRGB conformant system. The
1241 * values are scaled by 100000 in the _fixed version of the API (so 220000 for
1244 * The inverse of the value is always used to provide a default for the PNG file
1245 * encoding if it has no gAMA chunk and if png_set_gamma() has not been called
1246 * to override the PNG gamma information.
1248 * When the ALPHA_OPTIMIZED mode is selected the output gamma is used to encode
1249 * opaque pixels however pixels with lower alpha values are not encoded,
1250 * regardless of the output gamma setting.
1252 * When the standard Porter Duff handling is requested with mode 1 the output
1253 * encoding is set to be linear and the output_gamma value is only relevant
1254 * as a default for input data that has no gamma information. The linear output
1255 * encoding will be overridden if png_set_gamma() is called - the results may be
1256 * highly unexpected!
1258 * The following numbers are derived from the sRGB standard and the research
1259 * behind it. sRGB is defined to be approximated by a PNG gAMA chunk value of
1260 * 0.45455 (1/2.2) for PNG. The value implicitly includes any viewing
1261 * correction required to take account of any differences in the color
1262 * environment of the original scene and the intended display environment; the
1263 * value expresses how to *decode* the image for display, not how the original
1264 * data was *encoded*.
1266 * sRGB provides a peg for the PNG standard by defining a viewing environment.
1267 * sRGB itself, and earlier TV standards, actually use a more complex transform
1268 * (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is
1269 * limited to simple power laws.) By saying that an image for direct display on
1270 * an sRGB conformant system should be stored with a gAMA chunk value of 45455
1271 * (11.3.3.2 and 11.3.3.5 of the ISO PNG specification) the PNG specification
1272 * makes it possible to derive values for other display systems and
1275 * The Mac value is deduced from the sRGB based on an assumption that the actual
1276 * extra viewing correction used in early Mac display systems was implemented as
1277 * a power 1.45 lookup table.
1279 * Any system where a programmable lookup table is used or where the behavior of
1280 * the final display device characteristics can be changed requires system
1281 * specific code to obtain the current characteristic. However this can be
1282 * difficult and most PNG gamma correction only requires an approximate value.
1284 * By default, if png_set_alpha_mode() is not called, libpng assumes that all
1285 * values are unencoded, linear, values and that the output device also has a
1286 * linear characteristic. This is only very rarely correct - it is invariably
1287 * better to call png_set_alpha_mode() with PNG_DEFAULT_sRGB than rely on the
1288 * default if you don't know what the right answer is!
1290 * The special value PNG_GAMMA_MAC_18 indicates an older Mac system (pre Mac OS
1291 * 10.6) which used a correction table to implement a somewhat lower gamma on an
1292 * otherwise sRGB system.
1294 * Both these values are reserved (not simple gamma values) in order to allow
1295 * more precise correction internally in the future.
1297 * NOTE: the following values can be passed to either the fixed or floating
1298 * point APIs, but the floating point API will also accept floating point
1301 #define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */
1302 #define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */
1303 #define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */
1304 #define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */
1307 /* The following are examples of calls to png_set_alpha_mode to achieve the
1308 * required overall gamma correction and, where necessary, alpha
1309 * premultiplication.
1311 * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
1312 * This is the default libpng handling of the alpha channel - it is not
1313 * pre-multiplied into the color components. In addition the call states
1314 * that the output is for a sRGB system and causes all PNG files without gAMA
1315 * chunks to be assumed to be encoded using sRGB.
1317 * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
1318 * In this case the output is assumed to be something like an sRGB conformant
1319 * display preceeded by a power-law lookup table of power 1.45. This is how
1320 * early Mac systems behaved.
1322 * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
1323 * This is the classic Jim Blinn approach and will work in academic
1324 * environments where everything is done by the book. It has the shortcoming
1325 * of assuming that input PNG data with no gamma information is linear - this
1326 * is unlikely to be correct unless the PNG files where generated locally.
1327 * Most of the time the output precision will be so low as to show
1328 * significant banding in dark areas of the image.
1330 * png_set_expand_16(pp);
1331 * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB);
1332 * This is a somewhat more realistic Jim Blinn inspired approach. PNG files
1333 * are assumed to have the sRGB encoding if not marked with a gamma value and
1334 * the output is always 16 bits per component. This permits accurate scaling
1335 * and processing of the data. If you know that your input PNG files were
1336 * generated locally you might need to replace PNG_DEFAULT_sRGB with the
1337 * correct value for your system.
1339 * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);
1340 * If you just need to composite the PNG image onto an existing background
1341 * and if you control the code that does this you can use the optimization
1342 * setting. In this case you just copy completely opaque pixels to the
1343 * output. For pixels that are not completely transparent (you just skip
1344 * those) you do the composition math using png_composite or png_composite_16
1345 * below then encode the resultant 8-bit or 16-bit values to match the output
1349 * If neither the PNG nor the standard linear encoding work for you because
1350 * of the software or hardware you use then you have a big problem. The PNG
1351 * case will probably result in halos around the image. The linear encoding
1352 * will probably result in a washed out, too bright, image (it's actually too
1353 * contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably
1354 * substantially reduce the halos. Alternatively try:
1356 * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB);
1357 * This option will also reduce the halos, but there will be slight dark
1358 * halos round the opaque parts of the image where the background is light.
1359 * In the OPTIMIZED mode the halos will be light halos where the background
1360 * is dark. Take your pick - the halos are unavoidable unless you can get
1361 * your hardware/software fixed! (The OPTIMIZED approach is slightly
1364 * When the default gamma of PNG files doesn't match the output gamma.
1365 * If you have PNG files with no gamma information png_set_alpha_mode allows
1366 * you to provide a default gamma, but it also sets the ouput gamma to the
1367 * matching value. If you know your PNG files have a gamma that doesn't
1368 * match the output you can take advantage of the fact that
1369 * png_set_alpha_mode always sets the output gamma but only sets the PNG
1370 * default if it is not already set:
1372 * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
1373 * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
1374 * The first call sets both the default and the output gamma values, the
1375 * second call overrides the output gamma without changing the default. This
1376 * is easier than achieving the same effect with png_set_gamma. You must use
1377 * PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will
1378 * fire if more than one call to png_set_alpha_mode and png_set_background is
1379 * made in the same read operation, however multiple calls with PNG_ALPHA_PNG
1383 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
1384 PNG_EXPORT(36, void, png_set_strip_alpha, (png_structp png_ptr));
1387 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
1388 defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
1389 PNG_EXPORT(37, void, png_set_swap_alpha, (png_structp png_ptr));
1392 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
1393 defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
1394 PNG_EXPORT(38, void, png_set_invert_alpha, (png_structp png_ptr));
1397 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
1398 /* Add a filler byte to 8-bit Gray or 24-bit RGB images. */
1399 PNG_EXPORT(39, void, png_set_filler, (png_structp png_ptr, png_uint_32 filler,
1401 /* The values of the PNG_FILLER_ defines should NOT be changed */
1402 # define PNG_FILLER_BEFORE 0
1403 # define PNG_FILLER_AFTER 1
1404 /* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */
1405 PNG_EXPORT(40, void, png_set_add_alpha,
1406 (png_structp png_ptr, png_uint_32 filler,
1408 #endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */
1410 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
1411 /* Swap bytes in 16-bit depth files. */
1412 PNG_EXPORT(41, void, png_set_swap, (png_structp png_ptr));
1415 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
1416 /* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */
1417 PNG_EXPORT(42, void, png_set_packing, (png_structp png_ptr));
1420 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
1421 defined(PNG_WRITE_PACKSWAP_SUPPORTED)
1422 /* Swap packing order of pixels in bytes. */
1423 PNG_EXPORT(43, void, png_set_packswap, (png_structp png_ptr));
1426 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
1427 /* Converts files to legal bit depths. */
1428 PNG_EXPORT(44, void, png_set_shift, (png_structp png_ptr, png_const_color_8p
1432 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
1433 defined(PNG_WRITE_INTERLACING_SUPPORTED)
1434 /* Have the code handle the interlacing. Returns the number of passes.
1435 * MUST be called before png_read_update_info or png_start_read_image,
1436 * otherwise it will not have the desired effect. Note that it is still
1437 * necessary to call png_read_row or png_read_rows png_get_image_height
1438 * times for each pass.
1440 PNG_EXPORT(45, int, png_set_interlace_handling, (png_structp png_ptr));
1443 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
1444 /* Invert monochrome files */
1445 PNG_EXPORT(46, void, png_set_invert_mono, (png_structp png_ptr));
1448 #ifdef PNG_READ_BACKGROUND_SUPPORTED
1449 /* Handle alpha and tRNS by replacing with a background color. Prior to
1450 * libpng-1.5.4 this API must not be called before the PNG file header has been
1451 * read. Doing so will result in unexpected behavior and possible warnings or
1452 * errors if the PNG file contains a bKGD chunk.
1454 PNG_FP_EXPORT(47, void, png_set_background, (png_structp png_ptr,
1455 png_const_color_16p background_color, int background_gamma_code,
1456 int need_expand, double background_gamma));
1457 PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structp png_ptr,
1458 png_const_color_16p background_color, int background_gamma_code,
1459 int need_expand, png_fixed_point background_gamma));
1461 #ifdef PNG_READ_BACKGROUND_SUPPORTED
1462 # define PNG_BACKGROUND_GAMMA_UNKNOWN 0
1463 # define PNG_BACKGROUND_GAMMA_SCREEN 1
1464 # define PNG_BACKGROUND_GAMMA_FILE 2
1465 # define PNG_BACKGROUND_GAMMA_UNIQUE 3
1468 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
1469 /* Scale a 16-bit depth file down to 8-bit, accurately. */
1470 PNG_EXPORT(229, void, png_set_scale_16, (png_structp png_ptr));
1473 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
1474 #define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */
1475 /* Strip the second byte of information from a 16-bit depth file. */
1476 PNG_EXPORT(48, void, png_set_strip_16, (png_structp png_ptr));
1479 #ifdef PNG_READ_QUANTIZE_SUPPORTED
1480 /* Turn on quantizing, and reduce the palette to the number of colors
1483 PNG_EXPORT(49, void, png_set_quantize,
1484 (png_structp png_ptr, png_colorp palette,
1485 int num_palette, int maximum_colors, png_const_uint_16p histogram,
1486 int full_quantize));
1489 #ifdef PNG_READ_GAMMA_SUPPORTED
1490 /* The threshold on gamma processing is configurable but hard-wired into the
1491 * library. The following is the floating point variant.
1493 #define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001)
1495 /* Handle gamma correction. Screen_gamma=(display_exponent).
1496 * NOTE: this API simply sets the screen and file gamma values. It will
1497 * therefore override the value for gamma in a PNG file if it is called after
1498 * the file header has been read - use with care - call before reading the PNG
1499 * file for best results!
1501 * These routines accept the same gamma values as png_set_alpha_mode (described
1502 * above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either
1503 * API (floating point or fixed.) Notice, however, that the 'file_gamma' value
1504 * is the inverse of a 'screen gamma' value.
1506 PNG_FP_EXPORT(50, void, png_set_gamma,
1507 (png_structp png_ptr, double screen_gamma,
1508 double override_file_gamma));
1509 PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structp png_ptr,
1510 png_fixed_point screen_gamma, png_fixed_point override_file_gamma));
1513 #ifdef PNG_WRITE_FLUSH_SUPPORTED
1514 /* Set how many lines between output flushes - 0 for no flushing */
1515 PNG_EXPORT(51, void, png_set_flush, (png_structp png_ptr, int nrows));
1516 /* Flush the current PNG output buffer */
1517 PNG_EXPORT(52, void, png_write_flush, (png_structp png_ptr));
1520 /* Optional update palette with requested transformations */
1521 PNG_EXPORT(53, void, png_start_read_image, (png_structp png_ptr));
1523 /* Optional call to update the users info structure */
1524 PNG_EXPORT(54, void, png_read_update_info,
1525 (png_structp png_ptr, png_infop info_ptr));
1527 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1528 /* Read one or more rows of image data. */
1529 PNG_EXPORT(55, void, png_read_rows, (png_structp png_ptr, png_bytepp row,
1530 png_bytepp display_row, png_uint_32 num_rows));
1533 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1534 /* Read a row of data. */
1535 PNG_EXPORT(56, void, png_read_row, (png_structp png_ptr, png_bytep row,
1536 png_bytep display_row));
1539 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1540 /* Read the whole image into memory at once. */
1541 PNG_EXPORT(57, void, png_read_image, (png_structp png_ptr, png_bytepp image));
1544 /* Write a row of image data */
1545 PNG_EXPORT(58, void, png_write_row,
1546 (png_structp png_ptr, png_const_bytep row));
1548 /* Write a few rows of image data: (*row) is not written; however, the type
1549 * is declared as writeable to maintain compatibility with previous versions
1550 * of libpng and to allow the 'display_row' array from read_rows to be passed
1551 * unchanged to write_rows.
1553 PNG_EXPORT(59, void, png_write_rows, (png_structp png_ptr, png_bytepp row,
1554 png_uint_32 num_rows));
1556 /* Write the image data */
1557 PNG_EXPORT(60, void, png_write_image,
1558 (png_structp png_ptr, png_bytepp image));
1560 /* Write the end of the PNG file. */
1561 PNG_EXPORT(61, void, png_write_end,
1562 (png_structp png_ptr, png_infop info_ptr));
1564 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1565 /* Read the end of the PNG file. */
1566 PNG_EXPORT(62, void, png_read_end, (png_structp png_ptr, png_infop info_ptr));
1569 /* Free any memory associated with the png_info_struct */
1570 PNG_EXPORT(63, void, png_destroy_info_struct, (png_structp png_ptr,
1571 png_infopp info_ptr_ptr));
1573 /* Free any memory associated with the png_struct and the png_info_structs */
1574 PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr,
1575 png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));
1577 /* Free any memory associated with the png_struct and the png_info_structs */
1578 PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr,
1579 png_infopp info_ptr_ptr));
1581 /* Set the libpng method of handling chunk CRC errors */
1582 PNG_EXPORT(66, void, png_set_crc_action,
1583 (png_structp png_ptr, int crit_action, int ancil_action));
1585 /* Values for png_set_crc_action() say how to handle CRC errors in
1586 * ancillary and critical chunks, and whether to use the data contained
1587 * therein. Note that it is impossible to "discard" data in a critical
1588 * chunk. For versions prior to 0.90, the action was always error/quit,
1589 * whereas in version 0.90 and later, the action for CRC errors in ancillary
1590 * chunks is warn/discard. These values should NOT be changed.
1592 * value action:critical action:ancillary
1594 #define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */
1595 #define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */
1596 #define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */
1597 #define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */
1598 #define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */
1599 #define PNG_CRC_NO_CHANGE 5 /* use current value use current value */
1601 /* These functions give the user control over the scan-line filtering in
1602 * libpng and the compression methods used by zlib. These functions are
1603 * mainly useful for testing, as the defaults should work with most users.
1604 * Those users who are tight on memory or want faster performance at the
1605 * expense of compression can modify them. See the compression library
1606 * header file (zlib.h) for an explination of the compression functions.
1609 /* Set the filtering method(s) used by libpng. Currently, the only valid
1610 * value for "method" is 0.
1612 PNG_EXPORT(67, void, png_set_filter,
1613 (png_structp png_ptr, int method, int filters));
1615 /* Flags for png_set_filter() to say which filters to use. The flags
1616 * are chosen so that they don't conflict with real filter types
1617 * below, in case they are supplied instead of the #defined constants.
1618 * These values should NOT be changed.
1620 #define PNG_NO_FILTERS 0x00
1621 #define PNG_FILTER_NONE 0x08
1622 #define PNG_FILTER_SUB 0x10
1623 #define PNG_FILTER_UP 0x20
1624 #define PNG_FILTER_AVG 0x40
1625 #define PNG_FILTER_PAETH 0x80
1626 #define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \
1627 PNG_FILTER_AVG | PNG_FILTER_PAETH)
1629 /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
1630 * These defines should NOT be changed.
1632 #define PNG_FILTER_VALUE_NONE 0
1633 #define PNG_FILTER_VALUE_SUB 1
1634 #define PNG_FILTER_VALUE_UP 2
1635 #define PNG_FILTER_VALUE_AVG 3
1636 #define PNG_FILTER_VALUE_PAETH 4
1637 #define PNG_FILTER_VALUE_LAST 5
1639 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* EXPERIMENTAL */
1640 /* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_
1641 * defines, either the default (minimum-sum-of-absolute-differences), or
1642 * the experimental method (weighted-minimum-sum-of-absolute-differences).
1644 * Weights are factors >= 1.0, indicating how important it is to keep the
1645 * filter type consistent between rows. Larger numbers mean the current
1646 * filter is that many times as likely to be the same as the "num_weights"
1647 * previous filters. This is cumulative for each previous row with a weight.
1648 * There needs to be "num_weights" values in "filter_weights", or it can be
1649 * NULL if the weights aren't being specified. Weights have no influence on
1650 * the selection of the first row filter. Well chosen weights can (in theory)
1651 * improve the compression for a given image.
1653 * Costs are factors >= 1.0 indicating the relative decoding costs of a
1654 * filter type. Higher costs indicate more decoding expense, and are
1655 * therefore less likely to be selected over a filter with lower computational
1656 * costs. There needs to be a value in "filter_costs" for each valid filter
1657 * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't
1658 * setting the costs. Costs try to improve the speed of decompression without
1659 * unduly increasing the compressed image size.
1661 * A negative weight or cost indicates the default value is to be used, and
1662 * values in the range [0.0, 1.0) indicate the value is to remain unchanged.
1663 * The default values for both weights and costs are currently 1.0, but may
1664 * change if good general weighting/cost heuristics can be found. If both
1665 * the weights and costs are set to 1.0, this degenerates the WEIGHTED method
1666 * to the UNWEIGHTED method, but with added encoding time/computation.
1668 PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structp png_ptr,
1669 int heuristic_method, int num_weights, png_const_doublep filter_weights,
1670 png_const_doublep filter_costs));
1671 PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed,
1672 (png_structp png_ptr,
1673 int heuristic_method, int num_weights, png_const_fixed_point_p
1674 filter_weights, png_const_fixed_point_p filter_costs));
1675 #endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
1677 /* Heuristic used for row filter selection. These defines should NOT be
1680 #define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */
1681 #define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */
1682 #define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */
1683 #define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */
1685 #ifdef PNG_WRITE_SUPPORTED
1686 /* Set the library compression level. Currently, valid values range from
1687 * 0 - 9, corresponding directly to the zlib compression levels 0 - 9
1688 * (0 - no compression, 9 - "maximal" compression). Note that tests have
1689 * shown that zlib compression levels 3-6 usually perform as well as level 9
1690 * for PNG images, and do considerably fewer caclulations. In the future,
1691 * these values may not correspond directly to the zlib compression levels.
1693 PNG_EXPORT(69, void, png_set_compression_level,
1694 (png_structp png_ptr, int level));
1696 PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structp png_ptr,
1699 PNG_EXPORT(71, void, png_set_compression_strategy, (png_structp png_ptr,
1702 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
1703 * smaller value of window_bits if it can do so safely.
1705 PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structp png_ptr,
1708 PNG_EXPORT(73, void, png_set_compression_method, (png_structp png_ptr,
1712 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
1713 /* Also set zlib parameters for compressing non-IDAT chunks */
1714 PNG_EXPORT(222, void, png_set_text_compression_level,
1715 (png_structp png_ptr, int level));
1717 PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structp png_ptr,
1720 PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structp png_ptr,
1723 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
1724 * smaller value of window_bits if it can do so safely.
1726 PNG_EXPORT(225, void, png_set_text_compression_window_bits, (png_structp
1727 png_ptr, int window_bits));
1729 PNG_EXPORT(226, void, png_set_text_compression_method, (png_structp png_ptr,
1731 #endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */
1733 /* These next functions are called for input/output, memory, and error
1734 * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c,
1735 * and call standard C I/O routines such as fread(), fwrite(), and
1736 * fprintf(). These functions can be made to use other I/O routines
1737 * at run time for those applications that need to handle I/O in a
1738 * different manner by calling png_set_???_fn(). See libpng-manual.txt for
1742 #ifdef PNG_STDIO_SUPPORTED
1743 /* Initialize the input/output for the PNG file to the default functions. */
1744 PNG_EXPORT(74, void, png_init_io, (png_structp png_ptr, png_FILE_p fp));
1747 /* Replace the (error and abort), and warning functions with user
1748 * supplied functions. If no messages are to be printed you must still
1749 * write and use replacement functions. The replacement error_fn should
1750 * still do a longjmp to the last setjmp location if you are using this
1751 * method of error handling. If error_fn or warning_fn is NULL, the
1752 * default function will be used.
1755 PNG_EXPORT(75, void, png_set_error_fn,
1756 (png_structp png_ptr, png_voidp error_ptr,
1757 png_error_ptr error_fn, png_error_ptr warning_fn));
1759 /* Return the user pointer associated with the error functions */
1760 PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structp png_ptr));
1762 /* Replace the default data output functions with a user supplied one(s).
1763 * If buffered output is not used, then output_flush_fn can be set to NULL.
1764 * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time
1765 * output_flush_fn will be ignored (and thus can be NULL).
1766 * It is probably a mistake to use NULL for output_flush_fn if
1767 * write_data_fn is not also NULL unless you have built libpng with
1768 * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's
1769 * default flush function, which uses the standard *FILE structure, will
1772 PNG_EXPORT(77, void, png_set_write_fn, (png_structp png_ptr, png_voidp io_ptr,
1773 png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
1775 /* Replace the default data input function with a user supplied one. */
1776 PNG_EXPORT(78, void, png_set_read_fn, (png_structp png_ptr, png_voidp io_ptr,
1777 png_rw_ptr read_data_fn));
1779 /* Return the user pointer associated with the I/O functions */
1780 PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_structp png_ptr));
1782 PNG_EXPORT(80, void, png_set_read_status_fn, (png_structp png_ptr,
1783 png_read_status_ptr read_row_fn));
1785 PNG_EXPORT(81, void, png_set_write_status_fn, (png_structp png_ptr,
1786 png_write_status_ptr write_row_fn));
1788 #ifdef PNG_USER_MEM_SUPPORTED
1789 /* Replace the default memory allocation functions with user supplied one(s). */
1790 PNG_EXPORT(82, void, png_set_mem_fn, (png_structp png_ptr, png_voidp mem_ptr,
1791 png_malloc_ptr malloc_fn, png_free_ptr free_fn));
1792 /* Return the user pointer associated with the memory functions */
1793 PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structp png_ptr));
1796 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1797 PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structp png_ptr,
1798 png_user_transform_ptr read_user_transform_fn));
1801 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
1802 PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structp png_ptr,
1803 png_user_transform_ptr write_user_transform_fn));
1806 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
1807 PNG_EXPORT(86, void, png_set_user_transform_info, (png_structp png_ptr,
1808 png_voidp user_transform_ptr, int user_transform_depth,
1809 int user_transform_channels));
1810 /* Return the user pointer associated with the user transform functions */
1811 PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr,
1812 (png_const_structp png_ptr));
1815 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
1816 /* Return information about the row currently being processed. Note that these
1817 * APIs do not fail but will return unexpected results if called outside a user
1818 * transform callback. Also note that when transforming an interlaced image the
1819 * row number is the row number within the sub-image of the interlace pass, so
1820 * the value will increase to the height of the sub-image (not the full image)
1821 * then reset to 0 for the next pass.
1823 * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
1824 * find the output pixel (x,y) given an interlaced sub-image pixel
1825 * (row,col,pass). (See below for these macros.)
1827 PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structp));
1828 PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structp));
1831 #ifdef PNG_USER_CHUNKS_SUPPORTED
1832 PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structp png_ptr,
1833 png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
1834 PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structp png_ptr));
1837 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
1838 /* Sets the function callbacks for the push reader, and a pointer to a
1839 * user-defined structure available to the callback functions.
1841 PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structp png_ptr,
1842 png_voidp progressive_ptr, png_progressive_info_ptr info_fn,
1843 png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn));
1845 /* Returns the user pointer associated with the push read functions */
1846 PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, (png_const_structp png_ptr));
1848 /* Function to be called when data becomes available */
1849 PNG_EXPORT(92, void, png_process_data,
1850 (png_structp png_ptr, png_infop info_ptr,
1851 png_bytep buffer, png_size_t buffer_size));
1853 /* A function which may be called *only* within png_process_data to stop the
1854 * processing of any more data. The function returns the number of bytes
1855 * remaining, excluding any that libpng has cached internally. A subsequent
1856 * call to png_process_data must supply these bytes again. If the argument
1857 * 'save' is set to true the routine will first save all the pending data and
1858 * will always return 0.
1860 PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structp, int save));
1862 /* A function which may be called *only* outside (after) a call to
1863 * png_process_data. It returns the number of bytes of data to skip in the
1864 * input. Normally it will return 0, but if it returns a non-zero value the
1865 * application must skip than number of bytes of input data and pass the
1866 * following data to the next call to png_process_data.
1868 PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structp));
1870 #ifdef PNG_READ_INTERLACING_SUPPORTED
1871 /* Function that combines rows. 'new_row' is a flag that should come from
1872 * the callback and be non-NULL if anything needs to be done; the library
1873 * stores its own version of the new data internally and ignores the passed
1876 PNG_EXPORT(93, void, png_progressive_combine_row, (png_structp png_ptr,
1877 png_bytep old_row, png_const_bytep new_row));
1878 #endif /* PNG_READ_INTERLACING_SUPPORTED */
1879 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
1881 PNG_EXPORTA(94, png_voidp, png_malloc,
1882 (png_structp png_ptr, png_alloc_size_t size),
1884 /* Added at libpng version 1.4.0 */
1885 PNG_EXPORTA(95, png_voidp, png_calloc,
1886 (png_structp png_ptr, png_alloc_size_t size),
1889 /* Added at libpng version 1.2.4 */
1890 PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_structp png_ptr,
1891 png_alloc_size_t size), PNG_ALLOCATED);
1893 /* Frees a pointer allocated by png_malloc() */
1894 PNG_EXPORT(97, void, png_free, (png_structp png_ptr, png_voidp ptr));
1896 /* Free data that was allocated internally */
1897 PNG_EXPORT(98, void, png_free_data,
1898 (png_structp png_ptr, png_infop info_ptr, png_uint_32 free_me, int num));
1900 /* Reassign responsibility for freeing existing data, whether allocated
1901 * by libpng or by the application */
1902 PNG_EXPORT(99, void, png_data_freer,
1903 (png_structp png_ptr, png_infop info_ptr, int freer, png_uint_32 mask));
1905 /* Assignments for png_data_freer */
1906 #define PNG_DESTROY_WILL_FREE_DATA 1
1907 #define PNG_SET_WILL_FREE_DATA 1
1908 #define PNG_USER_WILL_FREE_DATA 2
1909 /* Flags for png_ptr->free_me and info_ptr->free_me */
1910 #define PNG_FREE_HIST 0x0008
1911 #define PNG_FREE_ICCP 0x0010
1912 #define PNG_FREE_SPLT 0x0020
1913 #define PNG_FREE_ROWS 0x0040
1914 #define PNG_FREE_PCAL 0x0080
1915 #define PNG_FREE_SCAL 0x0100
1916 #define PNG_FREE_UNKN 0x0200
1917 #define PNG_FREE_LIST 0x0400
1918 #define PNG_FREE_PLTE 0x1000
1919 #define PNG_FREE_TRNS 0x2000
1920 #define PNG_FREE_TEXT 0x4000
1921 #define PNG_FREE_ALL 0x7fff
1922 #define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
1924 #ifdef PNG_USER_MEM_SUPPORTED
1925 PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_structp png_ptr,
1926 png_alloc_size_t size), PNG_ALLOCATED);
1927 PNG_EXPORT(101, void, png_free_default, (png_structp png_ptr, png_voidp ptr));
1930 #ifdef PNG_ERROR_TEXT_SUPPORTED
1931 /* Fatal error in PNG image of libpng - can't continue */
1932 PNG_EXPORTA(102, void, png_error,
1933 (png_structp png_ptr, png_const_charp error_message),
1936 /* The same, but the chunk name is prepended to the error string. */
1937 PNG_EXPORTA(103, void, png_chunk_error, (png_structp png_ptr,
1938 png_const_charp error_message), PNG_NORETURN);
1941 /* Fatal error in PNG image of libpng - can't continue */
1942 PNG_EXPORTA(104, void, png_err, (png_structp png_ptr), PNG_NORETURN);
1945 #ifdef PNG_WARNINGS_SUPPORTED
1946 /* Non-fatal error in libpng. Can continue, but may have a problem. */
1947 PNG_EXPORT(105, void, png_warning, (png_structp png_ptr,
1948 png_const_charp warning_message));
1950 /* Non-fatal error in libpng, chunk name is prepended to message. */
1951 PNG_EXPORT(106, void, png_chunk_warning, (png_structp png_ptr,
1952 png_const_charp warning_message));
1955 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
1956 /* Benign error in libpng. Can continue, but may have a problem.
1957 * User can choose whether to handle as a fatal error or as a warning. */
1958 # undef png_benign_error
1959 PNG_EXPORT(107, void, png_benign_error, (png_structp png_ptr,
1960 png_const_charp warning_message));
1962 /* Same, chunk name is prepended to message. */
1963 # undef png_chunk_benign_error
1964 PNG_EXPORT(108, void, png_chunk_benign_error, (png_structp png_ptr,
1965 png_const_charp warning_message));
1967 PNG_EXPORT(109, void, png_set_benign_errors,
1968 (png_structp png_ptr, int allowed));
1970 # ifdef PNG_ALLOW_BENIGN_ERRORS
1971 # define png_benign_error png_warning
1972 # define png_chunk_benign_error png_chunk_warning
1974 # define png_benign_error png_error
1975 # define png_chunk_benign_error png_chunk_error
1979 /* The png_set_<chunk> functions are for storing values in the png_info_struct.
1980 * Similarly, the png_get_<chunk> calls are used to read values from the
1981 * png_info_struct, either storing the parameters in the passed variables, or
1982 * setting pointers into the png_info_struct where the data is stored. The
1983 * png_get_<chunk> functions return a non-zero value if the data was available
1984 * in info_ptr, or return zero and do not change any of the parameters if the
1985 * data was not available.
1987 * These functions should be used instead of directly accessing png_info
1988 * to avoid problems with future changes in the size and internal layout of
1991 /* Returns "flag" if chunk data is valid in info_ptr. */
1992 PNG_EXPORT(110, png_uint_32, png_get_valid,
1993 (png_const_structp png_ptr, png_const_infop info_ptr,
1996 /* Returns number of bytes needed to hold a transformed row. */
1997 PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structp png_ptr,
1998 png_const_infop info_ptr));
2000 #ifdef PNG_INFO_IMAGE_SUPPORTED
2001 /* Returns row_pointers, which is an array of pointers to scanlines that was
2002 * returned from png_read_png().
2004 PNG_EXPORT(112, png_bytepp, png_get_rows,
2005 (png_const_structp png_ptr, png_const_infop info_ptr));
2006 /* Set row_pointers, which is an array of pointers to scanlines for use
2007 * by png_write_png().
2009 PNG_EXPORT(113, void, png_set_rows, (png_structp png_ptr,
2010 png_infop info_ptr, png_bytepp row_pointers));
2013 /* Returns number of color channels in image. */
2014 PNG_EXPORT(114, png_byte, png_get_channels,
2015 (png_const_structp png_ptr, png_const_infop info_ptr));
2017 #ifdef PNG_EASY_ACCESS_SUPPORTED
2018 /* Returns image width in pixels. */
2019 PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structp png_ptr,
2020 png_const_infop info_ptr));
2022 /* Returns image height in pixels. */
2023 PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structp png_ptr,
2024 png_const_infop info_ptr));
2026 /* Returns image bit_depth. */
2027 PNG_EXPORT(117, png_byte, png_get_bit_depth,
2028 (png_const_structp png_ptr, png_const_infop info_ptr));
2030 /* Returns image color_type. */
2031 PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structp png_ptr,
2032 png_const_infop info_ptr));
2034 /* Returns image filter_type. */
2035 PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structp png_ptr,
2036 png_const_infop info_ptr));
2038 /* Returns image interlace_type. */
2039 PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structp png_ptr,
2040 png_const_infop info_ptr));
2042 /* Returns image compression_type. */
2043 PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structp png_ptr,
2044 png_const_infop info_ptr));
2046 /* Returns image resolution in pixels per meter, from pHYs chunk data. */
2047 PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter,
2048 (png_const_structp png_ptr, png_const_infop info_ptr));
2049 PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter,
2050 (png_const_structp png_ptr, png_const_infop info_ptr));
2051 PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter,
2052 (png_const_structp png_ptr, png_const_infop info_ptr));
2054 /* Returns pixel aspect ratio, computed from pHYs chunk data. */
2055 PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio,
2056 (png_const_structp png_ptr, png_const_infop info_ptr));
2057 PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed,
2058 (png_const_structp png_ptr, png_const_infop info_ptr));
2060 /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
2061 PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels,
2062 (png_const_structp png_ptr, png_const_infop info_ptr));
2063 PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels,
2064 (png_const_structp png_ptr, png_const_infop info_ptr));
2065 PNG_EXPORT(128, png_int_32, png_get_x_offset_microns,
2066 (png_const_structp png_ptr, png_const_infop info_ptr));
2067 PNG_EXPORT(129, png_int_32, png_get_y_offset_microns,
2068 (png_const_structp png_ptr, png_const_infop info_ptr));
2070 #endif /* PNG_EASY_ACCESS_SUPPORTED */
2072 /* Returns pointer to signature string read from PNG header */
2073 PNG_EXPORT(130, png_const_bytep, png_get_signature,
2074 (png_const_structp png_ptr, png_infop info_ptr));
2076 #ifdef PNG_bKGD_SUPPORTED
2077 PNG_EXPORT(131, png_uint_32, png_get_bKGD,
2078 (png_const_structp png_ptr, png_infop info_ptr,
2079 png_color_16p *background));
2082 #ifdef PNG_bKGD_SUPPORTED
2083 PNG_EXPORT(132, void, png_set_bKGD, (png_structp png_ptr, png_infop info_ptr,
2084 png_const_color_16p background));
2087 #ifdef PNG_cHRM_SUPPORTED
2088 PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structp png_ptr,
2089 png_const_infop info_ptr, double *white_x, double *white_y, double *red_x,
2090 double *red_y, double *green_x, double *green_y, double *blue_x,
2092 PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_structp png_ptr,
2093 png_const_infop info_ptr, double *red_X, double *red_Y, double *red_Z,
2094 double *green_X, double *green_Y, double *green_Z, double *blue_X,
2095 double *blue_Y, double *blue_Z));
2096 #ifdef PNG_FIXED_POINT_SUPPORTED /* Otherwise not implemented */
2097 PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed,
2098 (png_const_structp png_ptr,
2099 png_const_infop info_ptr, png_fixed_point *int_white_x,
2100 png_fixed_point *int_white_y, png_fixed_point *int_red_x,
2101 png_fixed_point *int_red_y, png_fixed_point *int_green_x,
2102 png_fixed_point *int_green_y, png_fixed_point *int_blue_x,
2103 png_fixed_point *int_blue_y));
2105 PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed,
2106 (png_structp png_ptr, png_const_infop info_ptr,
2107 png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
2108 png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
2109 png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
2110 png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
2111 png_fixed_point *int_blue_Z));
2114 #ifdef PNG_cHRM_SUPPORTED
2115 PNG_FP_EXPORT(135, void, png_set_cHRM,
2116 (png_structp png_ptr, png_infop info_ptr,
2117 double white_x, double white_y, double red_x, double red_y, double green_x,
2118 double green_y, double blue_x, double blue_y));
2119 PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_structp png_ptr,
2120 png_infop info_ptr, double red_X, double red_Y, double red_Z,
2121 double green_X, double green_Y, double green_Z, double blue_X,
2122 double blue_Y, double blue_Z));
2123 PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_structp png_ptr,
2124 png_infop info_ptr, png_fixed_point int_white_x,
2125 png_fixed_point int_white_y, png_fixed_point int_red_x,
2126 png_fixed_point int_red_y, png_fixed_point int_green_x,
2127 png_fixed_point int_green_y, png_fixed_point int_blue_x,
2128 png_fixed_point int_blue_y));
2129 PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_structp png_ptr,
2130 png_infop info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y,
2131 png_fixed_point int_red_Z, png_fixed_point int_green_X,
2132 png_fixed_point int_green_Y, png_fixed_point int_green_Z,
2133 png_fixed_point int_blue_X, png_fixed_point int_blue_Y,
2134 png_fixed_point int_blue_Z));
2137 #ifdef PNG_gAMA_SUPPORTED
2138 PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA,
2139 (png_const_structp png_ptr, png_const_infop info_ptr,
2140 double *file_gamma));
2141 PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed,
2142 (png_const_structp png_ptr, png_const_infop info_ptr,
2143 png_fixed_point *int_file_gamma));
2146 #ifdef PNG_gAMA_SUPPORTED
2147 PNG_FP_EXPORT(139, void, png_set_gAMA, (png_structp png_ptr,
2148 png_infop info_ptr, double file_gamma));
2149 PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_structp png_ptr,
2150 png_infop info_ptr, png_fixed_point int_file_gamma));
2153 #ifdef PNG_hIST_SUPPORTED
2154 PNG_EXPORT(141, png_uint_32, png_get_hIST,
2155 (png_const_structp png_ptr, png_const_infop info_ptr,
2156 png_uint_16p *hist));
2159 #ifdef PNG_hIST_SUPPORTED
2160 PNG_EXPORT(142, void, png_set_hIST, (png_structp png_ptr,
2161 png_infop info_ptr, png_const_uint_16p hist));
2164 PNG_EXPORT(143, png_uint_32, png_get_IHDR,
2165 (png_structp png_ptr, png_infop info_ptr,
2166 png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type,
2167 int *interlace_method, int *compression_method, int *filter_method));
2169 PNG_EXPORT(144, void, png_set_IHDR,
2170 (png_structp png_ptr, png_infop info_ptr,
2171 png_uint_32 width, png_uint_32 height, int bit_depth, int color_type,
2172 int interlace_method, int compression_method, int filter_method));
2174 #ifdef PNG_oFFs_SUPPORTED
2175 PNG_EXPORT(145, png_uint_32, png_get_oFFs,
2176 (png_const_structp png_ptr, png_const_infop info_ptr,
2177 png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type));
2180 #ifdef PNG_oFFs_SUPPORTED
2181 PNG_EXPORT(146, void, png_set_oFFs,
2182 (png_structp png_ptr, png_infop info_ptr,
2183 png_int_32 offset_x, png_int_32 offset_y, int unit_type));
2186 #ifdef PNG_pCAL_SUPPORTED
2187 PNG_EXPORT(147, png_uint_32, png_get_pCAL,
2188 (png_const_structp png_ptr, png_const_infop info_ptr,
2189 png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type,
2191 png_charp *units, png_charpp *params));
2194 #ifdef PNG_pCAL_SUPPORTED
2195 PNG_EXPORT(148, void, png_set_pCAL, (png_structp png_ptr,
2197 png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type,
2198 int nparams, png_const_charp units, png_charpp params));
2201 #ifdef PNG_pHYs_SUPPORTED
2202 PNG_EXPORT(149, png_uint_32, png_get_pHYs,
2203 (png_const_structp png_ptr, png_const_infop info_ptr,
2204 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));
2207 #ifdef PNG_pHYs_SUPPORTED
2208 PNG_EXPORT(150, void, png_set_pHYs,
2209 (png_structp png_ptr, png_infop info_ptr,
2210 png_uint_32 res_x, png_uint_32 res_y, int unit_type));
2213 PNG_EXPORT(151, png_uint_32, png_get_PLTE,
2214 (png_const_structp png_ptr, png_const_infop info_ptr,
2215 png_colorp *palette, int *num_palette));
2217 PNG_EXPORT(152, void, png_set_PLTE,
2218 (png_structp png_ptr, png_infop info_ptr,
2219 png_const_colorp palette, int num_palette));
2221 #ifdef PNG_sBIT_SUPPORTED
2222 PNG_EXPORT(153, png_uint_32, png_get_sBIT,
2223 (png_const_structp png_ptr, png_infop info_ptr,
2224 png_color_8p *sig_bit));
2227 #ifdef PNG_sBIT_SUPPORTED
2228 PNG_EXPORT(154, void, png_set_sBIT,
2229 (png_structp png_ptr, png_infop info_ptr, png_const_color_8p sig_bit));
2232 #ifdef PNG_sRGB_SUPPORTED
2233 PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structp png_ptr,
2234 png_const_infop info_ptr, int *file_srgb_intent));
2237 #ifdef PNG_sRGB_SUPPORTED
2238 PNG_EXPORT(156, void, png_set_sRGB,
2239 (png_structp png_ptr, png_infop info_ptr, int srgb_intent));
2240 PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_structp png_ptr,
2241 png_infop info_ptr, int srgb_intent));
2244 #ifdef PNG_iCCP_SUPPORTED
2245 PNG_EXPORT(158, png_uint_32, png_get_iCCP,
2246 (png_const_structp png_ptr, png_const_infop info_ptr,
2247 png_charpp name, int *compression_type, png_bytepp profile,
2248 png_uint_32 *proflen));
2251 #ifdef PNG_iCCP_SUPPORTED
2252 PNG_EXPORT(159, void, png_set_iCCP,
2253 (png_structp png_ptr, png_infop info_ptr,
2254 png_const_charp name, int compression_type, png_const_bytep profile,
2255 png_uint_32 proflen));
2258 #ifdef PNG_sPLT_SUPPORTED
2259 PNG_EXPORT(160, png_uint_32, png_get_sPLT,
2260 (png_const_structp png_ptr, png_const_infop info_ptr,
2261 png_sPLT_tpp entries));
2264 #ifdef PNG_sPLT_SUPPORTED
2265 PNG_EXPORT(161, void, png_set_sPLT,
2266 (png_structp png_ptr, png_infop info_ptr,
2267 png_const_sPLT_tp entries, int nentries));
2270 #ifdef PNG_TEXT_SUPPORTED
2271 /* png_get_text also returns the number of text chunks in *num_text */
2272 PNG_EXPORT(162, png_uint_32, png_get_text,
2273 (png_const_structp png_ptr, png_const_infop info_ptr,
2274 png_textp *text_ptr, int *num_text));
2277 /* Note while png_set_text() will accept a structure whose text,
2278 * language, and translated keywords are NULL pointers, the structure
2279 * returned by png_get_text will always contain regular
2280 * zero-terminated C strings. They might be empty strings but
2281 * they will never be NULL pointers.
2284 #ifdef PNG_TEXT_SUPPORTED
2285 PNG_EXPORT(163, void, png_set_text,
2286 (png_structp png_ptr, png_infop info_ptr,
2287 png_const_textp text_ptr, int num_text));
2290 #ifdef PNG_tIME_SUPPORTED
2291 PNG_EXPORT(164, png_uint_32, png_get_tIME,
2292 (png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time));
2295 #ifdef PNG_tIME_SUPPORTED
2296 PNG_EXPORT(165, void, png_set_tIME,
2297 (png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time));
2300 #ifdef PNG_tRNS_SUPPORTED
2301 PNG_EXPORT(166, png_uint_32, png_get_tRNS,
2302 (png_const_structp png_ptr, png_infop info_ptr,
2303 png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color));
2306 #ifdef PNG_tRNS_SUPPORTED
2307 PNG_EXPORT(167, void, png_set_tRNS,
2308 (png_structp png_ptr, png_infop info_ptr,
2309 png_const_bytep trans_alpha, int num_trans,
2310 png_const_color_16p trans_color));
2313 #ifdef PNG_sCAL_SUPPORTED
2314 PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL,
2315 (png_const_structp png_ptr, png_const_infop info_ptr,
2316 int *unit, double *width, double *height));
2317 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2318 /* NOTE: this API is currently implemented using floating point arithmetic,
2319 * consequently it can only be used on systems with floating point support.
2320 * In any case the range of values supported by png_fixed_point is small and it
2321 * is highly recommended that png_get_sCAL_s be used instead.
2323 PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed,
2324 (png_structp png_ptr, png_const_infop info_ptr, int *unit,
2325 png_fixed_point *width,
2326 png_fixed_point *height));
2328 PNG_EXPORT(169, png_uint_32, png_get_sCAL_s,
2329 (png_const_structp png_ptr, png_const_infop info_ptr,
2330 int *unit, png_charpp swidth, png_charpp sheight));
2332 PNG_FP_EXPORT(170, void, png_set_sCAL,
2333 (png_structp png_ptr, png_infop info_ptr,
2334 int unit, double width, double height));
2335 PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_structp png_ptr,
2336 png_infop info_ptr, int unit, png_fixed_point width,
2337 png_fixed_point height));
2338 PNG_EXPORT(171, void, png_set_sCAL_s,
2339 (png_structp png_ptr, png_infop info_ptr,
2340 int unit, png_const_charp swidth, png_const_charp sheight));
2341 #endif /* PNG_sCAL_SUPPORTED */
2343 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
2344 /* Provide a list of chunks and how they are to be handled, if the built-in
2345 handling or default unknown chunk handling is not desired. Any chunks not
2346 listed will be handled in the default manner. The IHDR and IEND chunks
2347 must not be listed. Because this turns off the default handling for chunks
2348 that would otherwise be recognized the behavior of libpng transformations may
2349 well become incorrect!
2350 keep = 0: PNG_HANDLE_CHUNK_AS_DEFAULT: follow default behavior
2351 = 1: PNG_HANDLE_CHUNK_NEVER: do not keep
2352 = 2: PNG_HANDLE_CHUNK_IF_SAFE: keep only if safe-to-copy
2353 = 3: PNG_HANDLE_CHUNK_ALWAYS: keep even if unsafe-to-copy
2355 PNG_EXPORT(172, void, png_set_keep_unknown_chunks,
2356 (png_structp png_ptr, int keep,
2357 png_const_bytep chunk_list, int num_chunks));
2359 /* The handling code is returned; the result is therefore true (non-zero) if
2360 * special handling is required, false for the default handling.
2362 PNG_EXPORT(173, int, png_handle_as_unknown, (png_structp png_ptr,
2363 png_const_bytep chunk_name));
2365 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
2366 PNG_EXPORT(174, void, png_set_unknown_chunks, (png_structp png_ptr,
2367 png_infop info_ptr, png_const_unknown_chunkp unknowns,
2369 PNG_EXPORT(175, void, png_set_unknown_chunk_location,
2370 (png_structp png_ptr, png_infop info_ptr, int chunk, int location));
2371 PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structp png_ptr,
2372 png_const_infop info_ptr, png_unknown_chunkpp entries));
2375 /* Png_free_data() will turn off the "valid" flag for anything it frees.
2376 * If you need to turn it off for a chunk that your application has freed,
2377 * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);
2379 PNG_EXPORT(177, void, png_set_invalid,
2380 (png_structp png_ptr, png_infop info_ptr, int mask));
2382 #ifdef PNG_INFO_IMAGE_SUPPORTED
2383 /* The "params" pointer is currently not used and is for future expansion. */
2384 PNG_EXPORT(178, void, png_read_png, (png_structp png_ptr, png_infop info_ptr,
2385 int transforms, png_voidp params));
2386 PNG_EXPORT(179, void, png_write_png, (png_structp png_ptr, png_infop info_ptr,
2387 int transforms, png_voidp params));
2390 PNG_EXPORT(180, png_const_charp, png_get_copyright,
2391 (png_const_structp png_ptr));
2392 PNG_EXPORT(181, png_const_charp, png_get_header_ver,
2393 (png_const_structp png_ptr));
2394 PNG_EXPORT(182, png_const_charp, png_get_header_version,
2395 (png_const_structp png_ptr));
2396 PNG_EXPORT(183, png_const_charp, png_get_libpng_ver,
2397 (png_const_structp png_ptr));
2399 #ifdef PNG_MNG_FEATURES_SUPPORTED
2400 PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structp png_ptr,
2401 png_uint_32 mng_features_permitted));
2404 /* For use in png_set_keep_unknown, added to version 1.2.6 */
2405 #define PNG_HANDLE_CHUNK_AS_DEFAULT 0
2406 #define PNG_HANDLE_CHUNK_NEVER 1
2407 #define PNG_HANDLE_CHUNK_IF_SAFE 2
2408 #define PNG_HANDLE_CHUNK_ALWAYS 3
2410 /* Strip the prepended error numbers ("#nnn ") from error and warning
2411 * messages before passing them to the error or warning handler.
2413 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
2414 PNG_EXPORT(185, void, png_set_strip_error_numbers,
2415 (png_structp png_ptr,
2416 png_uint_32 strip_mode));
2419 /* Added in libpng-1.2.6 */
2420 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
2421 PNG_EXPORT(186, void, png_set_user_limits, (png_structp png_ptr,
2422 png_uint_32 user_width_max, png_uint_32 user_height_max));
2423 PNG_EXPORT(187, png_uint_32, png_get_user_width_max,
2424 (png_const_structp png_ptr));
2425 PNG_EXPORT(188, png_uint_32, png_get_user_height_max,
2426 (png_const_structp png_ptr));
2427 /* Added in libpng-1.4.0 */
2428 PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structp png_ptr,
2429 png_uint_32 user_chunk_cache_max));
2430 PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max,
2431 (png_const_structp png_ptr));
2432 /* Added in libpng-1.4.1 */
2433 PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structp png_ptr,
2434 png_alloc_size_t user_chunk_cache_max));
2435 PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max,
2436 (png_const_structp png_ptr));
2439 #if defined(PNG_INCH_CONVERSIONS_SUPPORTED)
2440 PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch,
2441 (png_const_structp png_ptr, png_const_infop info_ptr));
2443 PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch,
2444 (png_const_structp png_ptr, png_const_infop info_ptr));
2446 PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch,
2447 (png_const_structp png_ptr, png_const_infop info_ptr));
2449 PNG_FP_EXPORT(196, float, png_get_x_offset_inches,
2450 (png_const_structp png_ptr, png_const_infop info_ptr));
2451 #ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
2452 PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed,
2453 (png_structp png_ptr, png_const_infop info_ptr));
2456 PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structp png_ptr,
2457 png_const_infop info_ptr));
2458 #ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
2459 PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed,
2460 (png_structp png_ptr, png_const_infop info_ptr));
2463 # ifdef PNG_pHYs_SUPPORTED
2464 PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structp png_ptr,
2465 png_const_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
2467 # endif /* PNG_pHYs_SUPPORTED */
2468 #endif /* PNG_INCH_CONVERSIONS_SUPPORTED */
2470 /* Added in libpng-1.4.0 */
2471 #ifdef PNG_IO_STATE_SUPPORTED
2472 PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_structp png_ptr));
2474 PNG_EXPORTA(200, png_const_bytep, png_get_io_chunk_name,
2475 (png_structp png_ptr), PNG_DEPRECATED);
2476 PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
2477 (png_const_structp png_ptr));
2479 /* The flags returned by png_get_io_state() are the following: */
2480 # define PNG_IO_NONE 0x0000 /* no I/O at this moment */
2481 # define PNG_IO_READING 0x0001 /* currently reading */
2482 # define PNG_IO_WRITING 0x0002 /* currently writing */
2483 # define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */
2484 # define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */
2485 # define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */
2486 # define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */
2487 # define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */
2488 # define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */
2489 #endif /* ?PNG_IO_STATE_SUPPORTED */
2491 /* Interlace support. The following macros are always defined so that if
2492 * libpng interlace handling is turned off the macros may be used to handle
2493 * interlaced images within the application.
2495 #define PNG_INTERLACE_ADAM7_PASSES 7
2497 /* Two macros to return the first row and first column of the original,
2498 * full, image which appears in a given pass. 'pass' is in the range 0
2499 * to 6 and the result is in the range 0 to 7.
2501 #define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7)
2502 #define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7)
2504 /* A macro to return the offset between pixels in the output row for a pair of
2505 * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that
2506 * follows. Note that ROW_OFFSET is the offset from one row to the next whereas
2507 * COL_OFFSET is from one column to the next, within a row.
2509 #define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8)
2510 #define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1))
2512 /* Two macros to help evaluate the number of rows or columns in each
2513 * pass. This is expressed as a shift - effectively log2 of the number or
2514 * rows or columns in each 8x8 tile of the original image.
2516 #define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
2517 #define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
2519 /* Hence two macros to determine the number of rows or columns in a given
2520 * pass of an image given its height or width. In fact these macros may
2521 * return non-zero even though the sub-image is empty, because the other
2522 * dimension may be empty for a small image.
2524 #define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
2525 -1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
2526 #define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
2527 -1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
2529 /* For the reader row callbacks (both progressive and sequential) it is
2530 * necessary to find the row in the output image given a row in an interlaced
2531 * image, so two more macros:
2533 #define PNG_ROW_FROM_PASS_ROW(yIn, pass) \
2534 (((yIn)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
2535 #define PNG_COL_FROM_PASS_COL(xIn, pass) \
2536 (((xIn)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
2538 /* Two macros which return a boolean (0 or 1) saying whether the given row
2539 * or column is in a particular pass. These use a common utility macro that
2540 * returns a mask for a given pass - the offset 'off' selects the row or
2541 * column version. The mask has the appropriate bit set for each column in
2544 #define PNG_PASS_MASK(pass,off) ( \
2545 ((0x110145AF>>(((7-(off))-(pass))<<2)) & 0xF) | \
2546 ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0))
2548 #define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
2549 ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
2550 #define PNG_COL_IN_INTERLACE_PASS(x, pass) \
2551 ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
2553 #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
2554 /* With these routines we avoid an integer divide, which will be slower on
2555 * most machines. However, it does take more operations than the corresponding
2556 * divide method, so it may be slower on a few RISC systems. There are two
2557 * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
2559 * Note that the rounding factors are NOT supposed to be the same! 128 and
2560 * 32768 are correct for the NODIV code; 127 and 32767 are correct for the
2563 * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]
2566 /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */
2568 # define png_composite(composite, fg, alpha, bg) \
2569 { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \
2570 * (png_uint_16)(alpha) \
2571 + (png_uint_16)(bg)*(png_uint_16)(255 \
2572 - (png_uint_16)(alpha)) + 128); \
2573 (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }
2575 # define png_composite_16(composite, fg, alpha, bg) \
2576 { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
2577 * (png_uint_32)(alpha) \
2578 + (png_uint_32)(bg)*(65535 \
2579 - (png_uint_32)(alpha)) + 32768); \
2580 (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }
2582 #else /* Standard method using integer division */
2584 # define png_composite(composite, fg, alpha, bg) \
2585 (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \
2586 (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
2589 # define png_composite_16(composite, fg, alpha, bg) \
2590 (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \
2591 (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \
2593 #endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */
2595 #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
2596 PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf));
2597 PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf));
2598 PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf));
2601 PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_structp png_ptr,
2602 png_const_bytep buf));
2603 /* No png_get_int_16 -- may be added if there's a real need for it. */
2605 /* Place a 32-bit number into a buffer in PNG byte order (big-endian). */
2606 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
2607 PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i));
2609 #ifdef PNG_SAVE_INT_32_SUPPORTED
2610 PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i));
2613 /* Place a 16-bit number into a buffer in PNG byte order.
2614 * The parameter is declared unsigned int, not png_uint_16,
2615 * just to avoid potential problems on pre-ANSI C compilers.
2617 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
2618 PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i));
2619 /* No png_save_int_16 -- may be added if there's a real need for it. */
2622 #ifdef PNG_USE_READ_MACROS
2623 /* Inline macros to do direct reads of bytes from the input buffer.
2624 * The png_get_int_32() routine assumes we are using two's complement
2625 * format for negative values, which is almost certainly true.
2627 # define png_get_uint_32(buf) \
2628 (((png_uint_32)(*(buf)) << 24) + \
2629 ((png_uint_32)(*((buf) + 1)) << 16) + \
2630 ((png_uint_32)(*((buf) + 2)) << 8) + \
2631 ((png_uint_32)(*((buf) + 3))))
2633 /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the
2634 * function) incorrectly returned a value of type png_uint_32.
2636 # define png_get_uint_16(buf) \
2638 (((unsigned int)(*(buf)) << 8) + \
2639 ((unsigned int)(*((buf) + 1)))))
2641 # define png_get_int_32(buf) \
2642 ((png_int_32)((*(buf) & 0x80) \
2643 ? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \
2644 : (png_int_32)png_get_uint_32(buf)))
2647 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
2648 defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
2649 PNG_EXPORT(234, void, png_set_check_for_invalid_index, (png_structp png_ptr,
2653 /* Maintainer: Put new public prototypes here ^, in libpng.3, and project
2657 /* The last ordinal number (this is the *last* one already used; the next
2658 * one to use is one more than this.) Maintainer, remember to add an entry to
2659 * scripts/symbols.def as well.
2661 #ifdef PNG_EXPORT_LAST_ORDINAL
2662 PNG_EXPORT_LAST_ORDINAL(234);
2669 #endif /* PNG_VERSION_INFO_ONLY */
2670 /* Do not put anything past this line */