1 | |
2 | /* png.h - header file for PNG reference library |
3 | * |
4 | * libpng version 1.2.54, November 12, 2015 |
5 | * |
6 | * Copyright (c) 1998-2015 Glenn Randers-Pehrson |
7 | * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
8 | * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
9 | * |
10 | * This code is released under the libpng license (See LICENSE, below) |
11 | * |
12 | * Authors and maintainers: |
13 | * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat |
14 | * libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger |
15 | * libpng versions 0.97, January 1998, through 1.2.54, November 12, 2015: Glenn |
16 | * See also "Contributing Authors", below. |
17 | */ |
18 | |
19 | /* |
20 | * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: |
21 | * |
22 | * If you modify libpng you may insert additional notices immediately following |
23 | * this sentence. |
24 | * |
25 | * This code is released under the libpng license. |
26 | * |
27 | * libpng versions 1.0.7, July 1, 2000, through 1.2.54, November 12, 2015, are |
28 | * Copyright (c) 2000-2002, 2004, 2006-2015 Glenn Randers-Pehrson, are |
29 | * derived from libpng-1.0.6, and are distributed according to the same |
30 | * disclaimer and license as libpng-1.0.6 with the following individuals |
31 | * added to the list of Contributing Authors: |
32 | * |
33 | * Simon-Pierre Cadieux |
34 | * Eric S. Raymond |
35 | * Cosmin Truta |
36 | * Gilles Vollant |
37 | * |
38 | * and with the following additions to the disclaimer: |
39 | * |
40 | * There is no warranty against interference with your enjoyment of the |
41 | * library or against infringement. There is no warranty that our |
42 | * efforts or the library will fulfill any of your particular purposes |
43 | * or needs. This library is provided with all faults, and the entire |
44 | * risk of satisfactory quality, performance, accuracy, and effort is with |
45 | * the user. |
46 | * |
47 | * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are |
48 | * Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from |
49 | * libpng-0.96, and are distributed according to the same disclaimer and |
50 | * license as libpng-0.96, with the following individuals added to the list |
51 | * of Contributing Authors: |
52 | * |
53 | * Tom Lane |
54 | * Glenn Randers-Pehrson |
55 | * Willem van Schaik |
56 | * |
57 | * libpng versions 0.89, June 1996, through 0.96, May 1997, are |
58 | * Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88, |
59 | * and are distributed according to the same disclaimer and license as |
60 | * libpng-0.88, with the following individuals added to the list of |
61 | * Contributing Authors: |
62 | * |
63 | * John Bowler |
64 | * Kevin Bracey |
65 | * Sam Bushell |
66 | * Magnus Holmgren |
67 | * Greg Roelofs |
68 | * Tom Tanner |
69 | * |
70 | * libpng versions 0.5, May 1995, through 0.88, January 1996, are |
71 | * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. |
72 | * |
73 | * For the purposes of this copyright and license, "Contributing Authors" |
74 | * is defined as the following set of individuals: |
75 | * |
76 | * Andreas Dilger |
77 | * Dave Martindale |
78 | * Guy Eric Schalnat |
79 | * Paul Schmidt |
80 | * Tim Wegner |
81 | * |
82 | * The PNG Reference Library is supplied "AS IS". The Contributing Authors |
83 | * and Group 42, Inc. disclaim all warranties, expressed or implied, |
84 | * including, without limitation, the warranties of merchantability and of |
85 | * fitness for any purpose. The Contributing Authors and Group 42, Inc. |
86 | * assume no liability for direct, indirect, incidental, special, exemplary, |
87 | * or consequential damages, which may result from the use of the PNG |
88 | * Reference Library, even if advised of the possibility of such damage. |
89 | * |
90 | * Permission is hereby granted to use, copy, modify, and distribute this |
91 | * source code, or portions hereof, for any purpose, without fee, subject |
92 | * to the following restrictions: |
93 | * |
94 | * 1. The origin of this source code must not be misrepresented. |
95 | * |
96 | * 2. Altered versions must be plainly marked as such and must not |
97 | * be misrepresented as being the original source. |
98 | * |
99 | * 3. This Copyright notice may not be removed or altered from any |
100 | * source or altered source distribution. |
101 | * |
102 | * The Contributing Authors and Group 42, Inc. specifically permit, without |
103 | * fee, and encourage the use of this source code as a component to |
104 | * supporting the PNG file format in commercial products. If you use this |
105 | * source code in a product, acknowledgment is not required but would be |
106 | * appreciated. |
107 | * |
108 | * END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE. |
109 | */ |
110 | |
111 | /* |
112 | * A "png_get_copyright" function is available, for convenient use in "about" |
113 | * boxes and the like: |
114 | * |
115 | * printf("%s", png_get_copyright(NULL)); |
116 | * |
117 | * Also, the PNG logo (in PNG format, of course) is supplied in the |
118 | * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). |
119 | */ |
120 | |
121 | /* |
122 | * Libpng is OSI Certified Open Source Software. OSI Certified Open Source is |
123 | * a certification mark of the Open Source Initiative. OSI has not addressed |
124 | * the additional disclaimers inserted at version 1.0.7. |
125 | */ |
126 | |
127 | /* |
128 | * The contributing authors would like to thank all those who helped |
129 | * with testing, bug fixes, and patience. This wouldn't have been |
130 | * possible without all of you. |
131 | * |
132 | * Thanks to Frank J. T. Wojcik for helping with the documentation. |
133 | */ |
134 | |
135 | /* Note about libpng version numbers: |
136 | * |
137 | * Due to various miscommunications, unforeseen code incompatibilities |
138 | * and occasional factors outside the authors' control, version numbering |
139 | * on the library has not always been consistent and straightforward. |
140 | * The following table summarizes matters since version 0.89c, which was |
141 | * the first widely used release: |
142 | * |
143 | * source png.h png.h shared-lib |
144 | * version string int version |
145 | * ------- ------ ----- ---------- |
146 | * 0.89c "1.0 beta 3" 0.89 89 1.0.89 |
147 | * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] |
148 | * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] |
149 | * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] |
150 | * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] |
151 | * 0.97c 0.97 97 2.0.97 |
152 | * 0.98 0.98 98 2.0.98 |
153 | * 0.99 0.99 98 2.0.99 |
154 | * 0.99a-m 0.99 99 2.0.99 |
155 | * 1.00 1.00 100 2.1.0 [100 should be 10000] |
156 | * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] |
157 | * 1.0.1 png.h string is 10001 2.1.0 |
158 | * 1.0.1a-e identical to the 10002 from here on, the shared library |
159 | * 1.0.2 source version) 10002 is 2.V where V is the source code |
160 | * 1.0.2a-b 10003 version, except as noted. |
161 | * 1.0.3 10003 |
162 | * 1.0.3a-d 10004 |
163 | * 1.0.4 10004 |
164 | * 1.0.4a-f 10005 |
165 | * 1.0.5 (+ 2 patches) 10005 |
166 | * 1.0.5a-d 10006 |
167 | * 1.0.5e-r 10100 (not source compatible) |
168 | * 1.0.5s-v 10006 (not binary compatible) |
169 | * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) |
170 | * 1.0.6d-f 10007 (still binary incompatible) |
171 | * 1.0.6g 10007 |
172 | * 1.0.6h 10007 10.6h (testing xy.z so-numbering) |
173 | * 1.0.6i 10007 10.6i |
174 | * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) |
175 | * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) |
176 | * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) |
177 | * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) |
178 | * 1.0.7 1 10007 (still compatible) |
179 | * ... |
180 | * 1.0.19 10 10019 10.so.0.19[.0] |
181 | * ... |
182 | * 1.0.64 10 10064 10.so.0.64[.0] |
183 | * 1.2.54 13 10254 12.so.0.54[.0] |
184 | * |
185 | * Henceforth the source version will match the shared-library major |
186 | * and minor numbers; the shared-library major version number will be |
187 | * used for changes in backward compatibility, as it is intended. The |
188 | * PNG_LIBPNG_VER macro, which is not used within libpng but is available |
189 | * for applications, is an unsigned integer of the form xyyzz corresponding |
190 | * to the source version x.y.z (leading zeros in y and z). Beta versions |
191 | * were given the previous public release number plus a letter, until |
192 | * version 1.0.6j; from then on they were given the upcoming public |
193 | * release number plus "betaNN" or "rcNN". |
194 | * |
195 | * Binary incompatibility exists only when applications make direct access |
196 | * to the info_ptr or png_ptr members through png.h, and the compiled |
197 | * application is loaded with a different version of the library. |
198 | * |
199 | * DLLNUM will change each time there are forward or backward changes |
200 | * in binary compatibility (e.g., when a new feature is added). |
201 | * |
202 | * See libpng.txt or libpng.3 for more information. The PNG specification |
203 | * is available as a W3C Recommendation and as an ISO Specification, |
204 | * <http://www.w3.org/TR/2003/REC-PNG-20031110/ |
205 | */ |
206 | |
207 | /* |
208 | * Y2K compliance in libpng: |
209 | * ========================= |
210 | * |
211 | * November 12, 2015 |
212 | * |
213 | * Since the PNG Development group is an ad-hoc body, we can't make |
214 | * an official declaration. |
215 | * |
216 | * This is your unofficial assurance that libpng from version 0.71 and |
217 | * upward through 1.2.54 are Y2K compliant. It is my belief that earlier |
218 | * versions were also Y2K compliant. |
219 | * |
220 | * Libpng only has three year fields. One is a 2-byte unsigned integer |
221 | * that will hold years up to 65535. The other two hold the date in text |
222 | * format, and will hold years up to 9999. |
223 | * |
224 | * The integer is |
225 | * "png_uint_16 year" in png_time_struct. |
226 | * |
227 | * The strings are |
228 | * "png_charp time_buffer" in png_struct and |
229 | * "near_time_buffer", which is a local character string in png.c. |
230 | * |
231 | * There are seven time-related functions: |
232 | * png.c: png_convert_to_rfc_1123() in png.c |
233 | * (formerly png_convert_to_rfc_1152() in error) |
234 | * png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c |
235 | * png_convert_from_time_t() in pngwrite.c |
236 | * png_get_tIME() in pngget.c |
237 | * png_handle_tIME() in pngrutil.c, called in pngread.c |
238 | * png_set_tIME() in pngset.c |
239 | * png_write_tIME() in pngwutil.c, called in pngwrite.c |
240 | * |
241 | * All handle dates properly in a Y2K environment. The |
242 | * png_convert_from_time_t() function calls gmtime() to convert from system |
243 | * clock time, which returns (year - 1900), which we properly convert to |
244 | * the full 4-digit year. There is a possibility that applications using |
245 | * libpng are not passing 4-digit years into the png_convert_to_rfc_1123() |
246 | * function, or that they are incorrectly passing only a 2-digit year |
247 | * instead of "year - 1900" into the png_convert_from_struct_tm() function, |
248 | * but this is not under our control. The libpng documentation has always |
249 | * stated that it works with 4-digit years, and the APIs have been |
250 | * documented as such. |
251 | * |
252 | * The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned |
253 | * integer to hold the year, and can hold years as large as 65535. |
254 | * |
255 | * zlib, upon which libpng depends, is also Y2K compliant. It contains |
256 | * no date-related code. |
257 | * |
258 | * Glenn Randers-Pehrson |
259 | * libpng maintainer |
260 | * PNG Development Group |
261 | */ |
262 | |
263 | #ifndef PNG_H |
264 | #define PNG_H |
265 | |
266 | /* This is not the place to learn how to use libpng. The file libpng.txt |
267 | * describes how to use libpng, and the file example.c summarizes it |
268 | * with some code on which to build. This file is useful for looking |
269 | * at the actual function definitions and structure components. |
270 | */ |
271 | |
272 | /* Version information for png.h - this should match the version in png.c */ |
273 | #define PNG_LIBPNG_VER_STRING "1.2.54" |
274 | #define \ |
275 | " libpng version 1.2.54 - November 12, 2015\n" |
276 | |
277 | #define PNG_LIBPNG_VER_SONUM 0 |
278 | #define PNG_LIBPNG_VER_DLLNUM 13 |
279 | |
280 | /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ |
281 | #define PNG_LIBPNG_VER_MAJOR 1 |
282 | #define PNG_LIBPNG_VER_MINOR 2 |
283 | #define PNG_LIBPNG_VER_RELEASE 54 |
284 | /* This should match the numeric part of the final component of |
285 | * PNG_LIBPNG_VER_STRING, omitting any leading zero: |
286 | */ |
287 | |
288 | #define PNG_LIBPNG_VER_BUILD 0 |
289 | |
290 | /* Release Status */ |
291 | #define PNG_LIBPNG_BUILD_ALPHA 1 |
292 | #define PNG_LIBPNG_BUILD_BETA 2 |
293 | #define PNG_LIBPNG_BUILD_RC 3 |
294 | #define PNG_LIBPNG_BUILD_STABLE 4 |
295 | #define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7 |
296 | |
297 | /* Release-Specific Flags */ |
298 | #define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with |
299 | PNG_LIBPNG_BUILD_STABLE only */ |
300 | #define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with |
301 | PNG_LIBPNG_BUILD_SPECIAL */ |
302 | #define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with |
303 | PNG_LIBPNG_BUILD_PRIVATE */ |
304 | |
305 | #define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE |
306 | |
307 | /* Careful here. At one time, Guy wanted to use 082, but that would be octal. |
308 | * We must not include leading zeros. |
309 | * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only |
310 | * version 1.0.0 was mis-numbered 100 instead of 10000). From |
311 | * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release |
312 | */ |
313 | #define PNG_LIBPNG_VER 10254 /* 1.2.54 */ |
314 | |
315 | #ifndef PNG_VERSION_INFO_ONLY |
316 | /* Include the compression library's header */ |
317 | #include "zlib.h" |
318 | #endif |
319 | |
320 | /* Include all user configurable info, including optional assembler routines */ |
321 | #include "pngconf.h" |
322 | |
323 | /* |
324 | * Added at libpng-1.2.8 */ |
325 | /* Ref MSDN: Private as priority over Special |
326 | * VS_FF_PRIVATEBUILD File *was not* built using standard release |
327 | * procedures. If this value is given, the StringFileInfo block must |
328 | * contain a PrivateBuild string. |
329 | * |
330 | * VS_FF_SPECIALBUILD File *was* built by the original company using |
331 | * standard release procedures but is a variation of the standard |
332 | * file of the same version number. If this value is given, the |
333 | * StringFileInfo block must contain a SpecialBuild string. |
334 | */ |
335 | |
336 | #ifdef PNG_USER_PRIVATEBUILD |
337 | # define PNG_LIBPNG_BUILD_TYPE \ |
338 | (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) |
339 | #else |
340 | # ifdef PNG_LIBPNG_SPECIALBUILD |
341 | # define PNG_LIBPNG_BUILD_TYPE \ |
342 | (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) |
343 | # else |
344 | # define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE) |
345 | # endif |
346 | #endif |
347 | |
348 | #ifndef PNG_VERSION_INFO_ONLY |
349 | |
350 | /* Inhibit C++ name-mangling for libpng functions but not for system calls. */ |
351 | #ifdef __cplusplus |
352 | extern "C" { |
353 | #endif /* __cplusplus */ |
354 | |
355 | /* This file is arranged in several sections. The first section contains |
356 | * structure and type definitions. The second section contains the external |
357 | * library functions, while the third has the internal library functions, |
358 | * which applications aren't expected to use directly. |
359 | */ |
360 | |
361 | #ifndef PNG_NO_TYPECAST_NULL |
362 | #define int_p_NULL (int *)NULL |
363 | #define png_bytep_NULL (png_bytep)NULL |
364 | #define png_bytepp_NULL (png_bytepp)NULL |
365 | #define png_doublep_NULL (png_doublep)NULL |
366 | #define png_error_ptr_NULL (png_error_ptr)NULL |
367 | #define png_flush_ptr_NULL (png_flush_ptr)NULL |
368 | #define png_free_ptr_NULL (png_free_ptr)NULL |
369 | #define png_infopp_NULL (png_infopp)NULL |
370 | #define png_malloc_ptr_NULL (png_malloc_ptr)NULL |
371 | #define png_read_status_ptr_NULL (png_read_status_ptr)NULL |
372 | #define png_rw_ptr_NULL (png_rw_ptr)NULL |
373 | #define png_structp_NULL (png_structp)NULL |
374 | #define png_uint_16p_NULL (png_uint_16p)NULL |
375 | #define png_voidp_NULL (png_voidp)NULL |
376 | #define png_write_status_ptr_NULL (png_write_status_ptr)NULL |
377 | #else |
378 | #define int_p_NULL NULL |
379 | #define png_bytep_NULL NULL |
380 | #define png_bytepp_NULL NULL |
381 | #define png_doublep_NULL NULL |
382 | #define png_error_ptr_NULL NULL |
383 | #define png_flush_ptr_NULL NULL |
384 | #define png_free_ptr_NULL NULL |
385 | #define png_infopp_NULL NULL |
386 | #define png_malloc_ptr_NULL NULL |
387 | #define png_read_status_ptr_NULL NULL |
388 | #define png_rw_ptr_NULL NULL |
389 | #define png_structp_NULL NULL |
390 | #define png_uint_16p_NULL NULL |
391 | #define png_voidp_NULL NULL |
392 | #define png_write_status_ptr_NULL NULL |
393 | #endif |
394 | |
395 | /* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */ |
396 | #if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) |
397 | /* Version information for C files, stored in png.c. This had better match |
398 | * the version above. |
399 | */ |
400 | #ifdef PNG_USE_GLOBAL_ARRAYS |
401 | PNG_EXPORT_VAR (PNG_CONST char) png_libpng_ver[18]; |
402 | /* Need room for 99.99.99beta99z */ |
403 | #else |
404 | #define png_libpng_ver png_get_header_ver(NULL) |
405 | #endif |
406 | |
407 | #ifdef PNG_USE_GLOBAL_ARRAYS |
408 | /* This was removed in version 1.0.5c */ |
409 | /* Structures to facilitate easy interlacing. See png.c for more details */ |
410 | PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_start[7]; |
411 | PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_inc[7]; |
412 | PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_ystart[7]; |
413 | PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_yinc[7]; |
414 | PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_mask[7]; |
415 | PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_dsp_mask[7]; |
416 | /* This isn't currently used. If you need it, see png.c for more details. |
417 | PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_height[7]; |
418 | */ |
419 | #endif |
420 | |
421 | #endif /* PNG_NO_EXTERN */ |
422 | |
423 | /* Three color definitions. The order of the red, green, and blue, (and the |
424 | * exact size) is not important, although the size of the fields need to |
425 | * be png_byte or png_uint_16 (as defined below). |
426 | */ |
427 | typedef struct png_color_struct |
428 | { |
429 | png_byte red; |
430 | png_byte green; |
431 | png_byte blue; |
432 | } png_color; |
433 | typedef png_color FAR * png_colorp; |
434 | typedef png_color FAR * FAR * png_colorpp; |
435 | |
436 | typedef struct png_color_16_struct |
437 | { |
438 | png_byte index; /* used for palette files */ |
439 | png_uint_16 red; /* for use in red green blue files */ |
440 | png_uint_16 green; |
441 | png_uint_16 blue; |
442 | png_uint_16 gray; /* for use in grayscale files */ |
443 | } png_color_16; |
444 | typedef png_color_16 FAR * png_color_16p; |
445 | typedef png_color_16 FAR * FAR * png_color_16pp; |
446 | |
447 | typedef struct png_color_8_struct |
448 | { |
449 | png_byte red; /* for use in red green blue files */ |
450 | png_byte green; |
451 | png_byte blue; |
452 | png_byte gray; /* for use in grayscale files */ |
453 | png_byte alpha; /* for alpha channel files */ |
454 | } png_color_8; |
455 | typedef png_color_8 FAR * png_color_8p; |
456 | typedef png_color_8 FAR * FAR * png_color_8pp; |
457 | |
458 | /* |
459 | * The following two structures are used for the in-core representation |
460 | * of sPLT chunks. |
461 | */ |
462 | typedef struct png_sPLT_entry_struct |
463 | { |
464 | png_uint_16 red; |
465 | png_uint_16 green; |
466 | png_uint_16 blue; |
467 | png_uint_16 alpha; |
468 | png_uint_16 frequency; |
469 | } png_sPLT_entry; |
470 | typedef png_sPLT_entry FAR * png_sPLT_entryp; |
471 | typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; |
472 | |
473 | /* When the depth of the sPLT palette is 8 bits, the color and alpha samples |
474 | * occupy the LSB of their respective members, and the MSB of each member |
475 | * is zero-filled. The frequency member always occupies the full 16 bits. |
476 | */ |
477 | |
478 | typedef struct png_sPLT_struct |
479 | { |
480 | png_charp name; /* palette name */ |
481 | png_byte depth; /* depth of palette samples */ |
482 | png_sPLT_entryp entries; /* palette entries */ |
483 | png_int_32 nentries; /* number of palette entries */ |
484 | } png_sPLT_t; |
485 | typedef png_sPLT_t FAR * png_sPLT_tp; |
486 | typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; |
487 | |
488 | #ifdef PNG_TEXT_SUPPORTED |
489 | /* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file, |
490 | * and whether that contents is compressed or not. The "key" field |
491 | * points to a regular zero-terminated C string. The "text", "lang", and |
492 | * "lang_key" fields can be regular C strings, empty strings, or NULL pointers. |
493 | * However, the * structure returned by png_get_text() will always contain |
494 | * regular zero-terminated C strings (possibly empty), never NULL pointers, |
495 | * so they can be safely used in printf() and other string-handling functions. |
496 | */ |
497 | typedef struct png_text_struct |
498 | { |
499 | int compression; /* compression value: |
500 | -1: tEXt, none |
501 | 0: zTXt, deflate |
502 | 1: iTXt, none |
503 | 2: iTXt, deflate */ |
504 | png_charp key; /* keyword, 1-79 character description of "text" */ |
505 | png_charp text; /* comment, may be an empty string (ie "") |
506 | or a NULL pointer */ |
507 | png_size_t text_length; /* length of the text string */ |
508 | #ifdef PNG_iTXt_SUPPORTED |
509 | png_size_t itxt_length; /* length of the itxt string */ |
510 | png_charp lang; /* language code, 0-79 characters |
511 | or a NULL pointer */ |
512 | png_charp lang_key; /* keyword translated UTF-8 string, 0 or more |
513 | chars or a NULL pointer */ |
514 | #endif |
515 | } png_text; |
516 | typedef png_text FAR * png_textp; |
517 | typedef png_text FAR * FAR * png_textpp; |
518 | #endif |
519 | |
520 | /* Supported compression types for text in PNG files (tEXt, and zTXt). |
521 | * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. |
522 | */ |
523 | #define PNG_TEXT_COMPRESSION_NONE_WR -3 |
524 | #define PNG_TEXT_COMPRESSION_zTXt_WR -2 |
525 | #define PNG_TEXT_COMPRESSION_NONE -1 |
526 | #define PNG_TEXT_COMPRESSION_zTXt 0 |
527 | #define PNG_ITXT_COMPRESSION_NONE 1 |
528 | #define PNG_ITXT_COMPRESSION_zTXt 2 |
529 | #define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */ |
530 | |
531 | /* png_time is a way to hold the time in an machine independent way. |
532 | * Two conversions are provided, both from time_t and struct tm. There |
533 | * is no portable way to convert to either of these structures, as far |
534 | * as I know. If you know of a portable way, send it to me. As a side |
535 | * note - PNG has always been Year 2000 compliant! |
536 | */ |
537 | typedef struct png_time_struct |
538 | { |
539 | png_uint_16 year; /* full year, as in, 1995 */ |
540 | png_byte month; /* month of year, 1 - 12 */ |
541 | png_byte day; /* day of month, 1 - 31 */ |
542 | png_byte hour; /* hour of day, 0 - 23 */ |
543 | png_byte minute; /* minute of hour, 0 - 59 */ |
544 | png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ |
545 | } png_time; |
546 | typedef png_time FAR * png_timep; |
547 | typedef png_time FAR * FAR * png_timepp; |
548 | |
549 | #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ |
550 | defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) |
551 | /* png_unknown_chunk is a structure to hold queued chunks for which there is |
552 | * no specific support. The idea is that we can use this to queue |
553 | * up private chunks for output even though the library doesn't actually |
554 | * know about their semantics. |
555 | */ |
556 | #define PNG_CHUNK_NAME_LENGTH 5 |
557 | typedef struct png_unknown_chunk_t |
558 | { |
559 | png_byte name[PNG_CHUNK_NAME_LENGTH]; |
560 | png_byte *data; |
561 | png_size_t size; |
562 | |
563 | /* libpng-using applications should NOT directly modify this byte. */ |
564 | png_byte location; /* mode of operation at read time */ |
565 | } |
566 | png_unknown_chunk; |
567 | typedef png_unknown_chunk FAR * png_unknown_chunkp; |
568 | typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; |
569 | #endif |
570 | |
571 | /* png_info is a structure that holds the information in a PNG file so |
572 | * that the application can find out the characteristics of the image. |
573 | * If you are reading the file, this structure will tell you what is |
574 | * in the PNG file. If you are writing the file, fill in the information |
575 | * you want to put into the PNG file, then call png_write_info(). |
576 | * The names chosen should be very close to the PNG specification, so |
577 | * consult that document for information about the meaning of each field. |
578 | * |
579 | * With libpng < 0.95, it was only possible to directly set and read the |
580 | * the values in the png_info_struct, which meant that the contents and |
581 | * order of the values had to remain fixed. With libpng 0.95 and later, |
582 | * however, there are now functions that abstract the contents of |
583 | * png_info_struct from the application, so this makes it easier to use |
584 | * libpng with dynamic libraries, and even makes it possible to use |
585 | * libraries that don't have all of the libpng ancillary chunk-handing |
586 | * functionality. |
587 | * |
588 | * In any case, the order of the parameters in png_info_struct should NOT |
589 | * be changed for as long as possible to keep compatibility with applications |
590 | * that use the old direct-access method with png_info_struct. |
591 | * |
592 | * The following members may have allocated storage attached that should be |
593 | * cleaned up before the structure is discarded: palette, trans, text, |
594 | * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, |
595 | * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these |
596 | * are automatically freed when the info structure is deallocated, if they were |
597 | * allocated internally by libpng. This behavior can be changed by means |
598 | * of the png_data_freer() function. |
599 | * |
600 | * More allocation details: all the chunk-reading functions that |
601 | * change these members go through the corresponding png_set_* |
602 | * functions. A function to clear these members is available: see |
603 | * png_free_data(). The png_set_* functions do not depend on being |
604 | * able to point info structure members to any of the storage they are |
605 | * passed (they make their own copies), EXCEPT that the png_set_text |
606 | * functions use the same storage passed to them in the text_ptr or |
607 | * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns |
608 | * functions do not make their own copies. |
609 | */ |
610 | typedef struct png_info_struct |
611 | { |
612 | /* The following are necessary for every PNG file */ |
613 | png_uint_32 width PNG_DEPSTRUCT; /* width of image in pixels (from IHDR) */ |
614 | png_uint_32 height PNG_DEPSTRUCT; /* height of image in pixels (from IHDR) */ |
615 | png_uint_32 valid PNG_DEPSTRUCT; /* valid chunk data (see PNG_INFO_ below) */ |
616 | png_uint_32 rowbytes PNG_DEPSTRUCT; /* bytes needed to hold an untransformed row */ |
617 | png_colorp palette PNG_DEPSTRUCT; /* array of color values (valid & PNG_INFO_PLTE) */ |
618 | png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in "palette" (PLTE) */ |
619 | png_uint_16 num_trans PNG_DEPSTRUCT; /* number of transparent palette color (tRNS) */ |
620 | png_byte bit_depth PNG_DEPSTRUCT; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */ |
621 | png_byte color_type PNG_DEPSTRUCT; /* see PNG_COLOR_TYPE_ below (from IHDR) */ |
622 | /* The following three should have been named *_method not *_type */ |
623 | png_byte compression_type PNG_DEPSTRUCT; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */ |
624 | png_byte filter_type PNG_DEPSTRUCT; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ |
625 | png_byte interlace_type PNG_DEPSTRUCT; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ |
626 | |
627 | /* The following is informational only on read, and not used on writes. */ |
628 | png_byte channels PNG_DEPSTRUCT; /* number of data channels per pixel (1, 2, 3, 4) */ |
629 | png_byte pixel_depth PNG_DEPSTRUCT; /* number of bits per pixel */ |
630 | png_byte spare_byte PNG_DEPSTRUCT; /* to align the data, and for future use */ |
631 | png_byte signature[8] PNG_DEPSTRUCT; /* magic bytes read by libpng from start of file */ |
632 | |
633 | /* The rest of the data is optional. If you are reading, check the |
634 | * valid field to see if the information in these are valid. If you |
635 | * are writing, set the valid field to those chunks you want written, |
636 | * and initialize the appropriate fields below. |
637 | */ |
638 | |
639 | #if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) |
640 | /* The gAMA chunk describes the gamma characteristics of the system |
641 | * on which the image was created, normally in the range [1.0, 2.5]. |
642 | * Data is valid if (valid & PNG_INFO_gAMA) is non-zero. |
643 | */ |
644 | float gamma PNG_DEPSTRUCT; /* gamma value of image, if (valid & PNG_INFO_gAMA) */ |
645 | #endif |
646 | |
647 | #ifdef PNG_sRGB_SUPPORTED |
648 | /* GR-P, 0.96a */ |
649 | /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ |
650 | png_byte srgb_intent PNG_DEPSTRUCT; /* sRGB rendering intent [0, 1, 2, or 3] */ |
651 | #endif |
652 | |
653 | #ifdef PNG_TEXT_SUPPORTED |
654 | /* The tEXt, and zTXt chunks contain human-readable textual data in |
655 | * uncompressed, compressed, and optionally compressed forms, respectively. |
656 | * The data in "text" is an array of pointers to uncompressed, |
657 | * null-terminated C strings. Each chunk has a keyword that describes the |
658 | * textual data contained in that chunk. Keywords are not required to be |
659 | * unique, and the text string may be empty. Any number of text chunks may |
660 | * be in an image. |
661 | */ |
662 | int num_text PNG_DEPSTRUCT; /* number of comments read/to write */ |
663 | int max_text PNG_DEPSTRUCT; /* current size of text array */ |
664 | png_textp text PNG_DEPSTRUCT; /* array of comments read/to write */ |
665 | #endif /* PNG_TEXT_SUPPORTED */ |
666 | |
667 | #ifdef PNG_tIME_SUPPORTED |
668 | /* The tIME chunk holds the last time the displayed image data was |
669 | * modified. See the png_time struct for the contents of this struct. |
670 | */ |
671 | png_time mod_time PNG_DEPSTRUCT; |
672 | #endif |
673 | |
674 | #ifdef PNG_sBIT_SUPPORTED |
675 | /* The sBIT chunk specifies the number of significant high-order bits |
676 | * in the pixel data. Values are in the range [1, bit_depth], and are |
677 | * only specified for the channels in the pixel data. The contents of |
678 | * the low-order bits is not specified. Data is valid if |
679 | * (valid & PNG_INFO_sBIT) is non-zero. |
680 | */ |
681 | png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in color channels */ |
682 | #endif |
683 | |
684 | #if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ |
685 | defined(PNG_READ_BACKGROUND_SUPPORTED) |
686 | /* The tRNS chunk supplies transparency data for paletted images and |
687 | * other image types that don't need a full alpha channel. There are |
688 | * "num_trans" transparency values for a paletted image, stored in the |
689 | * same order as the palette colors, starting from index 0. Values |
690 | * for the data are in the range [0, 255], ranging from fully transparent |
691 | * to fully opaque, respectively. For non-paletted images, there is a |
692 | * single color specified that should be treated as fully transparent. |
693 | * Data is valid if (valid & PNG_INFO_tRNS) is non-zero. |
694 | */ |
695 | png_bytep trans PNG_DEPSTRUCT; /* transparent values for paletted image */ |
696 | png_color_16 trans_values PNG_DEPSTRUCT; /* transparent color for non-palette image */ |
697 | #endif |
698 | |
699 | #if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
700 | /* The bKGD chunk gives the suggested image background color if the |
701 | * display program does not have its own background color and the image |
702 | * is needs to composited onto a background before display. The colors |
703 | * in "background" are normally in the same color space/depth as the |
704 | * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. |
705 | */ |
706 | png_color_16 background PNG_DEPSTRUCT; |
707 | #endif |
708 | |
709 | #ifdef PNG_oFFs_SUPPORTED |
710 | /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards |
711 | * and downwards from the top-left corner of the display, page, or other |
712 | * application-specific co-ordinate space. See the PNG_OFFSET_ defines |
713 | * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. |
714 | */ |
715 | png_int_32 x_offset PNG_DEPSTRUCT; /* x offset on page */ |
716 | png_int_32 y_offset PNG_DEPSTRUCT; /* y offset on page */ |
717 | png_byte offset_unit_type PNG_DEPSTRUCT; /* offset units type */ |
718 | #endif |
719 | |
720 | #ifdef PNG_pHYs_SUPPORTED |
721 | /* The pHYs chunk gives the physical pixel density of the image for |
722 | * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ |
723 | * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. |
724 | */ |
725 | png_uint_32 x_pixels_per_unit PNG_DEPSTRUCT; /* horizontal pixel density */ |
726 | png_uint_32 y_pixels_per_unit PNG_DEPSTRUCT; /* vertical pixel density */ |
727 | png_byte phys_unit_type PNG_DEPSTRUCT; /* resolution type (see PNG_RESOLUTION_ below) */ |
728 | #endif |
729 | |
730 | #ifdef PNG_hIST_SUPPORTED |
731 | /* The hIST chunk contains the relative frequency or importance of the |
732 | * various palette entries, so that a viewer can intelligently select a |
733 | * reduced-color palette, if required. Data is an array of "num_palette" |
734 | * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) |
735 | * is non-zero. |
736 | */ |
737 | png_uint_16p hist PNG_DEPSTRUCT; |
738 | #endif |
739 | |
740 | #ifdef PNG_cHRM_SUPPORTED |
741 | /* The cHRM chunk describes the CIE color characteristics of the monitor |
742 | * on which the PNG was created. This data allows the viewer to do gamut |
743 | * mapping of the input image to ensure that the viewer sees the same |
744 | * colors in the image as the creator. Values are in the range |
745 | * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. |
746 | */ |
747 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
748 | float x_white PNG_DEPSTRUCT; |
749 | float y_white PNG_DEPSTRUCT; |
750 | float x_red PNG_DEPSTRUCT; |
751 | float y_red PNG_DEPSTRUCT; |
752 | float x_green PNG_DEPSTRUCT; |
753 | float y_green PNG_DEPSTRUCT; |
754 | float x_blue PNG_DEPSTRUCT; |
755 | float y_blue PNG_DEPSTRUCT; |
756 | #endif |
757 | #endif |
758 | |
759 | #ifdef PNG_pCAL_SUPPORTED |
760 | /* The pCAL chunk describes a transformation between the stored pixel |
761 | * values and original physical data values used to create the image. |
762 | * The integer range [0, 2^bit_depth - 1] maps to the floating-point |
763 | * range given by [pcal_X0, pcal_X1], and are further transformed by a |
764 | * (possibly non-linear) transformation function given by "pcal_type" |
765 | * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ |
766 | * defines below, and the PNG-Group's PNG extensions document for a |
767 | * complete description of the transformations and how they should be |
768 | * implemented, and for a description of the ASCII parameter strings. |
769 | * Data values are valid if (valid & PNG_INFO_pCAL) non-zero. |
770 | */ |
771 | png_charp pcal_purpose PNG_DEPSTRUCT; /* pCAL chunk description string */ |
772 | png_int_32 pcal_X0 PNG_DEPSTRUCT; /* minimum value */ |
773 | png_int_32 pcal_X1 PNG_DEPSTRUCT; /* maximum value */ |
774 | png_charp pcal_units PNG_DEPSTRUCT; /* Latin-1 string giving physical units */ |
775 | png_charpp pcal_params PNG_DEPSTRUCT; /* ASCII strings containing parameter values */ |
776 | png_byte pcal_type PNG_DEPSTRUCT; /* equation type (see PNG_EQUATION_ below) */ |
777 | png_byte pcal_nparams PNG_DEPSTRUCT; /* number of parameters given in pcal_params */ |
778 | #endif |
779 | |
780 | /* New members added in libpng-1.0.6 */ |
781 | #ifdef PNG_FREE_ME_SUPPORTED |
782 | png_uint_32 free_me PNG_DEPSTRUCT; /* flags items libpng is responsible for freeing */ |
783 | #endif |
784 | |
785 | #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ |
786 | defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) |
787 | /* Storage for unknown chunks that the library doesn't recognize. */ |
788 | png_unknown_chunkp unknown_chunks PNG_DEPSTRUCT; |
789 | png_size_t unknown_chunks_num PNG_DEPSTRUCT; |
790 | #endif |
791 | |
792 | #ifdef PNG_iCCP_SUPPORTED |
793 | /* iCCP chunk data. */ |
794 | png_charp iccp_name PNG_DEPSTRUCT; /* profile name */ |
795 | png_charp iccp_profile PNG_DEPSTRUCT; /* International Color Consortium profile data */ |
796 | /* Note to maintainer: should be png_bytep */ |
797 | png_uint_32 iccp_proflen PNG_DEPSTRUCT; /* ICC profile data length */ |
798 | png_byte iccp_compression PNG_DEPSTRUCT; /* Always zero */ |
799 | #endif |
800 | |
801 | #ifdef PNG_sPLT_SUPPORTED |
802 | /* Data on sPLT chunks (there may be more than one). */ |
803 | png_sPLT_tp splt_palettes PNG_DEPSTRUCT; |
804 | png_uint_32 splt_palettes_num PNG_DEPSTRUCT; |
805 | #endif |
806 | |
807 | #ifdef PNG_sCAL_SUPPORTED |
808 | /* The sCAL chunk describes the actual physical dimensions of the |
809 | * subject matter of the graphic. The chunk contains a unit specification |
810 | * a byte value, and two ASCII strings representing floating-point |
811 | * values. The values are width and height corresponsing to one pixel |
812 | * in the image. This external representation is converted to double |
813 | * here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero. |
814 | */ |
815 | png_byte scal_unit PNG_DEPSTRUCT; /* unit of physical scale */ |
816 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
817 | double scal_pixel_width PNG_DEPSTRUCT; /* width of one pixel */ |
818 | double scal_pixel_height PNG_DEPSTRUCT; /* height of one pixel */ |
819 | #endif |
820 | #ifdef PNG_FIXED_POINT_SUPPORTED |
821 | png_charp scal_s_width PNG_DEPSTRUCT; /* string containing height */ |
822 | png_charp scal_s_height PNG_DEPSTRUCT; /* string containing width */ |
823 | #endif |
824 | #endif |
825 | |
826 | #ifdef PNG_INFO_IMAGE_SUPPORTED |
827 | /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */ |
828 | /* Data valid if (valid & PNG_INFO_IDAT) non-zero */ |
829 | png_bytepp row_pointers PNG_DEPSTRUCT; /* the image bits */ |
830 | #endif |
831 | |
832 | #if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED) |
833 | png_fixed_point int_gamma PNG_DEPSTRUCT; /* gamma of image, if (valid & PNG_INFO_gAMA) */ |
834 | #endif |
835 | |
836 | #if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED) |
837 | png_fixed_point int_x_white PNG_DEPSTRUCT; |
838 | png_fixed_point int_y_white PNG_DEPSTRUCT; |
839 | png_fixed_point int_x_red PNG_DEPSTRUCT; |
840 | png_fixed_point int_y_red PNG_DEPSTRUCT; |
841 | png_fixed_point int_x_green PNG_DEPSTRUCT; |
842 | png_fixed_point int_y_green PNG_DEPSTRUCT; |
843 | png_fixed_point int_x_blue PNG_DEPSTRUCT; |
844 | png_fixed_point int_y_blue PNG_DEPSTRUCT; |
845 | #endif |
846 | |
847 | } png_info; |
848 | |
849 | typedef png_info FAR * png_infop; |
850 | typedef png_info FAR * FAR * png_infopp; |
851 | |
852 | /* Maximum positive integer used in PNG is (2^31)-1 */ |
853 | #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL) |
854 | #define PNG_UINT_32_MAX ((png_uint_32)(-1)) |
855 | #define PNG_SIZE_MAX ((png_size_t)(-1)) |
856 | #if defined(PNG_1_0_X) || defined (PNG_1_2_X) |
857 | /* PNG_MAX_UINT is deprecated; use PNG_UINT_31_MAX instead. */ |
858 | #define PNG_MAX_UINT PNG_UINT_31_MAX |
859 | #endif |
860 | |
861 | /* These describe the color_type field in png_info. */ |
862 | /* color type masks */ |
863 | #define PNG_COLOR_MASK_PALETTE 1 |
864 | #define PNG_COLOR_MASK_COLOR 2 |
865 | #define PNG_COLOR_MASK_ALPHA 4 |
866 | |
867 | /* color types. Note that not all combinations are legal */ |
868 | #define PNG_COLOR_TYPE_GRAY 0 |
869 | #define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE) |
870 | #define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR) |
871 | #define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) |
872 | #define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA) |
873 | /* aliases */ |
874 | #define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA |
875 | #define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA |
876 | |
877 | /* This is for compression type. PNG 1.0-1.2 only define the single type. */ |
878 | #define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */ |
879 | #define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE |
880 | |
881 | /* This is for filter type. PNG 1.0-1.2 only define the single type. */ |
882 | #define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */ |
883 | #define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */ |
884 | #define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE |
885 | |
886 | /* These are for the interlacing type. These values should NOT be changed. */ |
887 | #define PNG_INTERLACE_NONE 0 /* Non-interlaced image */ |
888 | #define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */ |
889 | #define PNG_INTERLACE_LAST 2 /* Not a valid value */ |
890 | |
891 | /* These are for the oFFs chunk. These values should NOT be changed. */ |
892 | #define PNG_OFFSET_PIXEL 0 /* Offset in pixels */ |
893 | #define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */ |
894 | #define PNG_OFFSET_LAST 2 /* Not a valid value */ |
895 | |
896 | /* These are for the pCAL chunk. These values should NOT be changed. */ |
897 | #define PNG_EQUATION_LINEAR 0 /* Linear transformation */ |
898 | #define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */ |
899 | #define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */ |
900 | #define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */ |
901 | #define PNG_EQUATION_LAST 4 /* Not a valid value */ |
902 | |
903 | /* These are for the sCAL chunk. These values should NOT be changed. */ |
904 | #define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */ |
905 | #define PNG_SCALE_METER 1 /* meters per pixel */ |
906 | #define PNG_SCALE_RADIAN 2 /* radians per pixel */ |
907 | #define PNG_SCALE_LAST 3 /* Not a valid value */ |
908 | |
909 | /* These are for the pHYs chunk. These values should NOT be changed. */ |
910 | #define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */ |
911 | #define PNG_RESOLUTION_METER 1 /* pixels/meter */ |
912 | #define PNG_RESOLUTION_LAST 2 /* Not a valid value */ |
913 | |
914 | /* These are for the sRGB chunk. These values should NOT be changed. */ |
915 | #define PNG_sRGB_INTENT_PERCEPTUAL 0 |
916 | #define PNG_sRGB_INTENT_RELATIVE 1 |
917 | #define PNG_sRGB_INTENT_SATURATION 2 |
918 | #define PNG_sRGB_INTENT_ABSOLUTE 3 |
919 | #define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */ |
920 | |
921 | /* This is for text chunks */ |
922 | #define PNG_KEYWORD_MAX_LENGTH 79 |
923 | |
924 | /* Maximum number of entries in PLTE/sPLT/tRNS arrays */ |
925 | #define PNG_MAX_PALETTE_LENGTH 256 |
926 | |
927 | /* These determine if an ancillary chunk's data has been successfully read |
928 | * from the PNG header, or if the application has filled in the corresponding |
929 | * data in the info_struct to be written into the output file. The values |
930 | * of the PNG_INFO_<chunk> defines should NOT be changed. |
931 | */ |
932 | #define PNG_INFO_gAMA 0x0001 |
933 | #define PNG_INFO_sBIT 0x0002 |
934 | #define PNG_INFO_cHRM 0x0004 |
935 | #define PNG_INFO_PLTE 0x0008 |
936 | #define PNG_INFO_tRNS 0x0010 |
937 | #define PNG_INFO_bKGD 0x0020 |
938 | #define PNG_INFO_hIST 0x0040 |
939 | #define PNG_INFO_pHYs 0x0080 |
940 | #define PNG_INFO_oFFs 0x0100 |
941 | #define PNG_INFO_tIME 0x0200 |
942 | #define PNG_INFO_pCAL 0x0400 |
943 | #define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ |
944 | #define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ |
945 | #define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ |
946 | #define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ |
947 | #define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ |
948 | |
949 | /* This is used for the transformation routines, as some of them |
950 | * change these values for the row. It also should enable using |
951 | * the routines for other purposes. |
952 | */ |
953 | typedef struct png_row_info_struct |
954 | { |
955 | png_uint_32 width; /* width of row */ |
956 | png_uint_32 rowbytes; /* number of bytes in row */ |
957 | png_byte color_type; /* color type of row */ |
958 | png_byte bit_depth; /* bit depth of row */ |
959 | png_byte channels; /* number of channels (1, 2, 3, or 4) */ |
960 | png_byte pixel_depth; /* bits per pixel (depth * channels) */ |
961 | } png_row_info; |
962 | |
963 | typedef png_row_info FAR * png_row_infop; |
964 | typedef png_row_info FAR * FAR * png_row_infopp; |
965 | |
966 | /* These are the function types for the I/O functions and for the functions |
967 | * that allow the user to override the default I/O functions with his or her |
968 | * own. The png_error_ptr type should match that of user-supplied warning |
969 | * and error functions, while the png_rw_ptr type should match that of the |
970 | * user read/write data functions. |
971 | */ |
972 | typedef struct png_struct_def png_struct; |
973 | typedef png_struct FAR * png_structp; |
974 | |
975 | typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); |
976 | typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); |
977 | typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); |
978 | typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, |
979 | int)); |
980 | typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, |
981 | int)); |
982 | |
983 | #ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
984 | typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); |
985 | typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); |
986 | typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, |
987 | png_uint_32, int)); |
988 | #endif |
989 | |
990 | #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
991 | defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
992 | defined(PNG_LEGACY_SUPPORTED) |
993 | typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, |
994 | png_row_infop, png_bytep)); |
995 | #endif |
996 | |
997 | #ifdef PNG_USER_CHUNKS_SUPPORTED |
998 | typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); |
999 | #endif |
1000 | #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
1001 | typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); |
1002 | #endif |
1003 | |
1004 | /* Transform masks for the high-level interface */ |
1005 | #define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ |
1006 | #define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ |
1007 | #define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ |
1008 | #define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ |
1009 | #define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ |
1010 | #define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ |
1011 | #define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ |
1012 | #define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ |
1013 | #define PNG_TRANSFORM_BGR 0x0080 /* read and write */ |
1014 | #define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ |
1015 | #define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ |
1016 | #define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ |
1017 | #define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only, deprecated */ |
1018 | /* Added to libpng-1.2.34 */ |
1019 | #define PNG_TRANSFORM_STRIP_FILLER_BEFORE 0x0800 /* write only */ |
1020 | #define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ |
1021 | /* Added to libpng-1.2.41 */ |
1022 | #define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ |
1023 | |
1024 | /* Flags for MNG supported features */ |
1025 | #define PNG_FLAG_MNG_EMPTY_PLTE 0x01 |
1026 | #define PNG_FLAG_MNG_FILTER_64 0x04 |
1027 | #define PNG_ALL_MNG_FEATURES 0x05 |
1028 | |
1029 | typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); |
1030 | typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); |
1031 | |
1032 | /* The structure that holds the information to read and write PNG files. |
1033 | * The only people who need to care about what is inside of this are the |
1034 | * people who will be modifying the library for their own special needs. |
1035 | * It should NOT be accessed directly by an application, except to store |
1036 | * the jmp_buf. |
1037 | */ |
1038 | |
1039 | struct png_struct_def |
1040 | { |
1041 | #ifdef PNG_SETJMP_SUPPORTED |
1042 | jmp_buf jmpbuf; /* used in png_error */ |
1043 | #endif |
1044 | png_error_ptr error_fn PNG_DEPSTRUCT; /* function for printing errors and aborting */ |
1045 | png_error_ptr warning_fn PNG_DEPSTRUCT; /* function for printing warnings */ |
1046 | png_voidp error_ptr PNG_DEPSTRUCT; /* user supplied struct for error functions */ |
1047 | png_rw_ptr write_data_fn PNG_DEPSTRUCT; /* function for writing output data */ |
1048 | png_rw_ptr read_data_fn PNG_DEPSTRUCT; /* function for reading input data */ |
1049 | png_voidp io_ptr PNG_DEPSTRUCT; /* ptr to application struct for I/O functions */ |
1050 | |
1051 | #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED |
1052 | png_user_transform_ptr read_user_transform_fn PNG_DEPSTRUCT; /* user read transform */ |
1053 | #endif |
1054 | |
1055 | #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED |
1056 | png_user_transform_ptr write_user_transform_fn PNG_DEPSTRUCT; /* user write transform */ |
1057 | #endif |
1058 | |
1059 | /* These were added in libpng-1.0.2 */ |
1060 | #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED |
1061 | #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
1062 | defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
1063 | png_voidp user_transform_ptr PNG_DEPSTRUCT; /* user supplied struct for user transform */ |
1064 | png_byte user_transform_depth PNG_DEPSTRUCT; /* bit depth of user transformed pixels */ |
1065 | png_byte user_transform_channels PNG_DEPSTRUCT; /* channels in user transformed pixels */ |
1066 | #endif |
1067 | #endif |
1068 | |
1069 | png_uint_32 mode PNG_DEPSTRUCT; /* tells us where we are in the PNG file */ |
1070 | png_uint_32 flags PNG_DEPSTRUCT; /* flags indicating various things to libpng */ |
1071 | png_uint_32 transformations PNG_DEPSTRUCT; /* which transformations to perform */ |
1072 | |
1073 | z_stream zstream PNG_DEPSTRUCT; /* pointer to decompression structure (below) */ |
1074 | png_bytep zbuf PNG_DEPSTRUCT; /* buffer for zlib */ |
1075 | png_size_t zbuf_size PNG_DEPSTRUCT; /* size of zbuf */ |
1076 | int zlib_level PNG_DEPSTRUCT; /* holds zlib compression level */ |
1077 | int zlib_method PNG_DEPSTRUCT; /* holds zlib compression method */ |
1078 | int zlib_window_bits PNG_DEPSTRUCT; /* holds zlib compression window bits */ |
1079 | int zlib_mem_level PNG_DEPSTRUCT; /* holds zlib compression memory level */ |
1080 | int zlib_strategy PNG_DEPSTRUCT; /* holds zlib compression strategy */ |
1081 | |
1082 | png_uint_32 width PNG_DEPSTRUCT; /* width of image in pixels */ |
1083 | png_uint_32 height PNG_DEPSTRUCT; /* height of image in pixels */ |
1084 | png_uint_32 num_rows PNG_DEPSTRUCT; /* number of rows in current pass */ |
1085 | png_uint_32 usr_width PNG_DEPSTRUCT; /* width of row at start of write */ |
1086 | png_uint_32 rowbytes PNG_DEPSTRUCT; /* size of row in bytes */ |
1087 | #if 0 /* Replaced with the following in libpng-1.2.43 */ |
1088 | png_size_t irowbytes PNG_DEPSTRUCT; |
1089 | #endif |
1090 | /* Added in libpng-1.2.43 */ |
1091 | #ifdef PNG_USER_LIMITS_SUPPORTED |
1092 | /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown |
1093 | * chunks that can be stored (0 means unlimited). |
1094 | */ |
1095 | png_uint_32 user_chunk_cache_max PNG_DEPSTRUCT; |
1096 | #endif |
1097 | png_uint_32 iwidth PNG_DEPSTRUCT; /* width of current interlaced row in pixels */ |
1098 | png_uint_32 row_number PNG_DEPSTRUCT; /* current row in interlace pass */ |
1099 | png_bytep prev_row PNG_DEPSTRUCT; /* buffer to save previous (unfiltered) row */ |
1100 | png_bytep row_buf PNG_DEPSTRUCT; /* buffer to save current (unfiltered) row */ |
1101 | #ifndef PNG_NO_WRITE_FILTER |
1102 | png_bytep sub_row PNG_DEPSTRUCT; /* buffer to save "sub" row when filtering */ |
1103 | png_bytep up_row PNG_DEPSTRUCT; /* buffer to save "up" row when filtering */ |
1104 | png_bytep avg_row PNG_DEPSTRUCT; /* buffer to save "avg" row when filtering */ |
1105 | png_bytep paeth_row PNG_DEPSTRUCT; /* buffer to save "Paeth" row when filtering */ |
1106 | #endif |
1107 | png_row_info row_info PNG_DEPSTRUCT; /* used for transformation routines */ |
1108 | |
1109 | png_uint_32 idat_size PNG_DEPSTRUCT; /* current IDAT size for read */ |
1110 | png_uint_32 crc PNG_DEPSTRUCT; /* current chunk CRC value */ |
1111 | png_colorp palette PNG_DEPSTRUCT; /* palette from the input file */ |
1112 | png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in palette */ |
1113 | png_uint_16 num_trans PNG_DEPSTRUCT; /* number of transparency values */ |
1114 | png_byte chunk_name[5] PNG_DEPSTRUCT; /* null-terminated name of current chunk */ |
1115 | png_byte compression PNG_DEPSTRUCT; /* file compression type (always 0) */ |
1116 | png_byte filter PNG_DEPSTRUCT; /* file filter type (always 0) */ |
1117 | png_byte interlaced PNG_DEPSTRUCT; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ |
1118 | png_byte pass PNG_DEPSTRUCT; /* current interlace pass (0 - 6) */ |
1119 | png_byte do_filter PNG_DEPSTRUCT; /* row filter flags (see PNG_FILTER_ below ) */ |
1120 | png_byte color_type PNG_DEPSTRUCT; /* color type of file */ |
1121 | png_byte bit_depth PNG_DEPSTRUCT; /* bit depth of file */ |
1122 | png_byte usr_bit_depth PNG_DEPSTRUCT; /* bit depth of users row */ |
1123 | png_byte pixel_depth PNG_DEPSTRUCT; /* number of bits per pixel */ |
1124 | png_byte channels PNG_DEPSTRUCT; /* number of channels in file */ |
1125 | png_byte usr_channels PNG_DEPSTRUCT; /* channels at start of write */ |
1126 | png_byte sig_bytes PNG_DEPSTRUCT; /* magic bytes read/written from start of file */ |
1127 | |
1128 | #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
1129 | #ifdef PNG_LEGACY_SUPPORTED |
1130 | png_byte filler PNG_DEPSTRUCT; /* filler byte for pixel expansion */ |
1131 | #else |
1132 | png_uint_16 filler PNG_DEPSTRUCT; /* filler bytes for pixel expansion */ |
1133 | #endif |
1134 | #endif |
1135 | |
1136 | #ifdef PNG_bKGD_SUPPORTED |
1137 | png_byte background_gamma_type PNG_DEPSTRUCT; |
1138 | # ifdef PNG_FLOATING_POINT_SUPPORTED |
1139 | float background_gamma PNG_DEPSTRUCT; |
1140 | # endif |
1141 | png_color_16 background PNG_DEPSTRUCT; /* background color in screen gamma space */ |
1142 | #ifdef PNG_READ_GAMMA_SUPPORTED |
1143 | png_color_16 background_1 PNG_DEPSTRUCT; /* background normalized to gamma 1.0 */ |
1144 | #endif |
1145 | #endif /* PNG_bKGD_SUPPORTED */ |
1146 | |
1147 | #ifdef PNG_WRITE_FLUSH_SUPPORTED |
1148 | png_flush_ptr output_flush_fn PNG_DEPSTRUCT; /* Function for flushing output */ |
1149 | png_uint_32 flush_dist PNG_DEPSTRUCT; /* how many rows apart to flush, 0 - no flush */ |
1150 | png_uint_32 flush_rows PNG_DEPSTRUCT; /* number of rows written since last flush */ |
1151 | #endif |
1152 | |
1153 | #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
1154 | int gamma_shift PNG_DEPSTRUCT; /* number of "insignificant" bits 16-bit gamma */ |
1155 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
1156 | float gamma PNG_DEPSTRUCT; /* file gamma value */ |
1157 | float screen_gamma PNG_DEPSTRUCT; /* screen gamma value (display_exponent) */ |
1158 | #endif |
1159 | #endif |
1160 | |
1161 | #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
1162 | png_bytep gamma_table PNG_DEPSTRUCT; /* gamma table for 8-bit depth files */ |
1163 | png_bytep gamma_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to screen */ |
1164 | png_bytep gamma_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */ |
1165 | png_uint_16pp gamma_16_table PNG_DEPSTRUCT; /* gamma table for 16-bit depth files */ |
1166 | png_uint_16pp gamma_16_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to screen */ |
1167 | png_uint_16pp gamma_16_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */ |
1168 | #endif |
1169 | |
1170 | #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) |
1171 | png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in each available channel */ |
1172 | #endif |
1173 | |
1174 | #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
1175 | png_color_8 shift PNG_DEPSTRUCT; /* shift for significant bit tranformation */ |
1176 | #endif |
1177 | |
1178 | #if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ |
1179 | || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
1180 | png_bytep trans PNG_DEPSTRUCT; /* transparency values for paletted files */ |
1181 | png_color_16 trans_values PNG_DEPSTRUCT; /* transparency values for non-paletted files */ |
1182 | #endif |
1183 | |
1184 | png_read_status_ptr read_row_fn PNG_DEPSTRUCT; /* called after each row is decoded */ |
1185 | png_write_status_ptr write_row_fn PNG_DEPSTRUCT; /* called after each row is encoded */ |
1186 | #ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
1187 | png_progressive_info_ptr info_fn PNG_DEPSTRUCT; /* called after header data fully read */ |
1188 | png_progressive_row_ptr row_fn PNG_DEPSTRUCT; /* called after each prog. row is decoded */ |
1189 | png_progressive_end_ptr end_fn PNG_DEPSTRUCT; /* called after image is complete */ |
1190 | png_bytep save_buffer_ptr PNG_DEPSTRUCT; /* current location in save_buffer */ |
1191 | png_bytep save_buffer PNG_DEPSTRUCT; /* buffer for previously read data */ |
1192 | png_bytep current_buffer_ptr PNG_DEPSTRUCT; /* current location in current_buffer */ |
1193 | png_bytep current_buffer PNG_DEPSTRUCT; /* buffer for recently used data */ |
1194 | png_uint_32 push_length PNG_DEPSTRUCT; /* size of current input chunk */ |
1195 | png_uint_32 skip_length PNG_DEPSTRUCT; /* bytes to skip in input data */ |
1196 | png_size_t save_buffer_size PNG_DEPSTRUCT; /* amount of data now in save_buffer */ |
1197 | png_size_t save_buffer_max PNG_DEPSTRUCT; /* total size of save_buffer */ |
1198 | png_size_t buffer_size PNG_DEPSTRUCT; /* total amount of available input data */ |
1199 | png_size_t current_buffer_size PNG_DEPSTRUCT; /* amount of data now in current_buffer */ |
1200 | int process_mode PNG_DEPSTRUCT; /* what push library is currently doing */ |
1201 | int cur_palette PNG_DEPSTRUCT; /* current push library palette index */ |
1202 | |
1203 | # ifdef PNG_TEXT_SUPPORTED |
1204 | png_size_t current_text_size PNG_DEPSTRUCT; /* current size of text input data */ |
1205 | png_size_t current_text_left PNG_DEPSTRUCT; /* how much text left to read in input */ |
1206 | png_charp current_text PNG_DEPSTRUCT; /* current text chunk buffer */ |
1207 | png_charp current_text_ptr PNG_DEPSTRUCT; /* current location in current_text */ |
1208 | # endif /* PNG_TEXT_SUPPORTED */ |
1209 | #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
1210 | |
1211 | #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) |
1212 | /* for the Borland special 64K segment handler */ |
1213 | png_bytepp offset_table_ptr PNG_DEPSTRUCT; |
1214 | png_bytep offset_table PNG_DEPSTRUCT; |
1215 | png_uint_16 offset_table_number PNG_DEPSTRUCT; |
1216 | png_uint_16 offset_table_count PNG_DEPSTRUCT; |
1217 | png_uint_16 offset_table_count_free PNG_DEPSTRUCT; |
1218 | #endif |
1219 | |
1220 | #ifdef PNG_READ_DITHER_SUPPORTED |
1221 | png_bytep palette_lookup PNG_DEPSTRUCT; /* lookup table for dithering */ |
1222 | png_bytep dither_index PNG_DEPSTRUCT; /* index translation for palette files */ |
1223 | #endif |
1224 | |
1225 | #if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) |
1226 | png_uint_16p hist PNG_DEPSTRUCT; /* histogram */ |
1227 | #endif |
1228 | |
1229 | #ifdef PNG_TIME_RFC1123_SUPPORTED |
1230 | png_charp time_buffer PNG_DEPSTRUCT; /* String to hold RFC 1123 time text */ |
1231 | #endif |
1232 | |
1233 | /* New members added in libpng-1.0.6 */ |
1234 | |
1235 | #ifdef PNG_FREE_ME_SUPPORTED |
1236 | png_uint_32 free_me PNG_DEPSTRUCT; /* flags items libpng is responsible for freeing */ |
1237 | #endif |
1238 | |
1239 | #ifdef PNG_USER_CHUNKS_SUPPORTED |
1240 | png_voidp user_chunk_ptr PNG_DEPSTRUCT; |
1241 | png_user_chunk_ptr read_user_chunk_fn PNG_DEPSTRUCT; /* user read chunk handler */ |
1242 | #endif |
1243 | |
1244 | #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
1245 | int num_chunk_list PNG_DEPSTRUCT; |
1246 | png_bytep chunk_list PNG_DEPSTRUCT; |
1247 | #endif |
1248 | |
1249 | /* New members added in libpng-1.0.3 */ |
1250 | #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
1251 | png_byte rgb_to_gray_status PNG_DEPSTRUCT; |
1252 | /* These were changed from png_byte in libpng-1.0.6 */ |
1253 | png_uint_16 rgb_to_gray_red_coeff PNG_DEPSTRUCT; |
1254 | png_uint_16 rgb_to_gray_green_coeff PNG_DEPSTRUCT; |
1255 | png_uint_16 rgb_to_gray_blue_coeff PNG_DEPSTRUCT; |
1256 | #endif |
1257 | |
1258 | /* New member added in libpng-1.0.4 (renamed in 1.0.9) */ |
1259 | #if defined(PNG_MNG_FEATURES_SUPPORTED) || \ |
1260 | defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ |
1261 | defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) |
1262 | /* Changed from png_byte to png_uint_32 at version 1.2.0 */ |
1263 | #ifdef PNG_1_0_X |
1264 | png_byte mng_features_permitted PNG_DEPSTRUCT; |
1265 | #else |
1266 | png_uint_32 mng_features_permitted PNG_DEPSTRUCT; |
1267 | #endif /* PNG_1_0_X */ |
1268 | #endif |
1269 | |
1270 | /* New member added in libpng-1.0.7 */ |
1271 | #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
1272 | png_fixed_point int_gamma PNG_DEPSTRUCT; |
1273 | #endif |
1274 | |
1275 | /* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ |
1276 | #ifdef PNG_MNG_FEATURES_SUPPORTED |
1277 | png_byte filter_type PNG_DEPSTRUCT; |
1278 | #endif |
1279 | |
1280 | #ifdef PNG_1_0_X |
1281 | /* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ |
1282 | png_uint_32 row_buf_size PNG_DEPSTRUCT; |
1283 | #endif |
1284 | |
1285 | /* New members added in libpng-1.2.0 */ |
1286 | #ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
1287 | # ifndef PNG_1_0_X |
1288 | # ifdef PNG_MMX_CODE_SUPPORTED |
1289 | png_byte mmx_bitdepth_threshold PNG_DEPSTRUCT; |
1290 | png_uint_32 mmx_rowbytes_threshold PNG_DEPSTRUCT; |
1291 | # endif |
1292 | png_uint_32 asm_flags PNG_DEPSTRUCT; |
1293 | # endif |
1294 | #endif |
1295 | |
1296 | /* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ |
1297 | #ifdef PNG_USER_MEM_SUPPORTED |
1298 | png_voidp mem_ptr PNG_DEPSTRUCT; /* user supplied struct for mem functions */ |
1299 | png_malloc_ptr malloc_fn PNG_DEPSTRUCT; /* function for allocating memory */ |
1300 | png_free_ptr free_fn PNG_DEPSTRUCT; /* function for freeing memory */ |
1301 | #endif |
1302 | |
1303 | /* New member added in libpng-1.0.13 and 1.2.0 */ |
1304 | png_bytep big_row_buf PNG_DEPSTRUCT; /* buffer to save current (unfiltered) row */ |
1305 | |
1306 | #ifdef PNG_READ_DITHER_SUPPORTED |
1307 | /* The following three members were added at version 1.0.14 and 1.2.4 */ |
1308 | png_bytep dither_sort PNG_DEPSTRUCT; /* working sort array */ |
1309 | png_bytep index_to_palette PNG_DEPSTRUCT; /* where the original index currently is */ |
1310 | /* in the palette */ |
1311 | png_bytep palette_to_index PNG_DEPSTRUCT; /* which original index points to this */ |
1312 | /* palette color */ |
1313 | #endif |
1314 | |
1315 | /* New members added in libpng-1.0.16 and 1.2.6 */ |
1316 | png_byte compression_type PNG_DEPSTRUCT; |
1317 | |
1318 | #ifdef PNG_USER_LIMITS_SUPPORTED |
1319 | png_uint_32 user_width_max PNG_DEPSTRUCT; |
1320 | png_uint_32 user_height_max PNG_DEPSTRUCT; |
1321 | #endif |
1322 | |
1323 | /* New member added in libpng-1.0.25 and 1.2.17 */ |
1324 | #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
1325 | /* Storage for unknown chunk that the library doesn't recognize. */ |
1326 | png_unknown_chunk unknown_chunk PNG_DEPSTRUCT; |
1327 | #endif |
1328 | |
1329 | /* New members added in libpng-1.2.26 */ |
1330 | png_uint_32 old_big_row_buf_size PNG_DEPSTRUCT; |
1331 | png_uint_32 old_prev_row_size PNG_DEPSTRUCT; |
1332 | |
1333 | /* New member added in libpng-1.2.30 */ |
1334 | png_charp chunkdata PNG_DEPSTRUCT; /* buffer for reading chunk data */ |
1335 | |
1336 | |
1337 | }; |
1338 | |
1339 | |
1340 | /* This triggers a compiler error in png.c, if png.c and png.h |
1341 | * do not agree upon the version number. |
1342 | */ |
1343 | typedef png_structp version_1_2_54; |
1344 | |
1345 | typedef png_struct FAR * FAR * png_structpp; |
1346 | |
1347 | /* Here are the function definitions most commonly used. This is not |
1348 | * the place to find out how to use libpng. See libpng.txt for the |
1349 | * full explanation, see example.c for the summary. This just provides |
1350 | * a simple one line description of the use of each function. |
1351 | */ |
1352 | |
1353 | /* Returns the version number of the library */ |
1354 | extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); |
1355 | |
1356 | /* Tell lib we have already handled the first <num_bytes> magic bytes. |
1357 | * Handling more than 8 bytes from the beginning of the file is an error. |
1358 | */ |
1359 | extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, |
1360 | int num_bytes)); |
1361 | |
1362 | /* Check sig[start] through sig[start + num_to_check - 1] to see if it's a |
1363 | * PNG file. Returns zero if the supplied bytes match the 8-byte PNG |
1364 | * signature, and non-zero otherwise. Having num_to_check == 0 or |
1365 | * start > 7 will always fail (ie return non-zero). |
1366 | */ |
1367 | extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, |
1368 | png_size_t num_to_check)); |
1369 | |
1370 | /* Simple signature checking function. This is the same as calling |
1371 | * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). |
1372 | */ |
1373 | extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)) PNG_DEPRECATED; |
1374 | |
1375 | /* Allocate and initialize png_ptr struct for reading, and any other memory. */ |
1376 | extern PNG_EXPORT(png_structp,png_create_read_struct) |
1377 | PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
1378 | png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED; |
1379 | |
1380 | /* Allocate and initialize png_ptr struct for writing, and any other memory */ |
1381 | extern PNG_EXPORT(png_structp,png_create_write_struct) |
1382 | PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
1383 | png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED; |
1384 | |
1385 | #ifdef PNG_WRITE_SUPPORTED |
1386 | extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) |
1387 | PNGARG((png_structp png_ptr)); |
1388 | #endif |
1389 | |
1390 | #ifdef PNG_WRITE_SUPPORTED |
1391 | extern PNG_EXPORT(void,png_set_compression_buffer_size) |
1392 | PNGARG((png_structp png_ptr, png_uint_32 size)); |
1393 | #endif |
1394 | |
1395 | /* Reset the compression stream */ |
1396 | extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); |
1397 | |
1398 | /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ |
1399 | #ifdef PNG_USER_MEM_SUPPORTED |
1400 | extern PNG_EXPORT(png_structp,png_create_read_struct_2) |
1401 | PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
1402 | png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
1403 | png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED; |
1404 | extern PNG_EXPORT(png_structp,png_create_write_struct_2) |
1405 | PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
1406 | png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
1407 | png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED; |
1408 | #endif |
1409 | |
1410 | /* Write a PNG chunk - size, type, (optional) data, CRC. */ |
1411 | extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, |
1412 | png_bytep chunk_name, png_bytep data, png_size_t length)); |
1413 | |
1414 | /* Write the start of a PNG chunk - length and chunk name. */ |
1415 | extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, |
1416 | png_bytep chunk_name, png_uint_32 length)); |
1417 | |
1418 | /* Write the data of a PNG chunk started with png_write_chunk_start(). */ |
1419 | extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, |
1420 | png_bytep data, png_size_t length)); |
1421 | |
1422 | /* Finish a chunk started with png_write_chunk_start() (includes CRC). */ |
1423 | extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); |
1424 | |
1425 | /* Allocate and initialize the info structure */ |
1426 | extern PNG_EXPORT(png_infop,png_create_info_struct) |
1427 | PNGARG((png_structp png_ptr)) PNG_ALLOCATED; |
1428 | |
1429 | #if defined(PNG_1_0_X) || defined (PNG_1_2_X) |
1430 | /* Initialize the info structure (old interface - DEPRECATED) */ |
1431 | extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)) |
1432 | PNG_DEPRECATED; |
1433 | #undef png_info_init |
1434 | #define png_info_init(info_ptr) png_info_init_3(&info_ptr,\ |
1435 | png_sizeof(png_info)); |
1436 | #endif |
1437 | |
1438 | extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, |
1439 | png_size_t png_info_struct_size)); |
1440 | |
1441 | /* Writes all the PNG information before the image. */ |
1442 | extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, |
1443 | png_infop info_ptr)); |
1444 | extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, |
1445 | png_infop info_ptr)); |
1446 | |
1447 | #ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
1448 | /* Read the information before the actual image data. */ |
1449 | extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, |
1450 | png_infop info_ptr)); |
1451 | #endif |
1452 | |
1453 | #ifdef PNG_TIME_RFC1123_SUPPORTED |
1454 | extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) |
1455 | PNGARG((png_structp png_ptr, png_timep ptime)); |
1456 | #endif |
1457 | |
1458 | #ifdef PNG_CONVERT_tIME_SUPPORTED |
1459 | /* Convert from a struct tm to png_time */ |
1460 | extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, |
1461 | struct tm FAR * ttime)); |
1462 | |
1463 | /* Convert from time_t to png_time. Uses gmtime() */ |
1464 | extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, |
1465 | time_t ttime)); |
1466 | #endif /* PNG_CONVERT_tIME_SUPPORTED */ |
1467 | |
1468 | #ifdef PNG_READ_EXPAND_SUPPORTED |
1469 | /* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ |
1470 | extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); |
1471 | #ifndef PNG_1_0_X |
1472 | extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp |
1473 | png_ptr)); |
1474 | #endif |
1475 | extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); |
1476 | extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); |
1477 | #if defined(PNG_1_0_X) || defined (PNG_1_2_X) |
1478 | /* Deprecated */ |
1479 | extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp |
1480 | png_ptr)) PNG_DEPRECATED; |
1481 | #endif |
1482 | #endif |
1483 | |
1484 | #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
1485 | /* Use blue, green, red order for pixels. */ |
1486 | extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); |
1487 | #endif |
1488 | |
1489 | #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
1490 | /* Expand the grayscale to 24-bit RGB if necessary. */ |
1491 | extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); |
1492 | #endif |
1493 | |
1494 | #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
1495 | /* Reduce RGB to grayscale. */ |
1496 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
1497 | extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, |
1498 | int error_action, double red, double green )); |
1499 | #endif |
1500 | extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, |
1501 | int error_action, png_fixed_point red, png_fixed_point green )); |
1502 | extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp |
1503 | png_ptr)); |
1504 | #endif |
1505 | |
1506 | extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, |
1507 | png_colorp palette)); |
1508 | |
1509 | #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
1510 | extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); |
1511 | #endif |
1512 | |
1513 | #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ |
1514 | defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
1515 | extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); |
1516 | #endif |
1517 | |
1518 | #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ |
1519 | defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
1520 | extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); |
1521 | #endif |
1522 | |
1523 | #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
1524 | /* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ |
1525 | extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, |
1526 | png_uint_32 filler, int flags)); |
1527 | /* The values of the PNG_FILLER_ defines should NOT be changed */ |
1528 | #define PNG_FILLER_BEFORE 0 |
1529 | #define PNG_FILLER_AFTER 1 |
1530 | /* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ |
1531 | #ifndef PNG_1_0_X |
1532 | extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr, |
1533 | png_uint_32 filler, int flags)); |
1534 | #endif |
1535 | #endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ |
1536 | |
1537 | #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
1538 | /* Swap bytes in 16-bit depth files. */ |
1539 | extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); |
1540 | #endif |
1541 | |
1542 | #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) |
1543 | /* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ |
1544 | extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); |
1545 | #endif |
1546 | |
1547 | #if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
1548 | /* Swap packing order of pixels in bytes. */ |
1549 | extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); |
1550 | #endif |
1551 | |
1552 | #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
1553 | /* Converts files to legal bit depths. */ |
1554 | extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, |
1555 | png_color_8p true_bits)); |
1556 | #endif |
1557 | |
1558 | #if defined(PNG_READ_INTERLACING_SUPPORTED) || \ |
1559 | defined(PNG_WRITE_INTERLACING_SUPPORTED) |
1560 | /* Have the code handle the interlacing. Returns the number of passes. */ |
1561 | extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); |
1562 | #endif |
1563 | |
1564 | #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
1565 | /* Invert monochrome files */ |
1566 | extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); |
1567 | #endif |
1568 | |
1569 | #ifdef PNG_READ_BACKGROUND_SUPPORTED |
1570 | /* Handle alpha and tRNS by replacing with a background color. */ |
1571 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
1572 | extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, |
1573 | png_color_16p background_color, int background_gamma_code, |
1574 | int need_expand, double background_gamma)); |
1575 | #endif |
1576 | #define PNG_BACKGROUND_GAMMA_UNKNOWN 0 |
1577 | #define PNG_BACKGROUND_GAMMA_SCREEN 1 |
1578 | #define PNG_BACKGROUND_GAMMA_FILE 2 |
1579 | #define PNG_BACKGROUND_GAMMA_UNIQUE 3 |
1580 | #endif |
1581 | |
1582 | #ifdef PNG_READ_16_TO_8_SUPPORTED |
1583 | /* Strip the second byte of information from a 16-bit depth file. */ |
1584 | extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); |
1585 | #endif |
1586 | |
1587 | #ifdef PNG_READ_DITHER_SUPPORTED |
1588 | /* Turn on dithering, and reduce the palette to the number of colors available. */ |
1589 | extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, |
1590 | png_colorp palette, int num_palette, int maximum_colors, |
1591 | png_uint_16p histogram, int full_dither)); |
1592 | #endif |
1593 | |
1594 | #ifdef PNG_READ_GAMMA_SUPPORTED |
1595 | /* Handle gamma correction. Screen_gamma=(display_exponent) */ |
1596 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
1597 | extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, |
1598 | double screen_gamma, double default_file_gamma)); |
1599 | #endif |
1600 | #endif |
1601 | |
1602 | #if defined(PNG_1_0_X) || defined (PNG_1_2_X) |
1603 | #if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ |
1604 | defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) |
1605 | /* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ |
1606 | /* Deprecated and will be removed. Use png_permit_mng_features() instead. */ |
1607 | extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, |
1608 | int empty_plte_permitted)) PNG_DEPRECATED; |
1609 | #endif |
1610 | #endif |
1611 | |
1612 | #ifdef PNG_WRITE_FLUSH_SUPPORTED |
1613 | /* Set how many lines between output flushes - 0 for no flushing */ |
1614 | extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); |
1615 | /* Flush the current PNG output buffer */ |
1616 | extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); |
1617 | #endif |
1618 | |
1619 | /* Optional update palette with requested transformations */ |
1620 | extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); |
1621 | |
1622 | /* Optional call to update the users info structure */ |
1623 | extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, |
1624 | png_infop info_ptr)); |
1625 | |
1626 | #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED |
1627 | /* Read one or more rows of image data. */ |
1628 | extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, |
1629 | png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); |
1630 | #endif |
1631 | |
1632 | #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED |
1633 | /* Read a row of data. */ |
1634 | extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, |
1635 | png_bytep row, |
1636 | png_bytep display_row)); |
1637 | #endif |
1638 | |
1639 | #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED |
1640 | /* Read the whole image into memory at once. */ |
1641 | extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, |
1642 | png_bytepp image)); |
1643 | #endif |
1644 | |
1645 | /* Write a row of image data */ |
1646 | extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, |
1647 | png_bytep row)); |
1648 | |
1649 | /* Write a few rows of image data */ |
1650 | extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, |
1651 | png_bytepp row, png_uint_32 num_rows)); |
1652 | |
1653 | /* Write the image data */ |
1654 | extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, |
1655 | png_bytepp image)); |
1656 | |
1657 | /* Writes the end of the PNG file. */ |
1658 | extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, |
1659 | png_infop info_ptr)); |
1660 | |
1661 | #ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED |
1662 | /* Read the end of the PNG file. */ |
1663 | extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, |
1664 | png_infop info_ptr)); |
1665 | #endif |
1666 | |
1667 | /* Free any memory associated with the png_info_struct */ |
1668 | extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, |
1669 | png_infopp info_ptr_ptr)); |
1670 | |
1671 | /* Free any memory associated with the png_struct and the png_info_structs */ |
1672 | extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp |
1673 | png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); |
1674 | |
1675 | /* Free all memory used by the read (old method - NOT DLL EXPORTED) */ |
1676 | extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, |
1677 | png_infop end_info_ptr)) PNG_DEPRECATED; |
1678 | |
1679 | /* Free any memory associated with the png_struct and the png_info_structs */ |
1680 | extern PNG_EXPORT(void,png_destroy_write_struct) |
1681 | PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); |
1682 | |
1683 | /* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ |
1684 | extern void png_write_destroy PNGARG((png_structp png_ptr)) PNG_DEPRECATED; |
1685 | |
1686 | /* Set the libpng method of handling chunk CRC errors */ |
1687 | extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, |
1688 | int crit_action, int ancil_action)); |
1689 | |
1690 | /* Values for png_set_crc_action() to say how to handle CRC errors in |
1691 | * ancillary and critical chunks, and whether to use the data contained |
1692 | * therein. Note that it is impossible to "discard" data in a critical |
1693 | * chunk. For versions prior to 0.90, the action was always error/quit, |
1694 | * whereas in version 0.90 and later, the action for CRC errors in ancillary |
1695 | * chunks is warn/discard. These values should NOT be changed. |
1696 | * |
1697 | * value action:critical action:ancillary |
1698 | */ |
1699 | #define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ |
1700 | #define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ |
1701 | #define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ |
1702 | #define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ |
1703 | #define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ |
1704 | #define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ |
1705 | |
1706 | /* These functions give the user control over the scan-line filtering in |
1707 | * libpng and the compression methods used by zlib. These functions are |
1708 | * mainly useful for testing, as the defaults should work with most users. |
1709 | * Those users who are tight on memory or want faster performance at the |
1710 | * expense of compression can modify them. See the compression library |
1711 | * header file (zlib.h) for an explination of the compression functions. |
1712 | */ |
1713 | |
1714 | /* Set the filtering method(s) used by libpng. Currently, the only valid |
1715 | * value for "method" is 0. |
1716 | */ |
1717 | extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, |
1718 | int filters)); |
1719 | |
1720 | /* Flags for png_set_filter() to say which filters to use. The flags |
1721 | * are chosen so that they don't conflict with real filter types |
1722 | * below, in case they are supplied instead of the #defined constants. |
1723 | * These values should NOT be changed. |
1724 | */ |
1725 | #define PNG_NO_FILTERS 0x00 |
1726 | #define PNG_FILTER_NONE 0x08 |
1727 | #define PNG_FILTER_SUB 0x10 |
1728 | #define PNG_FILTER_UP 0x20 |
1729 | #define PNG_FILTER_AVG 0x40 |
1730 | #define PNG_FILTER_PAETH 0x80 |
1731 | #define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ |
1732 | PNG_FILTER_AVG | PNG_FILTER_PAETH) |
1733 | |
1734 | /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. |
1735 | * These defines should NOT be changed. |
1736 | */ |
1737 | #define PNG_FILTER_VALUE_NONE 0 |
1738 | #define PNG_FILTER_VALUE_SUB 1 |
1739 | #define PNG_FILTER_VALUE_UP 2 |
1740 | #define PNG_FILTER_VALUE_AVG 3 |
1741 | #define PNG_FILTER_VALUE_PAETH 4 |
1742 | #define PNG_FILTER_VALUE_LAST 5 |
1743 | |
1744 | #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* DEPRECATED */ |
1745 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
1746 | extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, |
1747 | int heuristic_method, int num_weights, png_doublep filter_weights, |
1748 | png_doublep filter_costs)); |
1749 | #endif |
1750 | #endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ |
1751 | |
1752 | /* The following are no longer used and will be removed from libpng-1.7: */ |
1753 | #define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ |
1754 | #define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ |
1755 | #define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ |
1756 | #define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ |
1757 | |
1758 | /* Set the library compression level. Currently, valid values range from |
1759 | * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 |
1760 | * (0 - no compression, 9 - "maximal" compression). Note that tests have |
1761 | * shown that zlib compression levels 3-6 usually perform as well as level 9 |
1762 | * for PNG images, and do considerably fewer caclulations. In the future, |
1763 | * these values may not correspond directly to the zlib compression levels. |
1764 | */ |
1765 | extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, |
1766 | int level)); |
1767 | |
1768 | extern PNG_EXPORT(void,png_set_compression_mem_level) |
1769 | PNGARG((png_structp png_ptr, int mem_level)); |
1770 | |
1771 | extern PNG_EXPORT(void,png_set_compression_strategy) |
1772 | PNGARG((png_structp png_ptr, int strategy)); |
1773 | |
1774 | extern PNG_EXPORT(void,png_set_compression_window_bits) |
1775 | PNGARG((png_structp png_ptr, int window_bits)); |
1776 | |
1777 | extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, |
1778 | int method)); |
1779 | |
1780 | /* These next functions are called for input/output, memory, and error |
1781 | * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, |
1782 | * and call standard C I/O routines such as fread(), fwrite(), and |
1783 | * fprintf(). These functions can be made to use other I/O routines |
1784 | * at run time for those applications that need to handle I/O in a |
1785 | * different manner by calling png_set_???_fn(). See libpng.txt for |
1786 | * more information. |
1787 | */ |
1788 | |
1789 | #ifdef PNG_STDIO_SUPPORTED |
1790 | /* Initialize the input/output for the PNG file to the default functions. */ |
1791 | extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); |
1792 | #endif |
1793 | |
1794 | /* Replace the (error and abort), and warning functions with user |
1795 | * supplied functions. If no messages are to be printed you must still |
1796 | * write and use replacement functions. The replacement error_fn should |
1797 | * still do a longjmp to the last setjmp location if you are using this |
1798 | * method of error handling. If error_fn or warning_fn is NULL, the |
1799 | * default function will be used. |
1800 | */ |
1801 | |
1802 | extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, |
1803 | png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); |
1804 | |
1805 | /* Return the user pointer associated with the error functions */ |
1806 | extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); |
1807 | |
1808 | /* Replace the default data output functions with a user supplied one(s). |
1809 | * If buffered output is not used, then output_flush_fn can be set to NULL. |
1810 | * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time |
1811 | * output_flush_fn will be ignored (and thus can be NULL). |
1812 | * It is probably a mistake to use NULL for output_flush_fn if |
1813 | * write_data_fn is not also NULL unless you have built libpng with |
1814 | * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's |
1815 | * default flush function, which uses the standard *FILE structure, will |
1816 | * be used. |
1817 | */ |
1818 | extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, |
1819 | png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); |
1820 | |
1821 | /* Replace the default data input function with a user supplied one. */ |
1822 | extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, |
1823 | png_voidp io_ptr, png_rw_ptr read_data_fn)); |
1824 | |
1825 | /* Return the user pointer associated with the I/O functions */ |
1826 | extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); |
1827 | |
1828 | extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, |
1829 | png_read_status_ptr read_row_fn)); |
1830 | |
1831 | extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, |
1832 | png_write_status_ptr write_row_fn)); |
1833 | |
1834 | #ifdef PNG_USER_MEM_SUPPORTED |
1835 | /* Replace the default memory allocation functions with user supplied one(s). */ |
1836 | extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, |
1837 | png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); |
1838 | /* Return the user pointer associated with the memory functions */ |
1839 | extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); |
1840 | #endif |
1841 | |
1842 | #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
1843 | defined(PNG_LEGACY_SUPPORTED) |
1844 | extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp |
1845 | png_ptr, png_user_transform_ptr read_user_transform_fn)); |
1846 | #endif |
1847 | |
1848 | #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
1849 | defined(PNG_LEGACY_SUPPORTED) |
1850 | extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp |
1851 | png_ptr, png_user_transform_ptr write_user_transform_fn)); |
1852 | #endif |
1853 | |
1854 | #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
1855 | defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
1856 | defined(PNG_LEGACY_SUPPORTED) |
1857 | extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp |
1858 | png_ptr, png_voidp user_transform_ptr, int user_transform_depth, |
1859 | int user_transform_channels)); |
1860 | /* Return the user pointer associated with the user transform functions */ |
1861 | extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) |
1862 | PNGARG((png_structp png_ptr)); |
1863 | #endif |
1864 | |
1865 | #ifdef PNG_USER_CHUNKS_SUPPORTED |
1866 | extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, |
1867 | png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); |
1868 | extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp |
1869 | png_ptr)); |
1870 | #endif |
1871 | |
1872 | #ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
1873 | /* Sets the function callbacks for the push reader, and a pointer to a |
1874 | * user-defined structure available to the callback functions. |
1875 | */ |
1876 | extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, |
1877 | png_voidp progressive_ptr, |
1878 | png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, |
1879 | png_progressive_end_ptr end_fn)); |
1880 | |
1881 | /* Returns the user pointer associated with the push read functions */ |
1882 | extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) |
1883 | PNGARG((png_structp png_ptr)); |
1884 | |
1885 | /* Function to be called when data becomes available */ |
1886 | extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, |
1887 | png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); |
1888 | |
1889 | /* Function that combines rows. Not very much different than the |
1890 | * png_combine_row() call. Is this even used????? |
1891 | */ |
1892 | extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, |
1893 | png_bytep old_row, png_bytep new_row)); |
1894 | #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
1895 | |
1896 | extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, |
1897 | png_uint_32 size)) PNG_ALLOCATED; |
1898 | |
1899 | #ifdef PNG_1_0_X |
1900 | # define png_malloc_warn png_malloc |
1901 | #else |
1902 | /* Added at libpng version 1.2.4 */ |
1903 | extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, |
1904 | png_uint_32 size)) PNG_ALLOCATED; |
1905 | #endif |
1906 | |
1907 | /* Frees a pointer allocated by png_malloc() */ |
1908 | extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); |
1909 | |
1910 | #ifdef PNG_1_0_X |
1911 | /* Function to allocate memory for zlib. */ |
1912 | extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, |
1913 | uInt size)); |
1914 | |
1915 | /* Function to free memory for zlib */ |
1916 | extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); |
1917 | #endif |
1918 | |
1919 | /* Free data that was allocated internally */ |
1920 | extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, |
1921 | png_infop info_ptr, png_uint_32 free_me, int num)); |
1922 | #ifdef PNG_FREE_ME_SUPPORTED |
1923 | /* Reassign responsibility for freeing existing data, whether allocated |
1924 | * by libpng or by the application |
1925 | */ |
1926 | extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, |
1927 | png_infop info_ptr, int freer, png_uint_32 mask)); |
1928 | #endif |
1929 | /* Assignments for png_data_freer */ |
1930 | #define PNG_DESTROY_WILL_FREE_DATA 1 |
1931 | #define PNG_SET_WILL_FREE_DATA 1 |
1932 | #define PNG_USER_WILL_FREE_DATA 2 |
1933 | /* Flags for png_ptr->free_me and info_ptr->free_me */ |
1934 | #define PNG_FREE_HIST 0x0008 |
1935 | #define PNG_FREE_ICCP 0x0010 |
1936 | #define PNG_FREE_SPLT 0x0020 |
1937 | #define PNG_FREE_ROWS 0x0040 |
1938 | #define PNG_FREE_PCAL 0x0080 |
1939 | #define PNG_FREE_SCAL 0x0100 |
1940 | #define PNG_FREE_UNKN 0x0200 |
1941 | #define PNG_FREE_LIST 0x0400 |
1942 | #define PNG_FREE_PLTE 0x1000 |
1943 | #define PNG_FREE_TRNS 0x2000 |
1944 | #define PNG_FREE_TEXT 0x4000 |
1945 | #define PNG_FREE_ALL 0x7fff |
1946 | #define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ |
1947 | |
1948 | #ifdef PNG_USER_MEM_SUPPORTED |
1949 | extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, |
1950 | png_uint_32 size)) PNG_ALLOCATED; |
1951 | extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, |
1952 | png_voidp ptr)); |
1953 | #endif |
1954 | |
1955 | extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, |
1956 | png_voidp s1, png_voidp s2, png_uint_32 size)) PNG_DEPRECATED; |
1957 | |
1958 | extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, |
1959 | png_voidp s1, int value, png_uint_32 size)) PNG_DEPRECATED; |
1960 | |
1961 | #if defined(USE_FAR_KEYWORD) /* memory model conversion function */ |
1962 | extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, |
1963 | int check)); |
1964 | #endif /* USE_FAR_KEYWORD */ |
1965 | |
1966 | #ifndef PNG_NO_ERROR_TEXT |
1967 | /* Fatal error in PNG image of libpng - can't continue */ |
1968 | extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, |
1969 | png_const_charp error_message)) PNG_NORETURN; |
1970 | |
1971 | /* The same, but the chunk name is prepended to the error string. */ |
1972 | extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, |
1973 | png_const_charp error_message)) PNG_NORETURN; |
1974 | #else |
1975 | /* Fatal error in PNG image of libpng - can't continue */ |
1976 | extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr)) PNG_NORETURN; |
1977 | #endif |
1978 | |
1979 | #ifndef PNG_NO_WARNINGS |
1980 | /* Non-fatal error in libpng. Can continue, but may have a problem. */ |
1981 | extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, |
1982 | png_const_charp warning_message)); |
1983 | |
1984 | #ifdef PNG_READ_SUPPORTED |
1985 | /* Non-fatal error in libpng, chunk name is prepended to message. */ |
1986 | extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, |
1987 | png_const_charp warning_message)); |
1988 | #endif /* PNG_READ_SUPPORTED */ |
1989 | #endif /* PNG_NO_WARNINGS */ |
1990 | |
1991 | /* The png_set_<chunk> functions are for storing values in the png_info_struct. |
1992 | * Similarly, the png_get_<chunk> calls are used to read values from the |
1993 | * png_info_struct, either storing the parameters in the passed variables, or |
1994 | * setting pointers into the png_info_struct where the data is stored. The |
1995 | * png_get_<chunk> functions return a non-zero value if the data was available |
1996 | * in info_ptr, or return zero and do not change any of the parameters if the |
1997 | * data was not available. |
1998 | * |
1999 | * These functions should be used instead of directly accessing png_info |
2000 | * to avoid problems with future changes in the size and internal layout of |
2001 | * png_info_struct. |
2002 | */ |
2003 | /* Returns "flag" if chunk data is valid in info_ptr. */ |
2004 | extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, |
2005 | png_infop info_ptr, png_uint_32 flag)); |
2006 | |
2007 | /* Returns number of bytes needed to hold a transformed row. */ |
2008 | extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, |
2009 | png_infop info_ptr)); |
2010 | |
2011 | #ifdef PNG_INFO_IMAGE_SUPPORTED |
2012 | /* Returns row_pointers, which is an array of pointers to scanlines that was |
2013 | * returned from png_read_png(). |
2014 | */ |
2015 | extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, |
2016 | png_infop info_ptr)); |
2017 | /* Set row_pointers, which is an array of pointers to scanlines for use |
2018 | * by png_write_png(). |
2019 | */ |
2020 | extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, |
2021 | png_infop info_ptr, png_bytepp row_pointers)); |
2022 | #endif |
2023 | |
2024 | /* Returns number of color channels in image. */ |
2025 | extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, |
2026 | png_infop info_ptr)); |
2027 | |
2028 | #ifdef PNG_EASY_ACCESS_SUPPORTED |
2029 | /* Returns image width in pixels. */ |
2030 | extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp |
2031 | png_ptr, png_infop info_ptr)); |
2032 | |
2033 | /* Returns image height in pixels. */ |
2034 | extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp |
2035 | png_ptr, png_infop info_ptr)); |
2036 | |
2037 | /* Returns image bit_depth. */ |
2038 | extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp |
2039 | png_ptr, png_infop info_ptr)); |
2040 | |
2041 | /* Returns image color_type. */ |
2042 | extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp |
2043 | png_ptr, png_infop info_ptr)); |
2044 | |
2045 | /* Returns image filter_type. */ |
2046 | extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp |
2047 | png_ptr, png_infop info_ptr)); |
2048 | |
2049 | /* Returns image interlace_type. */ |
2050 | extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp |
2051 | png_ptr, png_infop info_ptr)); |
2052 | |
2053 | /* Returns image compression_type. */ |
2054 | extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp |
2055 | png_ptr, png_infop info_ptr)); |
2056 | |
2057 | /* Returns image resolution in pixels per meter, from pHYs chunk data. */ |
2058 | extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp |
2059 | png_ptr, png_infop info_ptr)); |
2060 | extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp |
2061 | png_ptr, png_infop info_ptr)); |
2062 | extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp |
2063 | png_ptr, png_infop info_ptr)); |
2064 | |
2065 | /* Returns pixel aspect ratio, computed from pHYs chunk data. */ |
2066 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
2067 | extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp |
2068 | png_ptr, png_infop info_ptr)); |
2069 | #endif |
2070 | |
2071 | /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ |
2072 | extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp |
2073 | png_ptr, png_infop info_ptr)); |
2074 | extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp |
2075 | png_ptr, png_infop info_ptr)); |
2076 | extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp |
2077 | png_ptr, png_infop info_ptr)); |
2078 | extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp |
2079 | png_ptr, png_infop info_ptr)); |
2080 | |
2081 | #endif /* PNG_EASY_ACCESS_SUPPORTED */ |
2082 | |
2083 | /* Returns pointer to signature string read from PNG header */ |
2084 | extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, |
2085 | png_infop info_ptr)); |
2086 | |
2087 | #ifdef PNG_bKGD_SUPPORTED |
2088 | extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, |
2089 | png_infop info_ptr, png_color_16p *background)); |
2090 | #endif |
2091 | |
2092 | #ifdef PNG_bKGD_SUPPORTED |
2093 | extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, |
2094 | png_infop info_ptr, png_color_16p background)); |
2095 | #endif |
2096 | |
2097 | #ifdef PNG_cHRM_SUPPORTED |
2098 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
2099 | extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, |
2100 | png_infop info_ptr, double *white_x, double *white_y, double *red_x, |
2101 | double *red_y, double *green_x, double *green_y, double *blue_x, |
2102 | double *blue_y)); |
2103 | #endif |
2104 | #ifdef PNG_FIXED_POINT_SUPPORTED |
2105 | extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, |
2106 | png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point |
2107 | *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, |
2108 | png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point |
2109 | *int_blue_x, png_fixed_point *int_blue_y)); |
2110 | #endif |
2111 | #endif |
2112 | |
2113 | #ifdef PNG_cHRM_SUPPORTED |
2114 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
2115 | extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, |
2116 | png_infop info_ptr, double white_x, double white_y, double red_x, |
2117 | double red_y, double green_x, double green_y, double blue_x, double blue_y)); |
2118 | #endif |
2119 | #ifdef PNG_FIXED_POINT_SUPPORTED |
2120 | extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, |
2121 | png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, |
2122 | png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point |
2123 | int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, |
2124 | png_fixed_point int_blue_y)); |
2125 | #endif |
2126 | #endif |
2127 | |
2128 | #ifdef PNG_gAMA_SUPPORTED |
2129 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
2130 | extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, |
2131 | png_infop info_ptr, double *file_gamma)); |
2132 | #endif |
2133 | extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, |
2134 | png_infop info_ptr, png_fixed_point *int_file_gamma)); |
2135 | #endif |
2136 | |
2137 | #ifdef PNG_gAMA_SUPPORTED |
2138 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
2139 | extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, |
2140 | png_infop info_ptr, double file_gamma)); |
2141 | #endif |
2142 | extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, |
2143 | png_infop info_ptr, png_fixed_point int_file_gamma)); |
2144 | #endif |
2145 | |
2146 | #ifdef PNG_hIST_SUPPORTED |
2147 | extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, |
2148 | png_infop info_ptr, png_uint_16p *hist)); |
2149 | #endif |
2150 | |
2151 | #ifdef PNG_hIST_SUPPORTED |
2152 | extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, |
2153 | png_infop info_ptr, png_uint_16p hist)); |
2154 | #endif |
2155 | |
2156 | extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, |
2157 | png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, |
2158 | int *bit_depth, int *color_type, int *interlace_method, |
2159 | int *compression_method, int *filter_method)); |
2160 | |
2161 | extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, |
2162 | png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, |
2163 | int color_type, int interlace_method, int compression_method, |
2164 | int filter_method)); |
2165 | |
2166 | #ifdef PNG_oFFs_SUPPORTED |
2167 | extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, |
2168 | png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, |
2169 | int *unit_type)); |
2170 | #endif |
2171 | |
2172 | #ifdef PNG_oFFs_SUPPORTED |
2173 | extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, |
2174 | png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, |
2175 | int unit_type)); |
2176 | #endif |
2177 | |
2178 | #ifdef PNG_pCAL_SUPPORTED |
2179 | extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, |
2180 | png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, |
2181 | int *type, int *nparams, png_charp *units, png_charpp *params)); |
2182 | #endif |
2183 | |
2184 | #ifdef PNG_pCAL_SUPPORTED |
2185 | extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, |
2186 | png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, |
2187 | int type, int nparams, png_charp units, png_charpp params)); |
2188 | #endif |
2189 | |
2190 | #ifdef PNG_pHYs_SUPPORTED |
2191 | extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, |
2192 | png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); |
2193 | #endif |
2194 | |
2195 | #ifdef PNG_pHYs_SUPPORTED |
2196 | extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, |
2197 | png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); |
2198 | #endif |
2199 | |
2200 | extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, |
2201 | png_infop info_ptr, png_colorp *palette, int *num_palette)); |
2202 | |
2203 | extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, |
2204 | png_infop info_ptr, png_colorp palette, int num_palette)); |
2205 | |
2206 | #ifdef PNG_sBIT_SUPPORTED |
2207 | extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, |
2208 | png_infop info_ptr, png_color_8p *sig_bit)); |
2209 | #endif |
2210 | |
2211 | #ifdef PNG_sBIT_SUPPORTED |
2212 | extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, |
2213 | png_infop info_ptr, png_color_8p sig_bit)); |
2214 | #endif |
2215 | |
2216 | #ifdef PNG_sRGB_SUPPORTED |
2217 | extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, |
2218 | png_infop info_ptr, int *intent)); |
2219 | #endif |
2220 | |
2221 | #ifdef PNG_sRGB_SUPPORTED |
2222 | extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, |
2223 | png_infop info_ptr, int intent)); |
2224 | extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, |
2225 | png_infop info_ptr, int intent)); |
2226 | #endif |
2227 | |
2228 | #ifdef PNG_iCCP_SUPPORTED |
2229 | extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, |
2230 | png_infop info_ptr, png_charpp name, int *compression_type, |
2231 | png_charpp profile, png_uint_32 *proflen)); |
2232 | /* Note to maintainer: profile should be png_bytepp */ |
2233 | #endif |
2234 | |
2235 | #ifdef PNG_iCCP_SUPPORTED |
2236 | extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, |
2237 | png_infop info_ptr, png_charp name, int compression_type, |
2238 | png_charp profile, png_uint_32 proflen)); |
2239 | /* Note to maintainer: profile should be png_bytep */ |
2240 | #endif |
2241 | |
2242 | #ifdef PNG_sPLT_SUPPORTED |
2243 | extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, |
2244 | png_infop info_ptr, png_sPLT_tpp entries)); |
2245 | #endif |
2246 | |
2247 | #ifdef PNG_sPLT_SUPPORTED |
2248 | extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, |
2249 | png_infop info_ptr, png_sPLT_tp entries, int nentries)); |
2250 | #endif |
2251 | |
2252 | #ifdef PNG_TEXT_SUPPORTED |
2253 | /* png_get_text also returns the number of text chunks in *num_text */ |
2254 | extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, |
2255 | png_infop info_ptr, png_textp *text_ptr, int *num_text)); |
2256 | #endif |
2257 | |
2258 | /* |
2259 | * Note while png_set_text() will accept a structure whose text, |
2260 | * language, and translated keywords are NULL pointers, the structure |
2261 | * returned by png_get_text will always contain regular |
2262 | * zero-terminated C strings. They might be empty strings but |
2263 | * they will never be NULL pointers. |
2264 | */ |
2265 | |
2266 | #ifdef PNG_TEXT_SUPPORTED |
2267 | extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, |
2268 | png_infop info_ptr, png_textp text_ptr, int num_text)); |
2269 | #endif |
2270 | |
2271 | #ifdef PNG_tIME_SUPPORTED |
2272 | extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, |
2273 | png_infop info_ptr, png_timep *mod_time)); |
2274 | #endif |
2275 | |
2276 | #ifdef PNG_tIME_SUPPORTED |
2277 | extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, |
2278 | png_infop info_ptr, png_timep mod_time)); |
2279 | #endif |
2280 | |
2281 | #ifdef PNG_tRNS_SUPPORTED |
2282 | extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, |
2283 | png_infop info_ptr, png_bytep *trans, int *num_trans, |
2284 | png_color_16p *trans_values)); |
2285 | #endif |
2286 | |
2287 | #ifdef PNG_tRNS_SUPPORTED |
2288 | extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, |
2289 | png_infop info_ptr, png_bytep trans, int num_trans, |
2290 | png_color_16p trans_values)); |
2291 | #endif |
2292 | |
2293 | #ifdef PNG_tRNS_SUPPORTED |
2294 | #endif |
2295 | |
2296 | #ifdef PNG_sCAL_SUPPORTED |
2297 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
2298 | extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, |
2299 | png_infop info_ptr, int *unit, double *width, double *height)); |
2300 | #else |
2301 | #ifdef PNG_FIXED_POINT_SUPPORTED |
2302 | extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, |
2303 | png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); |
2304 | #endif |
2305 | #endif |
2306 | #endif /* PNG_sCAL_SUPPORTED */ |
2307 | |
2308 | #ifdef PNG_sCAL_SUPPORTED |
2309 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
2310 | extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, |
2311 | png_infop info_ptr, int unit, double width, double height)); |
2312 | #else |
2313 | #ifdef PNG_FIXED_POINT_SUPPORTED |
2314 | extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, |
2315 | png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); |
2316 | #endif |
2317 | #endif |
2318 | #endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ |
2319 | |
2320 | #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
2321 | /* Provide a list of chunks and how they are to be handled, if the built-in |
2322 | handling or default unknown chunk handling is not desired. Any chunks not |
2323 | listed will be handled in the default manner. The IHDR and IEND chunks |
2324 | must not be listed. |
2325 | keep = 0: follow default behaviour |
2326 | = 1: do not keep |
2327 | = 2: keep only if safe-to-copy |
2328 | = 3: keep even if unsafe-to-copy |
2329 | */ |
2330 | extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp |
2331 | png_ptr, int keep, png_bytep chunk_list, int num_chunks)); |
2332 | PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep |
2333 | chunk_name)); |
2334 | #endif |
2335 | #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
2336 | extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, |
2337 | png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); |
2338 | extern PNG_EXPORT(void, png_set_unknown_chunk_location) |
2339 | PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); |
2340 | extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp |
2341 | png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); |
2342 | #endif |
2343 | |
2344 | /* Png_free_data() will turn off the "valid" flag for anything it frees. |
2345 | * If you need to turn it off for a chunk that your application has freed, |
2346 | * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); |
2347 | */ |
2348 | extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, |
2349 | png_infop info_ptr, int mask)); |
2350 | |
2351 | #ifdef PNG_INFO_IMAGE_SUPPORTED |
2352 | /* The "params" pointer is currently not used and is for future expansion. */ |
2353 | extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, |
2354 | png_infop info_ptr, |
2355 | int transforms, |
2356 | png_voidp params)); |
2357 | extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, |
2358 | png_infop info_ptr, |
2359 | int transforms, |
2360 | png_voidp params)); |
2361 | #endif |
2362 | |
2363 | /* Define PNG_DEBUG at compile time for debugging information. Higher |
2364 | * numbers for PNG_DEBUG mean more debugging information. This has |
2365 | * only been added since version 0.95 so it is not implemented throughout |
2366 | * libpng yet, but more support will be added as needed. |
2367 | */ |
2368 | #ifdef PNG_DEBUG |
2369 | #if (PNG_DEBUG > 0) |
2370 | #if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) |
2371 | #include <crtdbg.h> |
2372 | #if (PNG_DEBUG > 1) |
2373 | #ifndef _DEBUG |
2374 | # define _DEBUG |
2375 | #endif |
2376 | #ifndef png_debug |
2377 | #define png_debug(l,m) _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE) |
2378 | #endif |
2379 | #ifndef png_debug1 |
2380 | #define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1) |
2381 | #endif |
2382 | #ifndef png_debug2 |
2383 | #define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2) |
2384 | #endif |
2385 | #endif |
2386 | #else /* PNG_DEBUG_FILE || !_MSC_VER */ |
2387 | #ifndef PNG_DEBUG_FILE |
2388 | #define PNG_DEBUG_FILE stderr |
2389 | #endif /* PNG_DEBUG_FILE */ |
2390 | |
2391 | #if (PNG_DEBUG > 1) |
2392 | /* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on non-ISO |
2393 | * compilers. |
2394 | */ |
2395 | # ifdef __STDC__ |
2396 | # ifndef png_debug |
2397 | # define png_debug(l,m) \ |
2398 | { \ |
2399 | int num_tabs=l; \ |
2400 | fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ |
2401 | (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ |
2402 | } |
2403 | # endif |
2404 | # ifndef png_debug1 |
2405 | # define png_debug1(l,m,p1) \ |
2406 | { \ |
2407 | int num_tabs=l; \ |
2408 | fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ |
2409 | (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ |
2410 | } |
2411 | # endif |
2412 | # ifndef png_debug2 |
2413 | # define png_debug2(l,m,p1,p2) \ |
2414 | { \ |
2415 | int num_tabs=l; \ |
2416 | fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ |
2417 | (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ |
2418 | } |
2419 | # endif |
2420 | # else /* __STDC __ */ |
2421 | # ifndef png_debug |
2422 | # define png_debug(l,m) \ |
2423 | { \ |
2424 | int num_tabs=l; \ |
2425 | char format[256]; \ |
2426 | snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ |
2427 | (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ |
2428 | m,PNG_STRING_NEWLINE); \ |
2429 | fprintf(PNG_DEBUG_FILE,format); \ |
2430 | } |
2431 | # endif |
2432 | # ifndef png_debug1 |
2433 | # define png_debug1(l,m,p1) \ |
2434 | { \ |
2435 | int num_tabs=l; \ |
2436 | char format[256]; \ |
2437 | snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ |
2438 | (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ |
2439 | m,PNG_STRING_NEWLINE); \ |
2440 | fprintf(PNG_DEBUG_FILE,format,p1); \ |
2441 | } |
2442 | # endif |
2443 | # ifndef png_debug2 |
2444 | # define png_debug2(l,m,p1,p2) \ |
2445 | { \ |
2446 | int num_tabs=l; \ |
2447 | char format[256]; \ |
2448 | snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ |
2449 | (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ |
2450 | m,PNG_STRING_NEWLINE); \ |
2451 | fprintf(PNG_DEBUG_FILE,format,p1,p2); \ |
2452 | } |
2453 | # endif |
2454 | # endif /* __STDC __ */ |
2455 | #endif /* (PNG_DEBUG > 1) */ |
2456 | |
2457 | #endif /* _MSC_VER */ |
2458 | #endif /* (PNG_DEBUG > 0) */ |
2459 | #endif /* PNG_DEBUG */ |
2460 | #ifndef png_debug |
2461 | #define png_debug(l, m) |
2462 | #endif |
2463 | #ifndef png_debug1 |
2464 | #define png_debug1(l, m, p1) |
2465 | #endif |
2466 | #ifndef png_debug2 |
2467 | #define png_debug2(l, m, p1, p2) |
2468 | #endif |
2469 | |
2470 | extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); |
2471 | extern PNG_EXPORT(png_charp,) PNGARG((png_structp png_ptr)); |
2472 | extern PNG_EXPORT(png_charp,) PNGARG((png_structp png_ptr)); |
2473 | extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); |
2474 | |
2475 | #ifdef PNG_MNG_FEATURES_SUPPORTED |
2476 | extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp |
2477 | png_ptr, png_uint_32 mng_features_permitted)); |
2478 | #endif |
2479 | |
2480 | /* For use in png_set_keep_unknown, added to version 1.2.6 */ |
2481 | #define PNG_HANDLE_CHUNK_AS_DEFAULT 0 |
2482 | #define PNG_HANDLE_CHUNK_NEVER 1 |
2483 | #define PNG_HANDLE_CHUNK_IF_SAFE 2 |
2484 | #define PNG_HANDLE_CHUNK_ALWAYS 3 |
2485 | |
2486 | /* Added to version 1.2.0 */ |
2487 | #ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
2488 | #ifdef PNG_MMX_CODE_SUPPORTED |
2489 | #define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ |
2490 | #define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ |
2491 | #define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 |
2492 | #define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 |
2493 | #define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 |
2494 | #define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 |
2495 | #define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 |
2496 | #define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 |
2497 | #define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ |
2498 | |
2499 | #define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ |
2500 | | PNG_ASM_FLAG_MMX_READ_INTERLACE \ |
2501 | | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ |
2502 | | PNG_ASM_FLAG_MMX_READ_FILTER_UP \ |
2503 | | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ |
2504 | | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) |
2505 | #define PNG_MMX_WRITE_FLAGS ( 0 ) |
2506 | |
2507 | #define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ |
2508 | | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ |
2509 | | PNG_MMX_READ_FLAGS \ |
2510 | | PNG_MMX_WRITE_FLAGS ) |
2511 | |
2512 | #define PNG_SELECT_READ 1 |
2513 | #define PNG_SELECT_WRITE 2 |
2514 | #endif /* PNG_MMX_CODE_SUPPORTED */ |
2515 | |
2516 | #ifndef PNG_1_0_X |
2517 | /* pngget.c */ |
2518 | extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) |
2519 | PNGARG((int flag_select, int *compilerID)); |
2520 | |
2521 | /* pngget.c */ |
2522 | extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) |
2523 | PNGARG((int flag_select)); |
2524 | |
2525 | /* pngget.c */ |
2526 | extern PNG_EXPORT(png_uint_32,png_get_asm_flags) |
2527 | PNGARG((png_structp png_ptr)); |
2528 | |
2529 | /* pngget.c */ |
2530 | extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) |
2531 | PNGARG((png_structp png_ptr)); |
2532 | |
2533 | /* pngget.c */ |
2534 | extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) |
2535 | PNGARG((png_structp png_ptr)); |
2536 | |
2537 | /* pngset.c */ |
2538 | extern PNG_EXPORT(void,png_set_asm_flags) |
2539 | PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); |
2540 | |
2541 | /* pngset.c */ |
2542 | extern PNG_EXPORT(void,png_set_mmx_thresholds) |
2543 | PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, |
2544 | png_uint_32 mmx_rowbytes_threshold)); |
2545 | |
2546 | #endif /* PNG_1_0_X */ |
2547 | |
2548 | #ifndef PNG_1_0_X |
2549 | /* png.c, pnggccrd.c, or pngvcrd.c */ |
2550 | extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); |
2551 | #endif /* PNG_1_0_X */ |
2552 | #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
2553 | |
2554 | /* Strip the prepended error numbers ("#nnn ") from error and warning |
2555 | * messages before passing them to the error or warning handler. |
2556 | */ |
2557 | #ifdef PNG_ERROR_NUMBERS_SUPPORTED |
2558 | extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp |
2559 | png_ptr, png_uint_32 strip_mode)); |
2560 | #endif |
2561 | |
2562 | /* Added at libpng-1.2.6 */ |
2563 | #ifdef PNG_SET_USER_LIMITS_SUPPORTED |
2564 | extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp |
2565 | png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max)); |
2566 | extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp |
2567 | png_ptr)); |
2568 | extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp |
2569 | png_ptr)); |
2570 | #endif |
2571 | /* Maintainer: Put new public prototypes here ^, in libpng.3, and in |
2572 | * project defs |
2573 | */ |
2574 | |
2575 | #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED |
2576 | /* With these routines we avoid an integer divide, which will be slower on |
2577 | * most machines. However, it does take more operations than the corresponding |
2578 | * divide method, so it may be slower on a few RISC systems. There are two |
2579 | * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. |
2580 | * |
2581 | * Note that the rounding factors are NOT supposed to be the same! 128 and |
2582 | * 32768 are correct for the NODIV code; 127 and 32767 are correct for the |
2583 | * standard method. |
2584 | * |
2585 | * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] |
2586 | */ |
2587 | |
2588 | /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ |
2589 | |
2590 | # define png_composite(composite, fg, alpha, bg) \ |
2591 | { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ |
2592 | + (png_uint_16)(bg)*(png_uint_16)(255 - \ |
2593 | (png_uint_16)(alpha)) + (png_uint_16)128); \ |
2594 | (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } |
2595 | |
2596 | # define png_composite_16(composite, fg, alpha, bg) \ |
2597 | { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ |
2598 | + (png_uint_32)(bg)*(png_uint_32)(65535L - \ |
2599 | (png_uint_32)(alpha)) + (png_uint_32)32768L); \ |
2600 | (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } |
2601 | |
2602 | #else /* Standard method using integer division */ |
2603 | |
2604 | # define png_composite(composite, fg, alpha, bg) \ |
2605 | (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ |
2606 | (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ |
2607 | (png_uint_16)127) / 255) |
2608 | |
2609 | # define png_composite_16(composite, fg, alpha, bg) \ |
2610 | (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ |
2611 | (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ |
2612 | (png_uint_32)32767) / (png_uint_32)65535L) |
2613 | |
2614 | #endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ |
2615 | |
2616 | /* Inline macros to do direct reads of bytes from the input buffer. These |
2617 | * require that you are using an architecture that uses PNG byte ordering |
2618 | * (MSB first) and supports unaligned data storage. I think that PowerPC |
2619 | * in big-endian mode and 680x0 are the only ones that will support this. |
2620 | * The x86 line of processors definitely do not. The png_get_int_32() |
2621 | * routine also assumes we are using two's complement format for negative |
2622 | * values, which is almost certainly true. |
2623 | */ |
2624 | #ifdef PNG_READ_BIG_ENDIAN_SUPPORTED |
2625 | # define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) |
2626 | # define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) |
2627 | # define png_get_int_32(buf) ( *((png_int_32p) (buf))) |
2628 | #else |
2629 | extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf)); |
2630 | extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf)); |
2631 | extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf)); |
2632 | #endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ |
2633 | extern PNG_EXPORT(png_uint_32,png_get_uint_31) |
2634 | PNGARG((png_structp png_ptr, png_bytep buf)); |
2635 | /* No png_get_int_16 -- may be added if there's a real need for it. */ |
2636 | |
2637 | /* Place a 32-bit number into a buffer in PNG byte order (big-endian). |
2638 | */ |
2639 | extern PNG_EXPORT(void,png_save_uint_32) |
2640 | PNGARG((png_bytep buf, png_uint_32 i)); |
2641 | extern PNG_EXPORT(void,png_save_int_32) |
2642 | PNGARG((png_bytep buf, png_int_32 i)); |
2643 | |
2644 | /* Place a 16-bit number into a buffer in PNG byte order. |
2645 | * The parameter is declared unsigned int, not png_uint_16, |
2646 | * just to avoid potential problems on pre-ANSI C compilers. |
2647 | */ |
2648 | extern PNG_EXPORT(void,png_save_uint_16) |
2649 | PNGARG((png_bytep buf, unsigned int i)); |
2650 | /* No png_save_int_16 -- may be added if there's a real need for it. */ |
2651 | |
2652 | /* ************************************************************************* */ |
2653 | |
2654 | /* These next functions are used internally in the code. They generally |
2655 | * shouldn't be used unless you are writing code to add or replace some |
2656 | * functionality in libpng. More information about most functions can |
2657 | * be found in the files where the functions are located. |
2658 | */ |
2659 | |
2660 | |
2661 | /* Various modes of operation, that are visible to applications because |
2662 | * they are used for unknown chunk location. |
2663 | */ |
2664 | #define PNG_HAVE_IHDR 0x01 |
2665 | #define PNG_HAVE_PLTE 0x02 |
2666 | #define PNG_HAVE_IDAT 0x04 |
2667 | #define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */ |
2668 | #define PNG_HAVE_IEND 0x10 |
2669 | |
2670 | #ifdef PNG_INTERNAL |
2671 | |
2672 | /* More modes of operation. Note that after an init, mode is set to |
2673 | * zero automatically when the structure is created. |
2674 | */ |
2675 | #define PNG_HAVE_gAMA 0x20 |
2676 | #define PNG_HAVE_cHRM 0x40 |
2677 | #define PNG_HAVE_sRGB 0x80 |
2678 | #define PNG_HAVE_CHUNK_HEADER 0x100 |
2679 | #define PNG_WROTE_tIME 0x200 |
2680 | #define PNG_WROTE_INFO_BEFORE_PLTE 0x400 |
2681 | #define PNG_BACKGROUND_IS_GRAY 0x800 |
2682 | #define PNG_HAVE_PNG_SIGNATURE 0x1000 |
2683 | #define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */ |
2684 | |
2685 | /* Flags for the transformations the PNG library does on the image data */ |
2686 | #define PNG_BGR 0x0001 |
2687 | #define PNG_INTERLACE 0x0002 |
2688 | #define PNG_PACK 0x0004 |
2689 | #define PNG_SHIFT 0x0008 |
2690 | #define PNG_SWAP_BYTES 0x0010 |
2691 | #define PNG_INVERT_MONO 0x0020 |
2692 | #define PNG_DITHER 0x0040 |
2693 | #define PNG_BACKGROUND 0x0080 |
2694 | #define PNG_BACKGROUND_EXPAND 0x0100 |
2695 | /* 0x0200 unused */ |
2696 | #define PNG_16_TO_8 0x0400 |
2697 | #define PNG_RGBA 0x0800 |
2698 | #define PNG_EXPAND 0x1000 |
2699 | #define PNG_GAMMA 0x2000 |
2700 | #define PNG_GRAY_TO_RGB 0x4000 |
2701 | #define PNG_FILLER 0x8000L |
2702 | #define PNG_PACKSWAP 0x10000L |
2703 | #define PNG_SWAP_ALPHA 0x20000L |
2704 | #define PNG_STRIP_ALPHA 0x40000L |
2705 | #define PNG_INVERT_ALPHA 0x80000L |
2706 | #define PNG_USER_TRANSFORM 0x100000L |
2707 | #define PNG_RGB_TO_GRAY_ERR 0x200000L |
2708 | #define PNG_RGB_TO_GRAY_WARN 0x400000L |
2709 | #define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ |
2710 | /* 0x800000L Unused */ |
2711 | #define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */ |
2712 | #define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */ |
2713 | #define PNG_PREMULTIPLY_ALPHA 0x4000000L /* Added to libpng-1.2.41 */ |
2714 | /* by volker */ |
2715 | /* 0x8000000L unused */ |
2716 | /* 0x10000000L unused */ |
2717 | /* 0x20000000L unused */ |
2718 | /* 0x40000000L unused */ |
2719 | |
2720 | /* Flags for png_create_struct */ |
2721 | #define PNG_STRUCT_PNG 0x0001 |
2722 | #define PNG_STRUCT_INFO 0x0002 |
2723 | |
2724 | /* Scaling factor for filter heuristic weighting calculations */ |
2725 | #define PNG_WEIGHT_SHIFT 8 |
2726 | #define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) |
2727 | #define PNG_COST_SHIFT 3 |
2728 | #define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) |
2729 | |
2730 | /* Flags for the png_ptr->flags rather than declaring a byte for each one */ |
2731 | #define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 |
2732 | #define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 |
2733 | #define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 |
2734 | #define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 |
2735 | #define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 |
2736 | #define PNG_FLAG_ZLIB_FINISHED 0x0020 |
2737 | #define PNG_FLAG_ROW_INIT 0x0040 |
2738 | #define PNG_FLAG_FILLER_AFTER 0x0080 |
2739 | #define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 |
2740 | #define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 |
2741 | #define PNG_FLAG_CRC_CRITICAL_USE 0x0400 |
2742 | #define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 |
2743 | #define PNG_FLAG_FREE_PLTE 0x1000 |
2744 | #define PNG_FLAG_FREE_TRNS 0x2000 |
2745 | #define PNG_FLAG_FREE_HIST 0x4000 |
2746 | #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L |
2747 | #define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L |
2748 | #define PNG_FLAG_LIBRARY_MISMATCH 0x20000L |
2749 | #define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L |
2750 | #define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L |
2751 | #define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L |
2752 | #define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */ |
2753 | #define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */ |
2754 | /* 0x800000L unused */ |
2755 | /* 0x1000000L unused */ |
2756 | /* 0x2000000L unused */ |
2757 | /* 0x4000000L unused */ |
2758 | /* 0x8000000L unused */ |
2759 | /* 0x10000000L unused */ |
2760 | /* 0x20000000L unused */ |
2761 | /* 0x40000000L unused */ |
2762 | |
2763 | #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ |
2764 | PNG_FLAG_CRC_ANCILLARY_NOWARN) |
2765 | |
2766 | #define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ |
2767 | PNG_FLAG_CRC_CRITICAL_IGNORE) |
2768 | |
2769 | #define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ |
2770 | PNG_FLAG_CRC_CRITICAL_MASK) |
2771 | |
2772 | /* Save typing and make code easier to understand */ |
2773 | |
2774 | #define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ |
2775 | abs((int)((c1).green) - (int)((c2).green)) + \ |
2776 | abs((int)((c1).blue) - (int)((c2).blue))) |
2777 | |
2778 | /* Added to libpng-1.2.6 JB */ |
2779 | #define PNG_ROWBYTES(pixel_bits, width) \ |
2780 | ((pixel_bits) >= 8 ? \ |
2781 | ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \ |
2782 | (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) ) |
2783 | |
2784 | /* PNG_OUT_OF_RANGE returns true if value is outside the range |
2785 | * ideal-delta..ideal+delta. Each argument is evaluated twice. |
2786 | * "ideal" and "delta" should be constants, normally simple |
2787 | * integers, "value" a variable. Added to libpng-1.2.6 JB |
2788 | */ |
2789 | #define PNG_OUT_OF_RANGE(value, ideal, delta) \ |
2790 | ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) |
2791 | |
2792 | /* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */ |
2793 | #if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) |
2794 | /* Place to hold the signature string for a PNG file. */ |
2795 | #ifdef PNG_USE_GLOBAL_ARRAYS |
2796 | PNG_EXPORT_VAR (PNG_CONST png_byte FARDATA) png_sig[8]; |
2797 | #else |
2798 | #endif |
2799 | #endif /* PNG_NO_EXTERN */ |
2800 | |
2801 | /* Constant strings for known chunk types. If you need to add a chunk, |
2802 | * define the name here, and add an invocation of the macro in png.c and |
2803 | * wherever it's needed. |
2804 | */ |
2805 | #define PNG_IHDR png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} |
2806 | #define PNG_IDAT png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} |
2807 | #define PNG_IEND png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} |
2808 | #define PNG_PLTE png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} |
2809 | #define PNG_bKGD png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} |
2810 | #define PNG_cHRM png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} |
2811 | #define PNG_gAMA png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} |
2812 | #define PNG_hIST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} |
2813 | #define PNG_iCCP png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} |
2814 | #define PNG_iTXt png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} |
2815 | #define PNG_oFFs png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} |
2816 | #define PNG_pCAL png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} |
2817 | #define PNG_sCAL png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} |
2818 | #define PNG_pHYs png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} |
2819 | #define PNG_sBIT png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} |
2820 | #define PNG_sPLT png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} |
2821 | #define PNG_sRGB png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} |
2822 | #define PNG_tEXt png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} |
2823 | #define PNG_tIME png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} |
2824 | #define PNG_tRNS png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} |
2825 | #define PNG_zTXt png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} |
2826 | |
2827 | #ifdef PNG_USE_GLOBAL_ARRAYS |
2828 | PNG_EXPORT_VAR (png_byte FARDATA) png_IHDR[5]; |
2829 | PNG_EXPORT_VAR (png_byte FARDATA) png_IDAT[5]; |
2830 | PNG_EXPORT_VAR (png_byte FARDATA) png_IEND[5]; |
2831 | PNG_EXPORT_VAR (png_byte FARDATA) png_PLTE[5]; |
2832 | PNG_EXPORT_VAR (png_byte FARDATA) png_bKGD[5]; |
2833 | PNG_EXPORT_VAR (png_byte FARDATA) png_cHRM[5]; |
2834 | PNG_EXPORT_VAR (png_byte FARDATA) png_gAMA[5]; |
2835 | PNG_EXPORT_VAR (png_byte FARDATA) png_hIST[5]; |
2836 | PNG_EXPORT_VAR (png_byte FARDATA) png_iCCP[5]; |
2837 | PNG_EXPORT_VAR (png_byte FARDATA) png_iTXt[5]; |
2838 | PNG_EXPORT_VAR (png_byte FARDATA) png_oFFs[5]; |
2839 | PNG_EXPORT_VAR (png_byte FARDATA) png_pCAL[5]; |
2840 | PNG_EXPORT_VAR (png_byte FARDATA) png_sCAL[5]; |
2841 | PNG_EXPORT_VAR (png_byte FARDATA) png_pHYs[5]; |
2842 | PNG_EXPORT_VAR (png_byte FARDATA) png_sBIT[5]; |
2843 | PNG_EXPORT_VAR (png_byte FARDATA) png_sPLT[5]; |
2844 | PNG_EXPORT_VAR (png_byte FARDATA) png_sRGB[5]; |
2845 | PNG_EXPORT_VAR (png_byte FARDATA) png_tEXt[5]; |
2846 | PNG_EXPORT_VAR (png_byte FARDATA) png_tIME[5]; |
2847 | PNG_EXPORT_VAR (png_byte FARDATA) png_tRNS[5]; |
2848 | PNG_EXPORT_VAR (png_byte FARDATA) png_zTXt[5]; |
2849 | #endif /* PNG_USE_GLOBAL_ARRAYS */ |
2850 | |
2851 | #if defined(PNG_1_0_X) || defined (PNG_1_2_X) |
2852 | /* Initialize png_ptr struct for reading, and allocate any other memory. |
2853 | * (old interface - DEPRECATED - use png_create_read_struct instead). |
2854 | */ |
2855 | extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)) |
2856 | PNG_DEPRECATED; |
2857 | #undef png_read_init |
2858 | #define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ |
2859 | PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); |
2860 | #endif |
2861 | |
2862 | extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, |
2863 | png_const_charp user_png_ver, png_size_t png_struct_size)); |
2864 | #if defined(PNG_1_0_X) || defined (PNG_1_2_X) |
2865 | extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, |
2866 | png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t |
2867 | png_info_size)); |
2868 | #endif |
2869 | |
2870 | #if defined(PNG_1_0_X) || defined (PNG_1_2_X) |
2871 | /* Initialize png_ptr struct for writing, and allocate any other memory. |
2872 | * (old interface - DEPRECATED - use png_create_write_struct instead). |
2873 | */ |
2874 | extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)) |
2875 | PNG_DEPRECATED; |
2876 | #undef png_write_init |
2877 | #define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ |
2878 | PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); |
2879 | #endif |
2880 | |
2881 | extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, |
2882 | png_const_charp user_png_ver, png_size_t png_struct_size)); |
2883 | extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, |
2884 | png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t |
2885 | png_info_size)); |
2886 | |
2887 | /* Allocate memory for an internal libpng struct */ |
2888 | PNG_EXTERN png_voidp png_create_struct PNGARG((int type)) PNG_PRIVATE; |
2889 | |
2890 | /* Free memory from internal libpng struct */ |
2891 | PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)) PNG_PRIVATE; |
2892 | |
2893 | PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr |
2894 | malloc_fn, png_voidp mem_ptr)) PNG_PRIVATE; |
2895 | PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, |
2896 | png_free_ptr free_fn, png_voidp mem_ptr)) PNG_PRIVATE; |
2897 | |
2898 | /* Free any memory that info_ptr points to and reset struct. */ |
2899 | PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, |
2900 | png_infop info_ptr)) PNG_PRIVATE; |
2901 | |
2902 | #ifndef PNG_1_0_X |
2903 | /* Function to allocate memory for zlib. */ |
2904 | PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, |
2905 | uInt size)) PNG_PRIVATE; |
2906 | |
2907 | /* Function to free memory for zlib */ |
2908 | PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)) PNG_PRIVATE; |
2909 | |
2910 | #ifdef PNG_SIZE_T |
2911 | /* Function to convert a sizeof an item to png_sizeof item */ |
2912 | PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)) |
2913 | PNG_PRIVATE; |
2914 | #endif |
2915 | |
2916 | /* Next four functions are used internally as callbacks. PNGAPI is required |
2917 | * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. |
2918 | */ |
2919 | |
2920 | PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, |
2921 | png_bytep data, png_size_t length)) PNG_PRIVATE; |
2922 | |
2923 | #ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
2924 | PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, |
2925 | png_bytep buffer, png_size_t length)) PNG_PRIVATE; |
2926 | #endif |
2927 | |
2928 | PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, |
2929 | png_bytep data, png_size_t length)) PNG_PRIVATE; |
2930 | |
2931 | #ifdef PNG_WRITE_FLUSH_SUPPORTED |
2932 | #ifdef PNG_STDIO_SUPPORTED |
2933 | PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)) |
2934 | PNG_PRIVATE; |
2935 | #endif |
2936 | #endif |
2937 | #else /* PNG_1_0_X */ |
2938 | #ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
2939 | PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, |
2940 | png_bytep buffer, png_size_t length)) PNG_PRIVATE; |
2941 | #endif |
2942 | #endif /* PNG_1_0_X */ |
2943 | |
2944 | /* Reset the CRC variable */ |
2945 | PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
2946 | |
2947 | /* Write the "data" buffer to whatever output you are using. */ |
2948 | PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, |
2949 | png_size_t length)) PNG_PRIVATE; |
2950 | |
2951 | /* Read data from whatever input you are using into the "data" buffer */ |
2952 | PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, |
2953 | png_size_t length)) PNG_PRIVATE; |
2954 | |
2955 | /* Read bytes into buf, and update png_ptr->crc */ |
2956 | PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, |
2957 | png_size_t length)) PNG_PRIVATE; |
2958 | |
2959 | /* Decompress data in a chunk that uses compression */ |
2960 | #if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ |
2961 | defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) |
2962 | PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr, |
2963 | int comp_type, png_size_t chunklength, |
2964 | png_size_t prefix_length, png_size_t *data_length)) PNG_PRIVATE; |
2965 | #endif |
2966 | |
2967 | /* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ |
2968 | PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip) |
2969 | PNG_PRIVATE); |
2970 | |
2971 | /* Read the CRC from the file and compare it to the libpng calculated CRC */ |
2972 | PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
2973 | |
2974 | /* Calculate the CRC over a section of data. Note that we are only |
2975 | * passing a maximum of 64K on systems that have this as a memory limit, |
2976 | * since this is the maximum buffer size we can specify. |
2977 | */ |
2978 | PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, |
2979 | png_size_t length)) PNG_PRIVATE; |
2980 | |
2981 | #ifdef PNG_WRITE_FLUSH_SUPPORTED |
2982 | PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
2983 | #endif |
2984 | |
2985 | /* Simple function to write the signature */ |
2986 | PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
2987 | |
2988 | /* Write various chunks */ |
2989 | |
2990 | /* Write the IHDR chunk, and update the png_struct with the necessary |
2991 | * information. |
2992 | */ |
2993 | PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, |
2994 | png_uint_32 height, |
2995 | int bit_depth, int color_type, int compression_method, int filter_method, |
2996 | int interlace_method)) PNG_PRIVATE; |
2997 | |
2998 | PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, |
2999 | png_uint_32 num_pal)) PNG_PRIVATE; |
3000 | |
3001 | PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, |
3002 | png_size_t length)) PNG_PRIVATE; |
3003 | |
3004 | PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3005 | |
3006 | #ifdef PNG_WRITE_gAMA_SUPPORTED |
3007 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
3008 | PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)) |
3009 | PNG_PRIVATE; |
3010 | #endif |
3011 | #ifdef PNG_FIXED_POINT_SUPPORTED |
3012 | PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, |
3013 | png_fixed_point file_gamma)) PNG_PRIVATE; |
3014 | #endif |
3015 | #endif |
3016 | |
3017 | #ifdef PNG_WRITE_sBIT_SUPPORTED |
3018 | PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, |
3019 | int color_type)) PNG_PRIVATE; |
3020 | #endif |
3021 | |
3022 | #ifdef PNG_WRITE_cHRM_SUPPORTED |
3023 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
3024 | PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, |
3025 | double white_x, double white_y, |
3026 | double red_x, double red_y, double green_x, double green_y, |
3027 | double blue_x, double blue_y)) PNG_PRIVATE; |
3028 | #endif |
3029 | #ifdef PNG_FIXED_POINT_SUPPORTED |
3030 | PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, |
3031 | png_fixed_point int_white_x, png_fixed_point int_white_y, |
3032 | png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point |
3033 | int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, |
3034 | png_fixed_point int_blue_y)) PNG_PRIVATE; |
3035 | #endif |
3036 | #endif |
3037 | |
3038 | #ifdef PNG_WRITE_sRGB_SUPPORTED |
3039 | PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, |
3040 | int intent)) PNG_PRIVATE; |
3041 | #endif |
3042 | |
3043 | #ifdef PNG_WRITE_iCCP_SUPPORTED |
3044 | PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, |
3045 | png_charp name, int compression_type, |
3046 | png_charp profile, int proflen)) PNG_PRIVATE; |
3047 | /* Note to maintainer: profile should be png_bytep */ |
3048 | #endif |
3049 | |
3050 | #ifdef PNG_WRITE_sPLT_SUPPORTED |
3051 | PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, |
3052 | png_sPLT_tp palette)) PNG_PRIVATE; |
3053 | #endif |
3054 | |
3055 | #ifdef PNG_WRITE_tRNS_SUPPORTED |
3056 | PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, |
3057 | png_color_16p values, int number, int color_type)) PNG_PRIVATE; |
3058 | #endif |
3059 | |
3060 | #ifdef PNG_WRITE_bKGD_SUPPORTED |
3061 | PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, |
3062 | png_color_16p values, int color_type)) PNG_PRIVATE; |
3063 | #endif |
3064 | |
3065 | #ifdef PNG_WRITE_hIST_SUPPORTED |
3066 | PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, |
3067 | int num_hist)) PNG_PRIVATE; |
3068 | #endif |
3069 | |
3070 | #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ |
3071 | defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
3072 | PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, |
3073 | png_charp key, png_charpp new_key)) PNG_PRIVATE; |
3074 | #endif |
3075 | |
3076 | #ifdef PNG_WRITE_tEXt_SUPPORTED |
3077 | PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, |
3078 | png_charp text, png_size_t text_len)) PNG_PRIVATE; |
3079 | #endif |
3080 | |
3081 | #ifdef PNG_WRITE_zTXt_SUPPORTED |
3082 | PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, |
3083 | png_charp text, png_size_t text_len, int compression)) PNG_PRIVATE; |
3084 | #endif |
3085 | |
3086 | #ifdef PNG_WRITE_iTXt_SUPPORTED |
3087 | PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, |
3088 | int compression, png_charp key, png_charp lang, png_charp lang_key, |
3089 | png_charp text)) PNG_PRIVATE; |
3090 | #endif |
3091 | |
3092 | #ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */ |
3093 | PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, |
3094 | png_infop info_ptr, png_textp text_ptr, int num_text)) PNG_PRIVATE; |
3095 | #endif |
3096 | |
3097 | #ifdef PNG_WRITE_oFFs_SUPPORTED |
3098 | PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, |
3099 | png_int_32 x_offset, png_int_32 y_offset, int unit_type)) PNG_PRIVATE; |
3100 | #endif |
3101 | |
3102 | #ifdef PNG_WRITE_pCAL_SUPPORTED |
3103 | PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, |
3104 | png_int_32 X0, png_int_32 X1, int type, int nparams, |
3105 | png_charp units, png_charpp params)) PNG_PRIVATE; |
3106 | #endif |
3107 | |
3108 | #ifdef PNG_WRITE_pHYs_SUPPORTED |
3109 | PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, |
3110 | png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, |
3111 | int unit_type)) PNG_PRIVATE; |
3112 | #endif |
3113 | |
3114 | #ifdef PNG_WRITE_tIME_SUPPORTED |
3115 | PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, |
3116 | png_timep mod_time)) PNG_PRIVATE; |
3117 | #endif |
3118 | |
3119 | #ifdef PNG_WRITE_sCAL_SUPPORTED |
3120 | #if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) |
3121 | PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, |
3122 | int unit, double width, double height)) PNG_PRIVATE; |
3123 | #else |
3124 | #ifdef PNG_FIXED_POINT_SUPPORTED |
3125 | PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, |
3126 | int unit, png_charp width, png_charp height)) PNG_PRIVATE; |
3127 | #endif |
3128 | #endif |
3129 | #endif |
3130 | |
3131 | /* Called when finished processing a row of data */ |
3132 | PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3133 | |
3134 | /* Internal use only. Called before first row of data */ |
3135 | PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3136 | |
3137 | #ifdef PNG_READ_GAMMA_SUPPORTED |
3138 | PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3139 | #endif |
3140 | |
3141 | /* Combine a row of data, dealing with alpha, etc. if requested */ |
3142 | PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, |
3143 | int mask)) PNG_PRIVATE; |
3144 | |
3145 | #ifdef PNG_READ_INTERLACING_SUPPORTED |
3146 | /* Expand an interlaced row */ |
3147 | /* OLD pre-1.0.9 interface: |
3148 | PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, |
3149 | png_bytep row, int pass, png_uint_32 transformations)) PNG_PRIVATE; |
3150 | */ |
3151 | PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3152 | #endif |
3153 | |
3154 | /* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ |
3155 | |
3156 | #ifdef PNG_WRITE_INTERLACING_SUPPORTED |
3157 | /* Grab pixels out of a row for an interlaced pass */ |
3158 | PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, |
3159 | png_bytep row, int pass)) PNG_PRIVATE; |
3160 | #endif |
3161 | |
3162 | /* Unfilter a row */ |
3163 | PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, |
3164 | png_row_infop row_info, png_bytep row, png_bytep prev_row, |
3165 | int filter)) PNG_PRIVATE; |
3166 | |
3167 | /* Choose the best filter to use and filter the row data */ |
3168 | PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, |
3169 | png_row_infop row_info)) PNG_PRIVATE; |
3170 | |
3171 | /* Write out the filtered row. */ |
3172 | PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, |
3173 | png_bytep filtered_row)) PNG_PRIVATE; |
3174 | /* Finish a row while reading, dealing with interlacing passes, etc. */ |
3175 | PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); |
3176 | |
3177 | /* Initialize the row buffers, etc. */ |
3178 | PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3179 | /* Optional call to update the users info structure */ |
3180 | PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, |
3181 | png_infop info_ptr)) PNG_PRIVATE; |
3182 | |
3183 | /* These are the functions that do the transformations */ |
3184 | #ifdef PNG_READ_FILLER_SUPPORTED |
3185 | PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, |
3186 | png_bytep row, png_uint_32 filler, png_uint_32 flags)) PNG_PRIVATE; |
3187 | #endif |
3188 | |
3189 | #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED |
3190 | PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, |
3191 | png_bytep row)) PNG_PRIVATE; |
3192 | #endif |
3193 | |
3194 | #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED |
3195 | PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, |
3196 | png_bytep row)) PNG_PRIVATE; |
3197 | #endif |
3198 | |
3199 | #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED |
3200 | PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, |
3201 | png_bytep row)) PNG_PRIVATE; |
3202 | #endif |
3203 | |
3204 | #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED |
3205 | PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, |
3206 | png_bytep row)) PNG_PRIVATE; |
3207 | #endif |
3208 | |
3209 | #if defined(PNG_WRITE_FILLER_SUPPORTED) || \ |
3210 | defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
3211 | PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, |
3212 | png_bytep row, png_uint_32 flags)) PNG_PRIVATE; |
3213 | #endif |
3214 | |
3215 | #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
3216 | PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, |
3217 | png_bytep row)) PNG_PRIVATE; |
3218 | #endif |
3219 | |
3220 | #if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
3221 | PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, |
3222 | png_bytep row)) PNG_PRIVATE; |
3223 | #endif |
3224 | |
3225 | #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
3226 | PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop |
3227 | row_info, png_bytep row)) PNG_PRIVATE; |
3228 | #endif |
3229 | |
3230 | #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
3231 | PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, |
3232 | png_bytep row)) PNG_PRIVATE; |
3233 | #endif |
3234 | |
3235 | #ifdef PNG_READ_PACK_SUPPORTED |
3236 | PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, |
3237 | png_bytep row)) PNG_PRIVATE; |
3238 | #endif |
3239 | |
3240 | #ifdef PNG_READ_SHIFT_SUPPORTED |
3241 | PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, |
3242 | png_color_8p sig_bits)) PNG_PRIVATE; |
3243 | #endif |
3244 | |
3245 | #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
3246 | PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, |
3247 | png_bytep row)) PNG_PRIVATE; |
3248 | #endif |
3249 | |
3250 | #ifdef PNG_READ_16_TO_8_SUPPORTED |
3251 | PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, |
3252 | png_bytep row)) PNG_PRIVATE; |
3253 | #endif |
3254 | |
3255 | #ifdef PNG_READ_DITHER_SUPPORTED |
3256 | PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, |
3257 | png_bytep row, png_bytep palette_lookup, |
3258 | png_bytep dither_lookup)) PNG_PRIVATE; |
3259 | |
3260 | # ifdef PNG_CORRECT_PALETTE_SUPPORTED |
3261 | PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, |
3262 | png_colorp palette, int num_palette)) PNG_PRIVATE; |
3263 | # endif |
3264 | #endif |
3265 | |
3266 | #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
3267 | PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, |
3268 | png_bytep row)) PNG_PRIVATE; |
3269 | #endif |
3270 | |
3271 | #ifdef PNG_WRITE_PACK_SUPPORTED |
3272 | PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, |
3273 | png_bytep row, png_uint_32 bit_depth)) PNG_PRIVATE; |
3274 | #endif |
3275 | |
3276 | #ifdef PNG_WRITE_SHIFT_SUPPORTED |
3277 | PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, |
3278 | png_color_8p bit_depth)) PNG_PRIVATE; |
3279 | #endif |
3280 | |
3281 | #ifdef PNG_READ_BACKGROUND_SUPPORTED |
3282 | #ifdef PNG_READ_GAMMA_SUPPORTED |
3283 | PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, |
3284 | png_color_16p trans_values, png_color_16p background, |
3285 | png_color_16p background_1, |
3286 | png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, |
3287 | png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, |
3288 | png_uint_16pp gamma_16_to_1, int gamma_shift)) PNG_PRIVATE; |
3289 | #else |
3290 | PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, |
3291 | png_color_16p trans_values, png_color_16p background)) PNG_PRIVATE; |
3292 | #endif |
3293 | #endif |
3294 | |
3295 | #ifdef PNG_READ_GAMMA_SUPPORTED |
3296 | PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, |
3297 | png_bytep gamma_table, png_uint_16pp gamma_16_table, |
3298 | int gamma_shift)) PNG_PRIVATE; |
3299 | #endif |
3300 | |
3301 | #ifdef PNG_READ_EXPAND_SUPPORTED |
3302 | PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, |
3303 | png_bytep row, png_colorp palette, png_bytep trans, |
3304 | int num_trans)) PNG_PRIVATE; |
3305 | PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, |
3306 | png_bytep row, png_color_16p trans_value)) PNG_PRIVATE; |
3307 | #endif |
3308 | |
3309 | /* The following decodes the appropriate chunks, and does error correction, |
3310 | * then calls the appropriate callback for the chunk if it is valid. |
3311 | */ |
3312 | |
3313 | /* Decode the IHDR chunk */ |
3314 | PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, |
3315 | png_uint_32 length)) PNG_PRIVATE; |
3316 | PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, |
3317 | png_uint_32 length)); |
3318 | PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, |
3319 | png_uint_32 length)); |
3320 | |
3321 | #ifdef PNG_READ_bKGD_SUPPORTED |
3322 | PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, |
3323 | png_uint_32 length)) PNG_PRIVATE; |
3324 | #endif |
3325 | |
3326 | #ifdef PNG_READ_cHRM_SUPPORTED |
3327 | PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, |
3328 | png_uint_32 length)) PNG_PRIVATE; |
3329 | #endif |
3330 | |
3331 | #ifdef PNG_READ_gAMA_SUPPORTED |
3332 | PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, |
3333 | png_uint_32 length)) PNG_PRIVATE; |
3334 | #endif |
3335 | |
3336 | #ifdef PNG_READ_hIST_SUPPORTED |
3337 | PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, |
3338 | png_uint_32 length)) PNG_PRIVATE; |
3339 | #endif |
3340 | |
3341 | #ifdef PNG_READ_iCCP_SUPPORTED |
3342 | extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, |
3343 | png_uint_32 length)); |
3344 | #endif /* PNG_READ_iCCP_SUPPORTED */ |
3345 | |
3346 | #ifdef PNG_READ_iTXt_SUPPORTED |
3347 | PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
3348 | png_uint_32 length)) PNG_PRIVATE; |
3349 | #endif |
3350 | |
3351 | #ifdef PNG_READ_oFFs_SUPPORTED |
3352 | PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, |
3353 | png_uint_32 length)) PNG_PRIVATE; |
3354 | #endif |
3355 | |
3356 | #ifdef PNG_READ_pCAL_SUPPORTED |
3357 | PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
3358 | png_uint_32 length)) PNG_PRIVATE; |
3359 | #endif |
3360 | |
3361 | #ifdef PNG_READ_pHYs_SUPPORTED |
3362 | PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, |
3363 | png_uint_32 length)) PNG_PRIVATE; |
3364 | #endif |
3365 | |
3366 | #ifdef PNG_READ_sBIT_SUPPORTED |
3367 | PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, |
3368 | png_uint_32 length)) PNG_PRIVATE; |
3369 | #endif |
3370 | |
3371 | #ifdef PNG_READ_sCAL_SUPPORTED |
3372 | PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
3373 | png_uint_32 length)) PNG_PRIVATE; |
3374 | #endif |
3375 | |
3376 | #ifdef PNG_READ_sPLT_SUPPORTED |
3377 | extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, |
3378 | png_uint_32 length)) PNG_PRIVATE; |
3379 | #endif /* PNG_READ_sPLT_SUPPORTED */ |
3380 | |
3381 | #ifdef PNG_READ_sRGB_SUPPORTED |
3382 | PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, |
3383 | png_uint_32 length)) PNG_PRIVATE; |
3384 | #endif |
3385 | |
3386 | #ifdef PNG_READ_tEXt_SUPPORTED |
3387 | PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
3388 | png_uint_32 length)) PNG_PRIVATE; |
3389 | #endif |
3390 | |
3391 | #ifdef PNG_READ_tIME_SUPPORTED |
3392 | PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, |
3393 | png_uint_32 length)) PNG_PRIVATE; |
3394 | #endif |
3395 | |
3396 | #ifdef PNG_READ_tRNS_SUPPORTED |
3397 | PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, |
3398 | png_uint_32 length)) PNG_PRIVATE; |
3399 | #endif |
3400 | |
3401 | #ifdef PNG_READ_zTXt_SUPPORTED |
3402 | PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
3403 | png_uint_32 length)) PNG_PRIVATE; |
3404 | #endif |
3405 | |
3406 | PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, |
3407 | png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; |
3408 | |
3409 | PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, |
3410 | png_bytep chunk_name)) PNG_PRIVATE; |
3411 | |
3412 | /* Handle the transformations for reading and writing */ |
3413 | PNG_EXTERN void png_do_read_transformations |
3414 | PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3415 | PNG_EXTERN void png_do_write_transformations |
3416 | PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3417 | |
3418 | PNG_EXTERN void png_init_read_transformations |
3419 | PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3420 | |
3421 | #ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
3422 | PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, |
3423 | png_infop info_ptr)) PNG_PRIVATE; |
3424 | PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, |
3425 | png_infop info_ptr)) PNG_PRIVATE; |
3426 | PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3427 | PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, |
3428 | png_uint_32 length)) PNG_PRIVATE; |
3429 | PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3430 | PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3431 | PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, |
3432 | png_bytep buffer, png_size_t buffer_length)) PNG_PRIVATE; |
3433 | PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3434 | PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, |
3435 | png_bytep buffer, png_size_t buffer_length)) PNG_PRIVATE; |
3436 | PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3437 | PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, |
3438 | png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; |
3439 | PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, |
3440 | png_infop info_ptr)) PNG_PRIVATE; |
3441 | PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, |
3442 | png_infop info_ptr)) PNG_PRIVATE; |
3443 | PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, |
3444 | png_bytep row)) PNG_PRIVATE; |
3445 | PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, |
3446 | png_infop info_ptr)) PNG_PRIVATE; |
3447 | PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, |
3448 | png_infop info_ptr)) PNG_PRIVATE; |
3449 | PNG_EXTERN void png_read_push_finish_row |
3450 | PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3451 | #ifdef PNG_READ_tEXt_SUPPORTED |
3452 | PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, |
3453 | png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; |
3454 | PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, |
3455 | png_infop info_ptr)) PNG_PRIVATE; |
3456 | #endif |
3457 | #ifdef PNG_READ_zTXt_SUPPORTED |
3458 | PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, |
3459 | png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; |
3460 | PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, |
3461 | png_infop info_ptr)) PNG_PRIVATE; |
3462 | #endif |
3463 | #ifdef PNG_READ_iTXt_SUPPORTED |
3464 | PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, |
3465 | png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; |
3466 | PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, |
3467 | png_infop info_ptr)) PNG_PRIVATE; |
3468 | #endif |
3469 | |
3470 | #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
3471 | |
3472 | #ifdef PNG_MNG_FEATURES_SUPPORTED |
3473 | PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, |
3474 | png_bytep row)) PNG_PRIVATE; |
3475 | PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, |
3476 | png_bytep row)) PNG_PRIVATE; |
3477 | #endif |
3478 | |
3479 | #ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
3480 | #ifdef PNG_MMX_CODE_SUPPORTED |
3481 | /* png.c */ /* PRIVATE */ |
3482 | PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3483 | #endif |
3484 | #endif |
3485 | |
3486 | |
3487 | /* The following six functions will be exported in libpng-1.4.0. */ |
3488 | #if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) |
3489 | PNG_EXTERN png_uint_32 png_get_pixels_per_inch PNGARG((png_structp png_ptr, |
3490 | png_infop info_ptr)); |
3491 | |
3492 | PNG_EXTERN png_uint_32 png_get_x_pixels_per_inch PNGARG((png_structp png_ptr, |
3493 | png_infop info_ptr)); |
3494 | |
3495 | PNG_EXTERN png_uint_32 png_get_y_pixels_per_inch PNGARG((png_structp png_ptr, |
3496 | png_infop info_ptr)); |
3497 | |
3498 | PNG_EXTERN float png_get_x_offset_inches PNGARG((png_structp png_ptr, |
3499 | png_infop info_ptr)); |
3500 | |
3501 | PNG_EXTERN float png_get_y_offset_inches PNGARG((png_structp png_ptr, |
3502 | png_infop info_ptr)); |
3503 | |
3504 | #ifdef PNG_pHYs_SUPPORTED |
3505 | PNG_EXTERN png_uint_32 png_get_pHYs_dpi PNGARG((png_structp png_ptr, |
3506 | png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); |
3507 | #endif /* PNG_pHYs_SUPPORTED */ |
3508 | #endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ |
3509 | |
3510 | /* Read the chunk header (length + type name) */ |
3511 | PNG_EXTERN png_uint_32 png_read_chunk_header |
3512 | PNGARG((png_structp png_ptr)) PNG_PRIVATE; |
3513 | |
3514 | /* Added at libpng version 1.2.34 */ |
3515 | #ifdef PNG_cHRM_SUPPORTED |
3516 | PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr, |
3517 | png_fixed_point int_white_x, png_fixed_point int_white_y, |
3518 | png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point |
3519 | int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, |
3520 | png_fixed_point int_blue_y)) PNG_PRIVATE; |
3521 | #endif |
3522 | |
3523 | #ifdef PNG_cHRM_SUPPORTED |
3524 | #ifdef PNG_CHECK_cHRM_SUPPORTED |
3525 | /* Added at libpng version 1.2.34 */ |
3526 | PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2, |
3527 | unsigned long *hi_product, unsigned long *lo_product)) PNG_PRIVATE; |
3528 | #endif |
3529 | #endif |
3530 | |
3531 | /* Added at libpng version 1.2.41 */ |
3532 | PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr, |
3533 | png_uint_32 width, png_uint_32 height, int bit_depth, |
3534 | int color_type, int interlace_type, int compression_type, |
3535 | int filter_type)) PNG_PRIVATE; |
3536 | |
3537 | /* Added at libpng version 1.2.41 */ |
3538 | PNG_EXTERN png_voidp png_calloc PNGARG((png_structp png_ptr, |
3539 | png_uint_32 size)); |
3540 | |
3541 | /* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ |
3542 | |
3543 | #endif /* PNG_INTERNAL */ |
3544 | |
3545 | #ifdef __cplusplus |
3546 | } |
3547 | #endif |
3548 | |
3549 | #endif /* PNG_VERSION_INFO_ONLY */ |
3550 | /* Do not put anything past this line */ |
3551 | #endif /* PNG_H */ |
3552 | |