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