1 2 /* png.h - header file for PNG reference library 3 * 4 * libpng version 1.4.3 - June 26, 2010 5 * Copyright (c) 1998-2010 Glenn Randers-Pehrson 6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) 7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) 8 * 9 * This code is released under the libpng license (See LICENSE, below) 10 * 11 * Authors and maintainers: 12 * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat 13 * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger 14 * libpng versions 0.97, January 1998, through 1.4.3 - June 26, 2010: Glenn 15 * See also "Contributing Authors", below. 16 * 17 * Note about libpng version numbers: 18 * 19 * Due to various miscommunications, unforeseen code incompatibilities 20 * and occasional factors outside the authors' control, version numbering 21 * on the library has not always been consistent and straightforward. 22 * The following table summarizes matters since version 0.89c, which was 23 * the first widely used release: 24 * 25 * source png.h png.h shared-lib 26 * version string int version 27 * ------- ------ ----- ---------- 28 * 0.89c "1.0 beta 3" 0.89 89 1.0.89 29 * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] 30 * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] 31 * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] 32 * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] 33 * 0.97c 0.97 97 2.0.97 34 * 0.98 0.98 98 2.0.98 35 * 0.99 0.99 98 2.0.99 36 * 0.99a-m 0.99 99 2.0.99 37 * 1.00 1.00 100 2.1.0 [100 should be 10000] 38 * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] 39 * 1.0.1 png.h string is 10001 2.1.0 40 * 1.0.1a-e identical to the 10002 from here on, the shared library 41 * 1.0.2 source version) 10002 is 2.V where V is the source code 42 * 1.0.2a-b 10003 version, except as noted. 43 * 1.0.3 10003 44 * 1.0.3a-d 10004 45 * 1.0.4 10004 46 * 1.0.4a-f 10005 47 * 1.0.5 (+ 2 patches) 10005 48 * 1.0.5a-d 10006 49 * 1.0.5e-r 10100 (not source compatible) 50 * 1.0.5s-v 10006 (not binary compatible) 51 * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) 52 * 1.0.6d-f 10007 (still binary incompatible) 53 * 1.0.6g 10007 54 * 1.0.6h 10007 10.6h (testing xy.z so-numbering) 55 * 1.0.6i 10007 10.6i 56 * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) 57 * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) 58 * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) 59 * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) 60 * 1.0.7 1 10007 (still compatible) 61 * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 62 * 1.0.8rc1 1 10008 2.1.0.8rc1 63 * 1.0.8 1 10008 2.1.0.8 64 * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 65 * 1.0.9rc1 1 10009 2.1.0.9rc1 66 * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 67 * 1.0.9rc2 1 10009 2.1.0.9rc2 68 * 1.0.9 1 10009 2.1.0.9 69 * 1.0.10beta1 1 10010 2.1.0.10beta1 70 * 1.0.10rc1 1 10010 2.1.0.10rc1 71 * 1.0.10 1 10010 2.1.0.10 72 * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 73 * 1.0.11rc1 1 10011 2.1.0.11rc1 74 * 1.0.11 1 10011 2.1.0.11 75 * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 76 * 1.0.12rc1 2 10012 2.1.0.12rc1 77 * 1.0.12 2 10012 2.1.0.12 78 * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) 79 * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 80 * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 81 * 1.2.0rc1 3 10200 3.1.2.0rc1 82 * 1.2.0 3 10200 3.1.2.0 83 * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 84 * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 85 * 1.2.1 3 10201 3.1.2.1 86 * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 87 * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 88 * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 89 * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 90 * 1.0.13 10 10013 10.so.0.1.0.13 91 * 1.2.2 12 10202 12.so.0.1.2.2 92 * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 93 * 1.2.3 12 10203 12.so.0.1.2.3 94 * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 95 * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 96 * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 97 * 1.0.14 10 10014 10.so.0.1.0.14 98 * 1.2.4 13 10204 12.so.0.1.2.4 99 * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 100 * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 101 * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 102 * 1.0.15 10 10015 10.so.0.1.0.15 103 * 1.2.5 13 10205 12.so.0.1.2.5 104 * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 105 * 1.0.16 10 10016 10.so.0.1.0.16 106 * 1.2.6 13 10206 12.so.0.1.2.6 107 * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 108 * 1.0.17rc1 10 10017 12.so.0.1.0.17rc1 109 * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 110 * 1.0.17 10 10017 12.so.0.1.0.17 111 * 1.2.7 13 10207 12.so.0.1.2.7 112 * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 113 * 1.0.18rc1-5 10 10018 12.so.0.1.0.18rc1-5 114 * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 115 * 1.0.18 10 10018 12.so.0.1.0.18 116 * 1.2.8 13 10208 12.so.0.1.2.8 117 * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 118 * 1.2.9beta4-11 13 10209 12.so.0.9[.0] 119 * 1.2.9rc1 13 10209 12.so.0.9[.0] 120 * 1.2.9 13 10209 12.so.0.9[.0] 121 * 1.2.10beta1-7 13 10210 12.so.0.10[.0] 122 * 1.2.10rc1-2 13 10210 12.so.0.10[.0] 123 * 1.2.10 13 10210 12.so.0.10[.0] 124 * 1.4.0beta1-5 14 10400 14.so.0.0[.0] 125 * 1.2.11beta1-4 13 10211 12.so.0.11[.0] 126 * 1.4.0beta7-8 14 10400 14.so.0.0[.0] 127 * 1.2.11 13 10211 12.so.0.11[.0] 128 * 1.2.12 13 10212 12.so.0.12[.0] 129 * 1.4.0beta9-14 14 10400 14.so.0.0[.0] 130 * 1.2.13 13 10213 12.so.0.13[.0] 131 * 1.4.0beta15-36 14 10400 14.so.0.0[.0] 132 * 1.4.0beta37-87 14 10400 14.so.14.0[.0] 133 * 1.4.0rc01 14 10400 14.so.14.0[.0] 134 * 1.4.0beta88-109 14 10400 14.so.14.0[.0] 135 * 1.4.0rc02-08 14 10400 14.so.14.0[.0] 136 * 1.4.0 14 10400 14.so.14.0[.0] 137 * 1.4.1beta01-03 14 10401 14.so.14.1[.0] 138 * 1.4.1rc01 14 10401 14.so.14.1[.0] 139 * 1.4.1beta04-12 14 10401 14.so.14.1[.0] 140 * 1.4.1rc02-04 14 10401 14.so.14.1[.0] 141 * 1.4.1 14 10401 14.so.14.1[.0] 142 * 1.4.2beta01 14 10402 14.so.14.2[.0] 143 * 1.4.2rc02-06 14 10402 14.so.14.2[.0] 144 * 1.4.2 14 10402 14.so.14.2[.0] 145 * 1.4.3beta01-05 14 10403 14.so.14.3[.0] 146 * 1.4.3rc01-03 14 10403 14.so.14.3[.0] 147 * 1.4.3 14 10403 14.so.14.3[.0] 148 * 149 * Henceforth the source version will match the shared-library major 150 * and minor numbers; the shared-library major version number will be 151 * used for changes in backward compatibility, as it is intended. The 152 * PNG_LIBPNG_VER macro, which is not used within libpng but is available 153 * for applications, is an unsigned integer of the form xyyzz corresponding 154 * to the source version x.y.z (leading zeros in y and z). Beta versions 155 * were given the previous public release number plus a letter, until 156 * version 1.0.6j; from then on they were given the upcoming public 157 * release number plus "betaNN" or "rcN". 158 * 159 * Binary incompatibility exists only when applications make direct access 160 * to the info_ptr or png_ptr members through png.h, and the compiled 161 * application is loaded with a different version of the library. 162 * 163 * DLLNUM will change each time there are forward or backward changes 164 * in binary compatibility (e.g., when a new feature is added). 165 * 166 * See libpng.txt or libpng.3 for more information. The PNG specification 167 * is available as a W3C Recommendation and as an ISO Specification, 168 * <http://www.w3.org/TR/2003/REC-PNG-20031110/ 169 */ 170 171 /* 172 * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: 173 * 174 * If you modify libpng you may insert additional notices immediately following 175 * this sentence. 176 * 177 * This code is released under the libpng license. 178 * 179 * libpng versions 1.2.6, August 15, 2004, through 1.4.3, June 26, 2010, are 180 * Copyright (c) 2004, 2006-2010 Glenn Randers-Pehrson, and are 181 * distributed according to the same disclaimer and license as libpng-1.2.5 182 * with the following individual added to the list of Contributing Authors: 183 * 184 * Cosmin Truta 185 * 186 * libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are 187 * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are 188 * distributed according to the same disclaimer and license as libpng-1.0.6 189 * with the following individuals added to the list of Contributing Authors: 190 * 191 * Simon-Pierre Cadieux 192 * Eric S. Raymond 193 * Gilles Vollant 194 * 195 * and with the following additions to the disclaimer: 196 * 197 * There is no warranty against interference with your enjoyment of the 198 * library or against infringement. There is no warranty that our 199 * efforts or the library will fulfill any of your particular purposes 200 * or needs. This library is provided with all faults, and the entire 201 * risk of satisfactory quality, performance, accuracy, and effort is with 202 * the user. 203 * 204 * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are 205 * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson, and are 206 * distributed according to the same disclaimer and license as libpng-0.96, 207 * with the following individuals added to the list of Contributing Authors: 208 * 209 * Tom Lane 210 * Glenn Randers-Pehrson 211 * Willem van Schaik 212 * 213 * libpng versions 0.89, June 1996, through 0.96, May 1997, are 214 * Copyright (c) 1996, 1997 Andreas Dilger 215 * Distributed according to the same disclaimer and license as libpng-0.88, 216 * with the following individuals added to the list of Contributing Authors: 217 * 218 * John Bowler 219 * Kevin Bracey 220 * Sam Bushell 221 * Magnus Holmgren 222 * Greg Roelofs 223 * Tom Tanner 224 * 225 * libpng versions 0.5, May 1995, through 0.88, January 1996, are 226 * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. 227 * 228 * For the purposes of this copyright and license, "Contributing Authors" 229 * is defined as the following set of individuals: 230 * 231 * Andreas Dilger 232 * Dave Martindale 233 * Guy Eric Schalnat 234 * Paul Schmidt 235 * Tim Wegner 236 * 237 * The PNG Reference Library is supplied "AS IS". The Contributing Authors 238 * and Group 42, Inc. disclaim all warranties, expressed or implied, 239 * including, without limitation, the warranties of merchantability and of 240 * fitness for any purpose. The Contributing Authors and Group 42, Inc. 241 * assume no liability for direct, indirect, incidental, special, exemplary, 242 * or consequential damages, which may result from the use of the PNG 243 * Reference Library, even if advised of the possibility of such damage. 244 * 245 * Permission is hereby granted to use, copy, modify, and distribute this 246 * source code, or portions hereof, for any purpose, without fee, subject 247 * to the following restrictions: 248 * 249 * 1. The origin of this source code must not be misrepresented. 250 * 251 * 2. Altered versions must be plainly marked as such and 252 * must not be misrepresented as being the original source. 253 * 254 * 3. This Copyright notice may not be removed or altered from 255 * any source or altered source distribution. 256 * 257 * The Contributing Authors and Group 42, Inc. specifically permit, without 258 * fee, and encourage the use of this source code as a component to 259 * supporting the PNG file format in commercial products. If you use this 260 * source code in a product, acknowledgment is not required but would be 261 * appreciated. 262 */ 263 264 /* 265 * A "png_get_copyright" function is available, for convenient use in "about" 266 * boxes and the like: 267 * 268 * printf("%s",png_get_copyright(NULL)); 269 * 270 * Also, the PNG logo (in PNG format, of course) is supplied in the 271 * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). 272 */ 273 274 /* 275 * Libpng is OSI Certified Open Source Software. OSI Certified is a 276 * certification mark of the Open Source Initiative. 277 */ 278 279 /* 280 * The contributing authors would like to thank all those who helped 281 * with testing, bug fixes, and patience. This wouldn't have been 282 * possible without all of you. 283 * 284 * Thanks to Frank J. T. Wojcik for helping with the documentation. 285 */ 286 287 /* 288 * Y2K compliance in libpng: 289 * ========================= 290 * 291 * June 26, 2010 292 * 293 * Since the PNG Development group is an ad-hoc body, we can't make 294 * an official declaration. 295 * 296 * This is your unofficial assurance that libpng from version 0.71 and 297 * upward through 1.4.3 are Y2K compliant. It is my belief that earlier 298 * versions were also Y2K compliant. 299 * 300 * Libpng only has three year fields. One is a 2-byte unsigned integer 301 * that will hold years up to 65535. The other two hold the date in text 302 * format, and will hold years up to 9999. 303 * 304 * The integer is 305 * "png_uint_16 year" in png_time_struct. 306 * 307 * The strings are 308 * "png_charp time_buffer" in png_struct and 309 * "near_time_buffer", which is a local character string in png.c. 310 * 311 * There are seven time-related functions: 312 * png.c: png_convert_to_rfc_1123() in png.c 313 * (formerly png_convert_to_rfc_1152() in error) 314 * png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c 315 * png_convert_from_time_t() in pngwrite.c 316 * png_get_tIME() in pngget.c 317 * png_handle_tIME() in pngrutil.c, called in pngread.c 318 * png_set_tIME() in pngset.c 319 * png_write_tIME() in pngwutil.c, called in pngwrite.c 320 * 321 * All handle dates properly in a Y2K environment. The 322 * png_convert_from_time_t() function calls gmtime() to convert from system 323 * clock time, which returns (year - 1900), which we properly convert to 324 * the full 4-digit year. There is a possibility that applications using 325 * libpng are not passing 4-digit years into the png_convert_to_rfc_1123() 326 * function, or that they are incorrectly passing only a 2-digit year 327 * instead of "year - 1900" into the png_convert_from_struct_tm() function, 328 * but this is not under our control. The libpng documentation has always 329 * stated that it works with 4-digit years, and the APIs have been 330 * documented as such. 331 * 332 * The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned 333 * integer to hold the year, and can hold years as large as 65535. 334 * 335 * zlib, upon which libpng depends, is also Y2K compliant. It contains 336 * no date-related code. 337 * 338 * Glenn Randers-Pehrson 339 * libpng maintainer 340 * PNG Development Group 341 */ 342 343 #ifndef PNG_H 344 #define PNG_H 345 346 /* This is not the place to learn how to use libpng. The file libpng.txt 347 * describes how to use libpng, and the file example.c summarizes it 348 * with some code on which to build. This file is useful for looking 349 * at the actual function definitions and structure components. 350 */ 351 352 /* Version information for png.h - this should match the version in png.c */ 353 #define PNG_LIBPNG_VER_STRING "1.4.3" 354 #define PNG_HEADER_VERSION_STRING \ 355 " libpng version 1.4.3 - June 26, 2010\n" 356 357 #define PNG_LIBPNG_VER_SONUM 14 358 #define PNG_LIBPNG_VER_DLLNUM 14 359 360 /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ 361 #define PNG_LIBPNG_VER_MAJOR 1 362 #define PNG_LIBPNG_VER_MINOR 4 363 #define PNG_LIBPNG_VER_RELEASE 3 364 /* This should match the numeric part of the final component of 365 * PNG_LIBPNG_VER_STRING, omitting any leading zero: 366 */ 367 368 #define PNG_LIBPNG_VER_BUILD 0 369 370 /* Release Status */ 371 #define PNG_LIBPNG_BUILD_ALPHA 1 372 #define PNG_LIBPNG_BUILD_BETA 2 373 #define PNG_LIBPNG_BUILD_RC 3 374 #define PNG_LIBPNG_BUILD_STABLE 4 375 #define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7 376 377 /* Release-Specific Flags */ 378 #define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with 379 PNG_LIBPNG_BUILD_STABLE only */ 380 #define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with 381 PNG_LIBPNG_BUILD_SPECIAL */ 382 #define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with 383 PNG_LIBPNG_BUILD_PRIVATE */ 384 385 #define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_BETA 386 387 /* Careful here. At one time, Guy wanted to use 082, but that would be octal. 388 * We must not include leading zeros. 389 * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only 390 * version 1.0.0 was mis-numbered 100 instead of 10000). From 391 * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release 392 */ 393 #define PNG_LIBPNG_VER 10403 /* 1.4.3 */ 394 395 #ifndef PNG_VERSION_INFO_ONLY 396 /* Include the compression library's header */ 397 #include <zlib.h> 398 #endif 399 400 /* Include all user configurable info, including optional assembler routines */ 401 #include "pngconf.h" 402 403 /* 404 * Added at libpng-1.2.8 405 * 406 * Ref MSDN: Private as priority over Special 407 * VS_FF_PRIVATEBUILD File *was not* built using standard release 408 * procedures. If this value is given, the StringFileInfo block must 409 * contain a PrivateBuild string. 410 * 411 * VS_FF_SPECIALBUILD File *was* built by the original company using 412 * standard release procedures but is a variation of the standard 413 * file of the same version number. If this value is given, the 414 * StringFileInfo block must contain a SpecialBuild string. 415 */ 416 417 #ifdef PNG_USER_PRIVATEBUILD 418 # define PNG_LIBPNG_BUILD_TYPE \ 419 (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) 420 #else 421 # ifdef PNG_LIBPNG_SPECIALBUILD 422 # define PNG_LIBPNG_BUILD_TYPE \ 423 (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) 424 # else 425 # define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE) 426 # endif 427 #endif 428 429 #ifndef PNG_VERSION_INFO_ONLY 430 431 /* Inhibit C++ name-mangling for libpng functions but not for system calls. */ 432 #ifdef __cplusplus 433 extern "C" { 434 #endif /* __cplusplus */ 435 436 /* This file is arranged in several sections. The first section contains 437 * structure and type definitions. The second section contains the external 438 * library functions, while the third has the internal library functions, 439 * which applications aren't expected to use directly. 440 */ 441 442 /* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */ 443 #if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) 444 /* Version information for C files, stored in png.c. This had better match 445 * the version above. 446 */ 447 #define png_libpng_ver png_get_header_ver(NULL) 448 449 #endif /* PNG_NO_EXTERN */ 450 451 /* Three color definitions. The order of the red, green, and blue, (and the 452 * exact size) is not important, although the size of the fields need to 453 * be png_byte or png_uint_16 (as defined below). 454 */ 455 typedef struct png_color_struct 456 { 457 png_byte red; 458 png_byte green; 459 png_byte blue; 460 } png_color; 461 typedef png_color FAR * png_colorp; 462 typedef png_color FAR * FAR * png_colorpp; 463 464 typedef struct png_color_16_struct 465 { 466 png_byte index; /* used for palette files */ 467 png_uint_16 red; /* for use in red green blue files */ 468 png_uint_16 green; 469 png_uint_16 blue; 470 png_uint_16 gray; /* for use in grayscale files */ 471 } png_color_16; 472 typedef png_color_16 FAR * png_color_16p; 473 typedef png_color_16 FAR * FAR * png_color_16pp; 474 475 typedef struct png_color_8_struct 476 { 477 png_byte red; /* for use in red green blue files */ 478 png_byte green; 479 png_byte blue; 480 png_byte gray; /* for use in grayscale files */ 481 png_byte alpha; /* for alpha channel files */ 482 } png_color_8; 483 typedef png_color_8 FAR * png_color_8p; 484 typedef png_color_8 FAR * FAR * png_color_8pp; 485 486 /* 487 * The following two structures are used for the in-core representation 488 * of sPLT chunks. 489 */ 490 typedef struct png_sPLT_entry_struct 491 { 492 png_uint_16 red; 493 png_uint_16 green; 494 png_uint_16 blue; 495 png_uint_16 alpha; 496 png_uint_16 frequency; 497 } png_sPLT_entry; 498 typedef png_sPLT_entry FAR * png_sPLT_entryp; 499 typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; 500 501 /* When the depth of the sPLT palette is 8 bits, the color and alpha samples 502 * occupy the LSB of their respective members, and the MSB of each member 503 * is zero-filled. The frequency member always occupies the full 16 bits. 504 */ 505 506 typedef struct png_sPLT_struct 507 { 508 png_charp name; /* palette name */ 509 png_byte depth; /* depth of palette samples */ 510 png_sPLT_entryp entries; /* palette entries */ 511 png_int_32 nentries; /* number of palette entries */ 512 } png_sPLT_t; 513 typedef png_sPLT_t FAR * png_sPLT_tp; 514 typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; 515 516 #ifdef PNG_TEXT_SUPPORTED 517 /* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file, 518 * and whether that contents is compressed or not. The "key" field 519 * points to a regular zero-terminated C string. The "text", "lang", and 520 * "lang_key" fields can be regular C strings, empty strings, or NULL pointers. 521 * However, the * structure returned by png_get_text() will always contain 522 * regular zero-terminated C strings (possibly empty), never NULL pointers, 523 * so they can be safely used in printf() and other string-handling functions. 524 */ 525 typedef struct png_text_struct 526 { 527 int compression; /* compression value: 528 -1: tEXt, none 529 0: zTXt, deflate 530 1: iTXt, none 531 2: iTXt, deflate */ 532 png_charp key; /* keyword, 1-79 character description of "text" */ 533 png_charp text; /* comment, may be an empty string (ie "") 534 or a NULL pointer */ 535 png_size_t text_length; /* length of the text string */ 536 #ifdef PNG_iTXt_SUPPORTED 537 png_size_t itxt_length; /* length of the itxt string */ 538 png_charp lang; /* language code, 0-79 characters 539 or a NULL pointer */ 540 png_charp lang_key; /* keyword translated UTF-8 string, 0 or more 541 chars or a NULL pointer */ 542 #endif 543 } png_text; 544 typedef png_text FAR * png_textp; 545 typedef png_text FAR * FAR * png_textpp; 546 #endif 547 548 /* Supported compression types for text in PNG files (tEXt, and zTXt). 549 * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */ 550 #define PNG_TEXT_COMPRESSION_NONE_WR -3 551 #define PNG_TEXT_COMPRESSION_zTXt_WR -2 552 #define PNG_TEXT_COMPRESSION_NONE -1 553 #define PNG_TEXT_COMPRESSION_zTXt 0 554 #define PNG_ITXT_COMPRESSION_NONE 1 555 #define PNG_ITXT_COMPRESSION_zTXt 2 556 #define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */ 557 558 /* png_time is a way to hold the time in an machine independent way. 559 * Two conversions are provided, both from time_t and struct tm. There 560 * is no portable way to convert to either of these structures, as far 561 * as I know. If you know of a portable way, send it to me. As a side 562 * note - PNG has always been Year 2000 compliant! 563 */ 564 typedef struct png_time_struct 565 { 566 png_uint_16 year; /* full year, as in, 1995 */ 567 png_byte month; /* month of year, 1 - 12 */ 568 png_byte day; /* day of month, 1 - 31 */ 569 png_byte hour; /* hour of day, 0 - 23 */ 570 png_byte minute; /* minute of hour, 0 - 59 */ 571 png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ 572 } png_time; 573 typedef png_time FAR * png_timep; 574 typedef png_time FAR * FAR * png_timepp; 575 576 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ 577 defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) 578 /* png_unknown_chunk is a structure to hold queued chunks for which there is 579 * no specific support. The idea is that we can use this to queue 580 * up private chunks for output even though the library doesn't actually 581 * know about their semantics. 582 */ 583 typedef struct png_unknown_chunk_t 584 { 585 png_byte name[5]; 586 png_byte *data; 587 png_size_t size; 588 589 /* libpng-using applications should NOT directly modify this byte. */ 590 png_byte location; /* mode of operation at read time */ 591 } 592 png_unknown_chunk; 593 typedef png_unknown_chunk FAR * png_unknown_chunkp; 594 typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; 595 #endif 596 597 /* png_info is a structure that holds the information in a PNG file so 598 * that the application can find out the characteristics of the image. 599 * If you are reading the file, this structure will tell you what is 600 * in the PNG file. If you are writing the file, fill in the information 601 * you want to put into the PNG file, then call png_write_info(). 602 * The names chosen should be very close to the PNG specification, so 603 * consult that document for information about the meaning of each field. 604 * 605 * With libpng < 0.95, it was only possible to directly set and read the 606 * the values in the png_info_struct, which meant that the contents and 607 * order of the values had to remain fixed. With libpng 0.95 and later, 608 * however, there are now functions that abstract the contents of 609 * png_info_struct from the application, so this makes it easier to use 610 * libpng with dynamic libraries, and even makes it possible to use 611 * libraries that don't have all of the libpng ancillary chunk-handing 612 * functionality. 613 * 614 * In any case, the order of the parameters in png_info_struct should NOT 615 * be changed for as long as possible to keep compatibility with applications 616 * that use the old direct-access method with png_info_struct. 617 * 618 * The following members may have allocated storage attached that should be 619 * cleaned up before the structure is discarded: palette, trans, text, 620 * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, 621 * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these 622 * are automatically freed when the info structure is deallocated, if they were 623 * allocated internally by libpng. This behavior can be changed by means 624 * of the png_data_freer() function. 625 * 626 * More allocation details: all the chunk-reading functions that 627 * change these members go through the corresponding png_set_* 628 * functions. A function to clear these members is available: see 629 * png_free_data(). The png_set_* functions do not depend on being 630 * able to point info structure members to any of the storage they are 631 * passed (they make their own copies), EXCEPT that the png_set_text 632 * functions use the same storage passed to them in the text_ptr or 633 * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns 634 * functions do not make their own copies. 635 */ 636 typedef struct png_info_struct 637 { 638 /* the following are necessary for every PNG file */ 639 png_uint_32 width PNG_DEPSTRUCT; /* width of image in pixels (from IHDR) */ 640 png_uint_32 height PNG_DEPSTRUCT; /* height of image in pixels (from IHDR) */ 641 png_uint_32 valid PNG_DEPSTRUCT; /* valid chunk data (see PNG_INFO_ 642 below) */ 643 png_size_t rowbytes PNG_DEPSTRUCT; /* bytes needed to hold an untransformed 644 row */ 645 png_colorp palette PNG_DEPSTRUCT; /* array of color values 646 (valid & PNG_INFO_PLTE) */ 647 png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in 648 "palette" (PLTE) */ 649 png_uint_16 num_trans PNG_DEPSTRUCT; /* number of transparent palette 650 color (tRNS) */ 651 png_byte bit_depth PNG_DEPSTRUCT; /* 1, 2, 4, 8, or 16 bits/channel 652 (from IHDR) */ 653 png_byte color_type PNG_DEPSTRUCT; /* see PNG_COLOR_TYPE_ below 654 (from IHDR) */ 655 /* The following three should have been named *_method not *_type */ 656 png_byte compression_type PNG_DEPSTRUCT; /* must be 657 PNG_COMPRESSION_TYPE_BASE (IHDR) */ 658 png_byte filter_type PNG_DEPSTRUCT; /* must be PNG_FILTER_TYPE_BASE 659 (from IHDR) */ 660 png_byte interlace_type PNG_DEPSTRUCT; /* One of PNG_INTERLACE_NONE, 661 PNG_INTERLACE_ADAM7 */ 662 663 /* The following is informational only on read, and not used on writes. */ 664 png_byte channels PNG_DEPSTRUCT; /* number of data channels per 665 pixel (1, 2, 3, 4) */ 666 png_byte pixel_depth PNG_DEPSTRUCT; /* number of bits per pixel */ 667 png_byte spare_byte PNG_DEPSTRUCT; /* to align the data, and for 668 future use */ 669 png_byte signature[8] PNG_DEPSTRUCT; /* magic bytes read by libpng 670 from start of file */ 671 672 /* The rest of the data is optional. If you are reading, check the 673 * valid field to see if the information in these are valid. If you 674 * are writing, set the valid field to those chunks you want written, 675 * and initialize the appropriate fields below. 676 */ 677 678 #if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) 679 /* The gAMA chunk describes the gamma characteristics of the system 680 * on which the image was created, normally in the range [1.0, 2.5]. 681 * Data is valid if (valid & PNG_INFO_gAMA) is non-zero. 682 */ 683 float gamma PNG_DEPSTRUCT; /* gamma value of image, 684 if (valid & PNG_INFO_gAMA) */ 685 #endif 686 687 #ifdef PNG_sRGB_SUPPORTED 688 /* GR-P, 0.96a */ 689 /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ 690 png_byte srgb_intent PNG_DEPSTRUCT; /* sRGB rendering intent 691 [0, 1, 2, or 3] */ 692 #endif 693 694 #ifdef PNG_TEXT_SUPPORTED 695 /* The tEXt, and zTXt chunks contain human-readable textual data in 696 * uncompressed, compressed, and optionally compressed forms, respectively. 697 * The data in "text" is an array of pointers to uncompressed, 698 * null-terminated C strings. Each chunk has a keyword that describes the 699 * textual data contained in that chunk. Keywords are not required to be 700 * unique, and the text string may be empty. Any number of text chunks may 701 * be in an image. 702 */ 703 int num_text PNG_DEPSTRUCT; /* number of comments read/to write */ 704 int max_text PNG_DEPSTRUCT; /* current size of text array */ 705 png_textp text PNG_DEPSTRUCT; /* array of comments read/to write */ 706 #endif /* PNG_TEXT_SUPPORTED */ 707 708 #ifdef PNG_tIME_SUPPORTED 709 /* The tIME chunk holds the last time the displayed image data was 710 * modified. See the png_time struct for the contents of this struct. 711 */ 712 png_time mod_time PNG_DEPSTRUCT; 713 #endif 714 715 #ifdef PNG_sBIT_SUPPORTED 716 /* The sBIT chunk specifies the number of significant high-order bits 717 * in the pixel data. Values are in the range [1, bit_depth], and are 718 * only specified for the channels in the pixel data. The contents of 719 * the low-order bits is not specified. Data is valid if 720 * (valid & PNG_INFO_sBIT) is non-zero. 721 */ 722 png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in color channels */ 723 #endif 724 725 #if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ 726 defined(PNG_READ_BACKGROUND_SUPPORTED) 727 /* The tRNS chunk supplies transparency data for paletted images and 728 * other image types that don't need a full alpha channel. There are 729 * "num_trans" transparency values for a paletted image, stored in the 730 * same order as the palette colors, starting from index 0. Values 731 * for the data are in the range [0, 255], ranging from fully transparent 732 * to fully opaque, respectively. For non-paletted images, there is a 733 * single color specified that should be treated as fully transparent. 734 * Data is valid if (valid & PNG_INFO_tRNS) is non-zero. 735 */ 736 png_bytep trans_alpha PNG_DEPSTRUCT; /* alpha values for paletted 737 image */ 738 png_color_16 trans_color PNG_DEPSTRUCT; /* transparent color for 739 non-palette image */ 740 #endif 741 742 #if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) 743 /* The bKGD chunk gives the suggested image background color if the 744 * display program does not have its own background color and the image 745 * is needs to composited onto a background before display. The colors 746 * in "background" are normally in the same color space/depth as the 747 * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. 748 */ 749 png_color_16 background PNG_DEPSTRUCT; 750 #endif 751 752 #ifdef PNG_oFFs_SUPPORTED 753 /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards 754 * and downwards from the top-left corner of the display, page, or other 755 * application-specific co-ordinate space. See the PNG_OFFSET_ defines 756 * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. 757 */ 758 png_int_32 x_offset PNG_DEPSTRUCT; /* x offset on page */ 759 png_int_32 y_offset PNG_DEPSTRUCT; /* y offset on page */ 760 png_byte offset_unit_type PNG_DEPSTRUCT; /* offset units type */ 761 #endif 762 763 #ifdef PNG_pHYs_SUPPORTED 764 /* The pHYs chunk gives the physical pixel density of the image for 765 * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ 766 * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. 767 */ 768 png_uint_32 x_pixels_per_unit PNG_DEPSTRUCT; /* horizontal pixel density */ 769 png_uint_32 y_pixels_per_unit PNG_DEPSTRUCT; /* vertical pixel density */ 770 png_byte phys_unit_type PNG_DEPSTRUCT; /* resolution type (see 771 PNG_RESOLUTION_ below) */ 772 #endif 773 774 #ifdef PNG_hIST_SUPPORTED 775 /* The hIST chunk contains the relative frequency or importance of the 776 * various palette entries, so that a viewer can intelligently select a 777 * reduced-color palette, if required. Data is an array of "num_palette" 778 * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) 779 * is non-zero. 780 */ 781 png_uint_16p hist PNG_DEPSTRUCT; 782 #endif 783 784 #ifdef PNG_cHRM_SUPPORTED 785 /* The cHRM chunk describes the CIE color characteristics of the monitor 786 * on which the PNG was created. This data allows the viewer to do gamut 787 * mapping of the input image to ensure that the viewer sees the same 788 * colors in the image as the creator. Values are in the range 789 * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. 790 */ 791 #ifdef PNG_FLOATING_POINT_SUPPORTED 792 float x_white PNG_DEPSTRUCT; 793 float y_white PNG_DEPSTRUCT; 794 float x_red PNG_DEPSTRUCT; 795 float y_red PNG_DEPSTRUCT; 796 float x_green PNG_DEPSTRUCT; 797 float y_green PNG_DEPSTRUCT; 798 float x_blue PNG_DEPSTRUCT; 799 float y_blue PNG_DEPSTRUCT; 800 #endif 801 #endif 802 803 #ifdef PNG_pCAL_SUPPORTED 804 /* The pCAL chunk describes a transformation between the stored pixel 805 * values and original physical data values used to create the image. 806 * The integer range [0, 2^bit_depth - 1] maps to the floating-point 807 * range given by [pcal_X0, pcal_X1], and are further transformed by a 808 * (possibly non-linear) transformation function given by "pcal_type" 809 * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ 810 * defines below, and the PNG-Group's PNG extensions document for a 811 * complete description of the transformations and how they should be 812 * implemented, and for a description of the ASCII parameter strings. 813 * Data values are valid if (valid & PNG_INFO_pCAL) non-zero. 814 */ 815 png_charp pcal_purpose PNG_DEPSTRUCT; /* pCAL chunk description string */ 816 png_int_32 pcal_X0 PNG_DEPSTRUCT; /* minimum value */ 817 png_int_32 pcal_X1 PNG_DEPSTRUCT; /* maximum value */ 818 png_charp pcal_units PNG_DEPSTRUCT; /* Latin-1 string giving physical 819 units */ 820 png_charpp pcal_params PNG_DEPSTRUCT; /* ASCII strings containing 821 parameter values */ 822 png_byte pcal_type PNG_DEPSTRUCT; /* equation type 823 (see PNG_EQUATION_ below) */ 824 png_byte pcal_nparams PNG_DEPSTRUCT; /* number of parameters given 825 in pcal_params */ 826 #endif 827 828 /* New members added in libpng-1.0.6 */ 829 png_uint_32 free_me PNG_DEPSTRUCT; /* flags items libpng is 830 responsible for freeing */ 831 832 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ 833 defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) 834 /* Storage for unknown chunks that the library doesn't recognize. */ 835 png_unknown_chunkp unknown_chunks PNG_DEPSTRUCT; 836 png_size_t unknown_chunks_num PNG_DEPSTRUCT; 837 #endif 838 839 #ifdef PNG_iCCP_SUPPORTED 840 /* iCCP chunk data. */ 841 png_charp iccp_name PNG_DEPSTRUCT; /* profile name */ 842 png_charp iccp_profile PNG_DEPSTRUCT; /* International Color Consortium 843 profile data */ 844 /* Note to maintainer: should be png_bytep */ 845 png_uint_32 iccp_proflen PNG_DEPSTRUCT; /* ICC profile data length */ 846 png_byte iccp_compression PNG_DEPSTRUCT; /* Always zero */ 847 #endif 848 849 #ifdef PNG_sPLT_SUPPORTED 850 /* Data on sPLT chunks (there may be more than one). */ 851 png_sPLT_tp splt_palettes PNG_DEPSTRUCT; 852 png_uint_32 splt_palettes_num PNG_DEPSTRUCT; 853 #endif 854 855 #ifdef PNG_sCAL_SUPPORTED 856 /* The sCAL chunk describes the actual physical dimensions of the 857 * subject matter of the graphic. The chunk contains a unit specification 858 * a byte value, and two ASCII strings representing floating-point 859 * values. The values are width and height corresponsing to one pixel 860 * in the image. This external representation is converted to double 861 * here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero. 862 */ 863 png_byte scal_unit PNG_DEPSTRUCT; /* unit of physical scale */ 864 #ifdef PNG_FLOATING_POINT_SUPPORTED 865 double scal_pixel_width PNG_DEPSTRUCT; /* width of one pixel */ 866 double scal_pixel_height PNG_DEPSTRUCT; /* height of one pixel */ 867 #endif 868 #ifdef PNG_FIXED_POINT_SUPPORTED 869 png_charp scal_s_width PNG_DEPSTRUCT; /* string containing height */ 870 png_charp scal_s_height PNG_DEPSTRUCT; /* string containing width */ 871 #endif 872 #endif 873 874 #ifdef PNG_INFO_IMAGE_SUPPORTED 875 /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) 876 non-zero */ 877 /* Data valid if (valid & PNG_INFO_IDAT) non-zero */ 878 png_bytepp row_pointers PNG_DEPSTRUCT; /* the image bits */ 879 #endif 880 881 #if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED) 882 png_fixed_point int_gamma PNG_DEPSTRUCT; /* gamma of image, 883 if (valid & PNG_INFO_gAMA) */ 884 #endif 885 886 #if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED) 887 png_fixed_point int_x_white PNG_DEPSTRUCT; 888 png_fixed_point int_y_white PNG_DEPSTRUCT; 889 png_fixed_point int_x_red PNG_DEPSTRUCT; 890 png_fixed_point int_y_red PNG_DEPSTRUCT; 891 png_fixed_point int_x_green PNG_DEPSTRUCT; 892 png_fixed_point int_y_green PNG_DEPSTRUCT; 893 png_fixed_point int_x_blue PNG_DEPSTRUCT; 894 png_fixed_point int_y_blue PNG_DEPSTRUCT; 895 #endif 896 897 } png_info; 898 899 typedef png_info FAR * png_infop; 900 typedef png_info FAR * FAR * png_infopp; 901 902 /* Maximum positive integer used in PNG is (2^31)-1 */ 903 #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL) 904 #define PNG_UINT_32_MAX ((png_uint_32)(-1)) 905 #define PNG_SIZE_MAX ((png_size_t)(-1)) 906 907 /* These describe the color_type field in png_info. */ 908 /* color type masks */ 909 #define PNG_COLOR_MASK_PALETTE 1 910 #define PNG_COLOR_MASK_COLOR 2 911 #define PNG_COLOR_MASK_ALPHA 4 912 913 /* color types. Note that not all combinations are legal */ 914 #define PNG_COLOR_TYPE_GRAY 0 915 #define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE) 916 #define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR) 917 #define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) 918 #define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA) 919 /* aliases */ 920 #define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA 921 #define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA 922 923 /* This is for compression type. PNG 1.0-1.2 only define the single type. */ 924 #define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */ 925 #define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE 926 927 /* This is for filter type. PNG 1.0-1.2 only define the single type. */ 928 #define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */ 929 #define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */ 930 #define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE 931 932 /* These are for the interlacing type. These values should NOT be changed. */ 933 #define PNG_INTERLACE_NONE 0 /* Non-interlaced image */ 934 #define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */ 935 #define PNG_INTERLACE_LAST 2 /* Not a valid value */ 936 937 /* These are for the oFFs chunk. These values should NOT be changed. */ 938 #define PNG_OFFSET_PIXEL 0 /* Offset in pixels */ 939 #define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */ 940 #define PNG_OFFSET_LAST 2 /* Not a valid value */ 941 942 /* These are for the pCAL chunk. These values should NOT be changed. */ 943 #define PNG_EQUATION_LINEAR 0 /* Linear transformation */ 944 #define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */ 945 #define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */ 946 #define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */ 947 #define PNG_EQUATION_LAST 4 /* Not a valid value */ 948 949 /* These are for the sCAL chunk. These values should NOT be changed. */ 950 #define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */ 951 #define PNG_SCALE_METER 1 /* meters per pixel */ 952 #define PNG_SCALE_RADIAN 2 /* radians per pixel */ 953 #define PNG_SCALE_LAST 3 /* Not a valid value */ 954 955 /* These are for the pHYs chunk. These values should NOT be changed. */ 956 #define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */ 957 #define PNG_RESOLUTION_METER 1 /* pixels/meter */ 958 #define PNG_RESOLUTION_LAST 2 /* Not a valid value */ 959 960 /* These are for the sRGB chunk. These values should NOT be changed. */ 961 #define PNG_sRGB_INTENT_PERCEPTUAL 0 962 #define PNG_sRGB_INTENT_RELATIVE 1 963 #define PNG_sRGB_INTENT_SATURATION 2 964 #define PNG_sRGB_INTENT_ABSOLUTE 3 965 #define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */ 966 967 /* This is for text chunks */ 968 #define PNG_KEYWORD_MAX_LENGTH 79 969 970 /* Maximum number of entries in PLTE/sPLT/tRNS arrays */ 971 #define PNG_MAX_PALETTE_LENGTH 256 972 973 /* These determine if an ancillary chunk's data has been successfully read 974 * from the PNG header, or if the application has filled in the corresponding 975 * data in the info_struct to be written into the output file. The values 976 * of the PNG_INFO_<chunk> defines should NOT be changed. 977 */ 978 #define PNG_INFO_gAMA 0x0001 979 #define PNG_INFO_sBIT 0x0002 980 #define PNG_INFO_cHRM 0x0004 981 #define PNG_INFO_PLTE 0x0008 982 #define PNG_INFO_tRNS 0x0010 983 #define PNG_INFO_bKGD 0x0020 984 #define PNG_INFO_hIST 0x0040 985 #define PNG_INFO_pHYs 0x0080 986 #define PNG_INFO_oFFs 0x0100 987 #define PNG_INFO_tIME 0x0200 988 #define PNG_INFO_pCAL 0x0400 989 #define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ 990 #define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ 991 #define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ 992 #define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ 993 #define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ 994 995 /* This is used for the transformation routines, as some of them 996 * change these values for the row. It also should enable using 997 * the routines for other purposes. 998 */ 999 typedef struct png_row_info_struct 1000 { 1001 png_uint_32 width; /* width of row */ 1002 png_size_t rowbytes; /* number of bytes in row */ 1003 png_byte color_type; /* color type of row */ 1004 png_byte bit_depth; /* bit depth of row */ 1005 png_byte channels; /* number of channels (1, 2, 3, or 4) */ 1006 png_byte pixel_depth; /* bits per pixel (depth * channels) */ 1007 } png_row_info; 1008 1009 typedef png_row_info FAR * png_row_infop; 1010 typedef png_row_info FAR * FAR * png_row_infopp; 1011 1012 /* These are the function types for the I/O functions and for the functions 1013 * that allow the user to override the default I/O functions with his or her 1014 * own. The png_error_ptr type should match that of user-supplied warning 1015 * and error functions, while the png_rw_ptr type should match that of the 1016 * user read/write data functions. 1017 */ 1018 typedef struct png_struct_def png_struct; 1019 typedef png_struct FAR * png_structp; 1020 1021 typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); 1022 typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); 1023 typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); 1024 typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, 1025 int)); 1026 typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, 1027 int)); 1028 1029 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED 1030 typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, 1031 png_infop)); 1032 typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); 1033 typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, 1034 png_uint_32, int)); 1035 #endif 1036 1037 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ 1038 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) 1039 typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, 1040 png_row_infop, png_bytep)); 1041 #endif 1042 1043 #ifdef PNG_USER_CHUNKS_SUPPORTED 1044 typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, 1045 png_unknown_chunkp)); 1046 #endif 1047 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED 1048 typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); 1049 #endif 1050 #ifdef PNG_SETJMP_SUPPORTED 1051 /* This must match the function definition in <setjmp.h>, and the 1052 * application must include this before png.h to obtain the definition 1053 * of jmp_buf. 1054 */ 1055 typedef void (PNGAPI *png_longjmp_ptr) PNGARG((jmp_buf, int)); 1056 #endif 1057 1058 /* Transform masks for the high-level interface */ 1059 #define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ 1060 #define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ 1061 #define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ 1062 #define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ 1063 #define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ 1064 #define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ 1065 #define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ 1066 #define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ 1067 #define PNG_TRANSFORM_BGR 0x0080 /* read and write */ 1068 #define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ 1069 #define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ 1070 #define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ 1071 #define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */ 1072 /* Added to libpng-1.2.34 */ 1073 #define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER 1074 #define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ 1075 /* Added to libpng-1.4.0 */ 1076 #define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ 1077 1078 /* Flags for MNG supported features */ 1079 #define PNG_FLAG_MNG_EMPTY_PLTE 0x01 1080 #define PNG_FLAG_MNG_FILTER_64 0x04 1081 #define PNG_ALL_MNG_FEATURES 0x05 1082 1083 typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_alloc_size_t)); 1084 typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); 1085 1086 /* The structure that holds the information to read and write PNG files. 1087 * The only people who need to care about what is inside of this are the 1088 * people who will be modifying the library for their own special needs. 1089 * It should NOT be accessed directly by an application, except to store 1090 * the jmp_buf. 1091 */ 1092 1093 struct png_struct_def 1094 { 1095 #ifdef PNG_SETJMP_SUPPORTED 1096 jmp_buf jmpbuf PNG_DEPSTRUCT; /* used in png_error */ 1097 png_longjmp_ptr longjmp_fn PNG_DEPSTRUCT;/* setjmp non-local goto 1098 function. */ 1099 #endif 1100 png_error_ptr error_fn PNG_DEPSTRUCT; /* function for printing 1101 errors and aborting */ 1102 png_error_ptr warning_fn PNG_DEPSTRUCT; /* function for printing 1103 warnings */ 1104 png_voidp error_ptr PNG_DEPSTRUCT; /* user supplied struct for 1105 error functions */ 1106 png_rw_ptr write_data_fn PNG_DEPSTRUCT; /* function for writing 1107 output data */ 1108 png_rw_ptr read_data_fn PNG_DEPSTRUCT; /* function for reading 1109 input data */ 1110 png_voidp io_ptr PNG_DEPSTRUCT; /* ptr to application struct 1111 for I/O functions */ 1112 1113 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED 1114 png_user_transform_ptr read_user_transform_fn PNG_DEPSTRUCT; /* user read 1115 transform */ 1116 #endif 1117 1118 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED 1119 png_user_transform_ptr write_user_transform_fn PNG_DEPSTRUCT; /* user write 1120 transform */ 1121 #endif 1122 1123 /* These were added in libpng-1.0.2 */ 1124 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED 1125 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ 1126 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) 1127 png_voidp user_transform_ptr PNG_DEPSTRUCT; /* user supplied struct 1128 for user transform */ 1129 png_byte user_transform_depth PNG_DEPSTRUCT; /* bit depth of user 1130 transformed pixels */ 1131 png_byte user_transform_channels PNG_DEPSTRUCT; /* channels in user 1132 transformed pixels */ 1133 #endif 1134 #endif 1135 1136 png_uint_32 mode PNG_DEPSTRUCT; /* tells us where we are in 1137 the PNG file */ 1138 png_uint_32 flags PNG_DEPSTRUCT; /* flags indicating various 1139 things to libpng */ 1140 png_uint_32 transformations PNG_DEPSTRUCT; /* which transformations 1141 to perform */ 1142 1143 z_stream zstream PNG_DEPSTRUCT; /* pointer to decompression 1144 structure (below) */ 1145 png_bytep zbuf PNG_DEPSTRUCT; /* buffer for zlib */ 1146 png_size_t zbuf_size PNG_DEPSTRUCT; /* size of zbuf */ 1147 int zlib_level PNG_DEPSTRUCT; /* holds zlib compression level */ 1148 int zlib_method PNG_DEPSTRUCT; /* holds zlib compression method */ 1149 int zlib_window_bits PNG_DEPSTRUCT; /* holds zlib compression window 1150 bits */ 1151 int zlib_mem_level PNG_DEPSTRUCT; /* holds zlib compression memory 1152 level */ 1153 int zlib_strategy PNG_DEPSTRUCT; /* holds zlib compression 1154 strategy */ 1155 1156 png_uint_32 width PNG_DEPSTRUCT; /* width of image in pixels */ 1157 png_uint_32 height PNG_DEPSTRUCT; /* height of image in pixels */ 1158 png_uint_32 num_rows PNG_DEPSTRUCT; /* number of rows in current pass */ 1159 png_uint_32 usr_width PNG_DEPSTRUCT; /* width of row at start of write */ 1160 png_size_t rowbytes PNG_DEPSTRUCT; /* size of row in bytes */ 1161 #if 0 /* Replaced with the following in libpng-1.4.1 */ 1162 png_size_t irowbytes PNG_DEPSTRUCT; 1163 #endif 1164 /* Added in libpng-1.4.1 */ 1165 #ifdef PNG_USER_LIMITS_SUPPORTED 1166 /* Total memory that a zTXt, sPLT, iTXt, iCCP, or unknown chunk 1167 * can occupy when decompressed. 0 means unlimited. 1168 * We will change the typedef from png_size_t to png_alloc_size_t 1169 * in libpng-1.6.0 1170 */ 1171 png_alloc_size_t user_chunk_malloc_max PNG_DEPSTRUCT; 1172 #endif 1173 png_uint_32 iwidth PNG_DEPSTRUCT; /* width of current interlaced 1174 row in pixels */ 1175 png_uint_32 row_number PNG_DEPSTRUCT; /* current row in interlace pass */ 1176 png_bytep prev_row PNG_DEPSTRUCT; /* buffer to save previous 1177 (unfiltered) row */ 1178 png_bytep row_buf PNG_DEPSTRUCT; /* buffer to save current 1179 (unfiltered) row */ 1180 png_bytep sub_row PNG_DEPSTRUCT; /* buffer to save "sub" row 1181 when filtering */ 1182 png_bytep up_row PNG_DEPSTRUCT; /* buffer to save "up" row 1183 when filtering */ 1184 png_bytep avg_row PNG_DEPSTRUCT; /* buffer to save "avg" row 1185 when filtering */ 1186 png_bytep paeth_row PNG_DEPSTRUCT; /* buffer to save "Paeth" row 1187 when filtering */ 1188 png_row_info row_info PNG_DEPSTRUCT; /* used for transformation 1189 routines */ 1190 1191 png_uint_32 idat_size PNG_DEPSTRUCT; /* current IDAT size for read */ 1192 png_uint_32 crc PNG_DEPSTRUCT; /* current chunk CRC value */ 1193 png_colorp palette PNG_DEPSTRUCT; /* palette from the input file */ 1194 png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in 1195 palette */ 1196 png_uint_16 num_trans PNG_DEPSTRUCT; /* number of transparency values */ 1197 png_byte chunk_name[5] PNG_DEPSTRUCT; /* null-terminated name of current 1198 chunk */ 1199 png_byte compression PNG_DEPSTRUCT; /* file compression type 1200 (always 0) */ 1201 png_byte filter PNG_DEPSTRUCT; /* file filter type (always 0) */ 1202 png_byte interlaced PNG_DEPSTRUCT; /* PNG_INTERLACE_NONE, 1203 PNG_INTERLACE_ADAM7 */ 1204 png_byte pass PNG_DEPSTRUCT; /* current interlace pass (0 - 6) */ 1205 png_byte do_filter PNG_DEPSTRUCT; /* row filter flags (see 1206 PNG_FILTER_ below ) */ 1207 png_byte color_type PNG_DEPSTRUCT; /* color type of file */ 1208 png_byte bit_depth PNG_DEPSTRUCT; /* bit depth of file */ 1209 png_byte usr_bit_depth PNG_DEPSTRUCT; /* bit depth of users row */ 1210 png_byte pixel_depth PNG_DEPSTRUCT; /* number of bits per pixel */ 1211 png_byte channels PNG_DEPSTRUCT; /* number of channels in file */ 1212 png_byte usr_channels PNG_DEPSTRUCT; /* channels at start of write */ 1213 png_byte sig_bytes PNG_DEPSTRUCT; /* magic bytes read/written from 1214 start of file */ 1215 1216 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) 1217 png_uint_16 filler PNG_DEPSTRUCT; /* filler bytes for pixel 1218 expansion */ 1219 #endif 1220 1221 #ifdef PNG_bKGD_SUPPORTED 1222 png_byte background_gamma_type PNG_DEPSTRUCT; 1223 # ifdef PNG_FLOATING_POINT_SUPPORTED 1224 float background_gamma PNG_DEPSTRUCT; 1225 # endif 1226 png_color_16 background PNG_DEPSTRUCT; /* background color in 1227 screen gamma space */ 1228 #ifdef PNG_READ_GAMMA_SUPPORTED 1229 png_color_16 background_1 PNG_DEPSTRUCT; /* background normalized 1230 to gamma 1.0 */ 1231 #endif 1232 #endif /* PNG_bKGD_SUPPORTED */ 1233 1234 #ifdef PNG_WRITE_FLUSH_SUPPORTED 1235 png_flush_ptr output_flush_fn PNG_DEPSTRUCT; /* Function for flushing 1236 output */ 1237 png_uint_32 flush_dist PNG_DEPSTRUCT; /* how many rows apart to flush, 1238 0 - no flush */ 1239 png_uint_32 flush_rows PNG_DEPSTRUCT; /* number of rows written since 1240 last flush */ 1241 #endif 1242 1243 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) 1244 int gamma_shift PNG_DEPSTRUCT; /* number of "insignificant" bits 1245 16-bit gamma */ 1246 #ifdef PNG_FLOATING_POINT_SUPPORTED 1247 float gamma PNG_DEPSTRUCT; /* file gamma value */ 1248 float screen_gamma PNG_DEPSTRUCT; /* screen gamma value 1249 (display_exponent) */ 1250 #endif 1251 #endif 1252 1253 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) 1254 png_bytep gamma_table PNG_DEPSTRUCT; /* gamma table for 8-bit 1255 depth files */ 1256 png_bytep gamma_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to screen */ 1257 png_bytep gamma_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */ 1258 png_uint_16pp gamma_16_table PNG_DEPSTRUCT; /* gamma table for 16-bit 1259 depth files */ 1260 png_uint_16pp gamma_16_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to 1261 screen */ 1262 png_uint_16pp gamma_16_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */ 1263 #endif 1264 1265 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) 1266 png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in each 1267 available channel */ 1268 #endif 1269 1270 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) 1271 png_color_8 shift PNG_DEPSTRUCT; /* shift for significant bit 1272 tranformation */ 1273 #endif 1274 1275 #if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ 1276 || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) 1277 png_bytep trans_alpha PNG_DEPSTRUCT; /* alpha values for 1278 paletted files */ 1279 png_color_16 trans_color PNG_DEPSTRUCT; /* transparent color for 1280 non-paletted files */ 1281 #endif 1282 1283 png_read_status_ptr read_row_fn PNG_DEPSTRUCT; /* called after each 1284 row is decoded */ 1285 png_write_status_ptr write_row_fn PNG_DEPSTRUCT; /* called after each 1286 row is encoded */ 1287 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED 1288 png_progressive_info_ptr info_fn PNG_DEPSTRUCT; /* called after header 1289 data fully read */ 1290 png_progressive_row_ptr row_fn PNG_DEPSTRUCT; /* called after each 1291 prog. row is decoded */ 1292 png_progressive_end_ptr end_fn PNG_DEPSTRUCT; /* called after image 1293 is complete */ 1294 png_bytep save_buffer_ptr PNG_DEPSTRUCT; /* current location in 1295 save_buffer */ 1296 png_bytep save_buffer PNG_DEPSTRUCT; /* buffer for previously 1297 read data */ 1298 png_bytep current_buffer_ptr PNG_DEPSTRUCT; /* current location in 1299 current_buffer */ 1300 png_bytep current_buffer PNG_DEPSTRUCT; /* buffer for recently 1301 used data */ 1302 png_uint_32 push_length PNG_DEPSTRUCT; /* size of current input 1303 chunk */ 1304 png_uint_32 skip_length PNG_DEPSTRUCT; /* bytes to skip in 1305 input data */ 1306 png_size_t save_buffer_size PNG_DEPSTRUCT; /* amount of data now 1307 in save_buffer */ 1308 png_size_t save_buffer_max PNG_DEPSTRUCT; /* total size of 1309 save_buffer */ 1310 png_size_t buffer_size PNG_DEPSTRUCT; /* total amount of 1311 available input data */ 1312 png_size_t current_buffer_size PNG_DEPSTRUCT; /* amount of data now 1313 in current_buffer */ 1314 int process_mode PNG_DEPSTRUCT; /* what push library 1315 is currently doing */ 1316 int cur_palette PNG_DEPSTRUCT; /* current push library 1317 palette index */ 1318 1319 # ifdef PNG_TEXT_SUPPORTED 1320 png_size_t current_text_size PNG_DEPSTRUCT; /* current size of 1321 text input data */ 1322 png_size_t current_text_left PNG_DEPSTRUCT; /* how much text left 1323 to read in input */ 1324 png_charp current_text PNG_DEPSTRUCT; /* current text chunk 1325 buffer */ 1326 png_charp current_text_ptr PNG_DEPSTRUCT; /* current location 1327 in current_text */ 1328 # endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */ 1329 1330 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ 1331 1332 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) 1333 /* For the Borland special 64K segment handler */ 1334 png_bytepp offset_table_ptr PNG_DEPSTRUCT; 1335 png_bytep offset_table PNG_DEPSTRUCT; 1336 png_uint_16 offset_table_number PNG_DEPSTRUCT; 1337 png_uint_16 offset_table_count PNG_DEPSTRUCT; 1338 png_uint_16 offset_table_count_free PNG_DEPSTRUCT; 1339 #endif 1340 1341 #ifdef PNG_READ_QUANTIZE_SUPPORTED 1342 png_bytep palette_lookup PNG_DEPSTRUCT; /* lookup table for quantizing */ 1343 png_bytep quantize_index PNG_DEPSTRUCT; /* index translation for palette 1344 files */ 1345 #endif 1346 1347 #if defined(PNG_READ_QUANTIZE_SUPPORTED) || defined(PNG_hIST_SUPPORTED) 1348 png_uint_16p hist PNG_DEPSTRUCT; /* histogram */ 1349 #endif 1350 1351 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED 1352 png_byte heuristic_method PNG_DEPSTRUCT; /* heuristic for row 1353 filter selection */ 1354 png_byte num_prev_filters PNG_DEPSTRUCT; /* number of weights 1355 for previous rows */ 1356 png_bytep prev_filters PNG_DEPSTRUCT; /* filter type(s) of 1357 previous row(s) */ 1358 png_uint_16p filter_weights PNG_DEPSTRUCT; /* weight(s) for previous 1359 line(s) */ 1360 png_uint_16p inv_filter_weights PNG_DEPSTRUCT; /* 1/weight(s) for 1361 previous line(s) */ 1362 png_uint_16p filter_costs PNG_DEPSTRUCT; /* relative filter 1363 calculation cost */ 1364 png_uint_16p inv_filter_costs PNG_DEPSTRUCT; /* 1/relative filter 1365 calculation cost */ 1366 #endif 1367 1368 #ifdef PNG_TIME_RFC1123_SUPPORTED 1369 png_charp time_buffer PNG_DEPSTRUCT; /* String to hold RFC 1123 time text */ 1370 #endif 1371 1372 /* New members added in libpng-1.0.6 */ 1373 1374 png_uint_32 free_me PNG_DEPSTRUCT; /* flags items libpng is 1375 responsible for freeing */ 1376 1377 #ifdef PNG_USER_CHUNKS_SUPPORTED 1378 png_voidp user_chunk_ptr PNG_DEPSTRUCT; 1379 png_user_chunk_ptr read_user_chunk_fn PNG_DEPSTRUCT; /* user read 1380 chunk handler */ 1381 #endif 1382 1383 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 1384 int num_chunk_list PNG_DEPSTRUCT; 1385 png_bytep chunk_list PNG_DEPSTRUCT; 1386 #endif 1387 1388 /* New members added in libpng-1.0.3 */ 1389 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 1390 png_byte rgb_to_gray_status PNG_DEPSTRUCT; 1391 /* These were changed from png_byte in libpng-1.0.6 */ 1392 png_uint_16 rgb_to_gray_red_coeff PNG_DEPSTRUCT; 1393 png_uint_16 rgb_to_gray_green_coeff PNG_DEPSTRUCT; 1394 png_uint_16 rgb_to_gray_blue_coeff PNG_DEPSTRUCT; 1395 #endif 1396 1397 /* New member added in libpng-1.0.4 (renamed in 1.0.9) */ 1398 #if defined(PNG_MNG_FEATURES_SUPPORTED) || \ 1399 defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ 1400 defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) 1401 /* Changed from png_byte to png_uint_32 at version 1.2.0 */ 1402 png_uint_32 mng_features_permitted PNG_DEPSTRUCT; 1403 #endif 1404 1405 /* New member added in libpng-1.0.7 */ 1406 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) 1407 png_fixed_point int_gamma PNG_DEPSTRUCT; 1408 #endif 1409 1410 /* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ 1411 #ifdef PNG_MNG_FEATURES_SUPPORTED 1412 png_byte filter_type PNG_DEPSTRUCT; 1413 #endif 1414 1415 /* New members added in libpng-1.2.0 */ 1416 1417 /* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ 1418 #ifdef PNG_USER_MEM_SUPPORTED 1419 png_voidp mem_ptr PNG_DEPSTRUCT; /* user supplied struct for 1420 mem functions */ 1421 png_malloc_ptr malloc_fn PNG_DEPSTRUCT; /* function for 1422 allocating memory */ 1423 png_free_ptr free_fn PNG_DEPSTRUCT; /* function for 1424 freeing memory */ 1425 #endif 1426 1427 /* New member added in libpng-1.0.13 and 1.2.0 */ 1428 png_bytep big_row_buf PNG_DEPSTRUCT; /* buffer to save current 1429 (unfiltered) row */ 1430 1431 #ifdef PNG_READ_QUANTIZE_SUPPORTED 1432 /* The following three members were added at version 1.0.14 and 1.2.4 */ 1433 png_bytep quantize_sort PNG_DEPSTRUCT; /* working sort array */ 1434 png_bytep index_to_palette PNG_DEPSTRUCT; /* where the original 1435 index currently is 1436 in the palette */ 1437 png_bytep palette_to_index PNG_DEPSTRUCT; /* which original index 1438 points to this 1439 palette color */ 1440 #endif 1441 1442 /* New members added in libpng-1.0.16 and 1.2.6 */ 1443 png_byte compression_type PNG_DEPSTRUCT; 1444 1445 #ifdef PNG_USER_LIMITS_SUPPORTED 1446 png_uint_32 user_width_max PNG_DEPSTRUCT; 1447 png_uint_32 user_height_max PNG_DEPSTRUCT; 1448 /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown 1449 * chunks that can be stored (0 means unlimited). 1450 */ 1451 png_uint_32 user_chunk_cache_max PNG_DEPSTRUCT; 1452 #endif 1453 1454 /* New member added in libpng-1.0.25 and 1.2.17 */ 1455 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED 1456 /* Storage for unknown chunk that the library doesn't recognize. */ 1457 png_unknown_chunk unknown_chunk PNG_DEPSTRUCT; 1458 #endif 1459 1460 /* New members added in libpng-1.2.26 */ 1461 png_uint_32 old_big_row_buf_size PNG_DEPSTRUCT; 1462 png_uint_32 old_prev_row_size PNG_DEPSTRUCT; 1463 1464 /* New member added in libpng-1.2.30 */ 1465 png_charp chunkdata PNG_DEPSTRUCT; /* buffer for reading chunk data */ 1466 1467 #ifdef PNG_IO_STATE_SUPPORTED 1468 /* New member added in libpng-1.4.0 */ 1469 png_uint_32 io_state PNG_DEPSTRUCT; 1470 #endif 1471 }; 1472 1473 1474 /* This triggers a compiler error in png.c, if png.c and png.h 1475 * do not agree upon the version number. 1476 */ 1477 typedef png_structp version_1_4_3; 1478 1479 typedef png_struct FAR * FAR * png_structpp; 1480 1481 /* Here are the function definitions most commonly used. This is not 1482 * the place to find out how to use libpng. See libpng.txt for the 1483 * full explanation, see example.c for the summary. This just provides 1484 * a simple one line description of the use of each function. 1485 */ 1486 1487 /* Returns the version number of the library */ 1488 extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); 1489 1490 /* Tell lib we have already handled the first <num_bytes> magic bytes. 1491 * Handling more than 8 bytes from the beginning of the file is an error. 1492 */ 1493 extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, 1494 int num_bytes)); 1495 1496 /* Check sig[start] through sig[start + num_to_check - 1] to see if it's a 1497 * PNG file. Returns zero if the supplied bytes match the 8-byte PNG 1498 * signature, and non-zero otherwise. Having num_to_check == 0 or 1499 * start > 7 will always fail (ie return non-zero). 1500 */ 1501 extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, 1502 png_size_t num_to_check)); 1503 1504 /* Simple signature checking function. This is the same as calling 1505 * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). 1506 */ 1507 #define png_check_sig(sig,n) !png_sig_cmp((sig), 0, (n)) 1508 1509 /* Allocate and initialize png_ptr struct for reading, and any other memory. */ 1510 extern PNG_EXPORT(png_structp,png_create_read_struct) 1511 PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, 1512 png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED; 1513 1514 /* Allocate and initialize png_ptr struct for writing, and any other memory */ 1515 extern PNG_EXPORT(png_structp,png_create_write_struct) 1516 PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, 1517 png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED; 1518 1519 extern PNG_EXPORT(png_size_t,png_get_compression_buffer_size) 1520 PNGARG((png_structp png_ptr)); 1521 1522 extern PNG_EXPORT(void,png_set_compression_buffer_size) 1523 PNGARG((png_structp png_ptr, png_size_t size)); 1524 1525 /* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp 1526 * match up. 1527 */ 1528 #ifdef PNG_SETJMP_SUPPORTED 1529 /* This function returns the jmp_buf built in to *png_ptr. It must be 1530 * supplied with an appropriate 'longjmp' function to use on that jmp_buf 1531 * unless the default error function is overridden in which case NULL is 1532 * acceptable. The size of the jmp_buf is checked against the actual size 1533 * allocated by the library - the call will return NULL on a mismatch 1534 * indicating an ABI mismatch. 1535 */ 1536 extern PNG_EXPORT(jmp_buf*, png_set_longjmp_fn) 1537 PNGARG((png_structp png_ptr, png_longjmp_ptr longjmp_fn, size_t 1538 jmp_buf_size)); 1539 # define png_jmpbuf(png_ptr) \ 1540 (*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf))) 1541 #else 1542 # define png_jmpbuf(png_ptr) \ 1543 (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) 1544 #endif 1545 1546 #ifdef PNG_READ_SUPPORTED 1547 /* Reset the compression stream */ 1548 extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); 1549 #endif 1550 1551 /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ 1552 #ifdef PNG_USER_MEM_SUPPORTED 1553 extern PNG_EXPORT(png_structp,png_create_read_struct_2) 1554 PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, 1555 png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, 1556 png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED; 1557 extern PNG_EXPORT(png_structp,png_create_write_struct_2) 1558 PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, 1559 png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, 1560 png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED; 1561 #endif 1562 1563 /* Write the PNG file signature. */ 1564 extern PNG_EXPORT(void,png_write_sig) PNGARG((png_structp png_ptr)); 1565 1566 /* Write a PNG chunk - size, type, (optional) data, CRC. */ 1567 extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, 1568 png_bytep chunk_name, png_bytep data, png_size_t length)); 1569 1570 /* Write the start of a PNG chunk - length and chunk name. */ 1571 extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, 1572 png_bytep chunk_name, png_uint_32 length)); 1573 1574 /* Write the data of a PNG chunk started with png_write_chunk_start(). */ 1575 extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, 1576 png_bytep data, png_size_t length)); 1577 1578 /* Finish a chunk started with png_write_chunk_start() (includes CRC). */ 1579 extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); 1580 1581 /* Allocate and initialize the info structure */ 1582 extern PNG_EXPORT(png_infop,png_create_info_struct) 1583 PNGARG((png_structp png_ptr)) PNG_ALLOCATED; 1584 1585 extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, 1586 png_size_t png_info_struct_size)); 1587 1588 /* Writes all the PNG information before the image. */ 1589 extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, 1590 png_infop info_ptr)); 1591 extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, 1592 png_infop info_ptr)); 1593 1594 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1595 /* Read the information before the actual image data. */ 1596 extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, 1597 png_infop info_ptr)); 1598 #endif 1599 1600 #ifdef PNG_TIME_RFC1123_SUPPORTED 1601 extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) 1602 PNGARG((png_structp png_ptr, png_timep ptime)); 1603 #endif 1604 1605 #ifdef PNG_CONVERT_tIME_SUPPORTED 1606 /* Convert from a struct tm to png_time */ 1607 extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, 1608 struct tm FAR * ttime)); 1609 1610 /* Convert from time_t to png_time. Uses gmtime() */ 1611 extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, 1612 time_t ttime)); 1613 #endif /* PNG_CONVERT_tIME_SUPPORTED */ 1614 1615 #ifdef PNG_READ_EXPAND_SUPPORTED 1616 /* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ 1617 extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); 1618 extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp 1619 png_ptr)); 1620 extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); 1621 extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); 1622 #endif 1623 1624 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) 1625 /* Use blue, green, red order for pixels. */ 1626 extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); 1627 #endif 1628 1629 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED 1630 /* Expand the grayscale to 24-bit RGB if necessary. */ 1631 extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); 1632 #endif 1633 1634 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 1635 /* Reduce RGB to grayscale. */ 1636 #ifdef PNG_FLOATING_POINT_SUPPORTED 1637 extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, 1638 int error_action, double red, double green )); 1639 #endif 1640 extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, 1641 int error_action, png_fixed_point red, png_fixed_point green )); 1642 extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp 1643 png_ptr)); 1644 #endif 1645 1646 extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, 1647 png_colorp palette)); 1648 1649 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED 1650 extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); 1651 #endif 1652 1653 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ 1654 defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) 1655 extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); 1656 #endif 1657 1658 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ 1659 defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) 1660 extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); 1661 #endif 1662 1663 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) 1664 /* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ 1665 extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, 1666 png_uint_32 filler, int flags)); 1667 /* The values of the PNG_FILLER_ defines should NOT be changed */ 1668 #define PNG_FILLER_BEFORE 0 1669 #define PNG_FILLER_AFTER 1 1670 /* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ 1671 extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr, 1672 png_uint_32 filler, int flags)); 1673 #endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ 1674 1675 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) 1676 /* Swap bytes in 16-bit depth files. */ 1677 extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); 1678 #endif 1679 1680 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) 1681 /* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ 1682 extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); 1683 #endif 1684 1685 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ 1686 defined(PNG_WRITE_PACKSWAP_SUPPORTED) 1687 /* Swap packing order of pixels in bytes. */ 1688 extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); 1689 #endif 1690 1691 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) 1692 /* Converts files to legal bit depths. */ 1693 extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, 1694 png_color_8p true_bits)); 1695 #endif 1696 1697 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \ 1698 defined(PNG_WRITE_INTERLACING_SUPPORTED) 1699 /* Have the code handle the interlacing. Returns the number of passes. */ 1700 extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); 1701 #endif 1702 1703 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) 1704 /* Invert monochrome files */ 1705 extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); 1706 #endif 1707 1708 #ifdef PNG_READ_BACKGROUND_SUPPORTED 1709 /* Handle alpha and tRNS by replacing with a background color. */ 1710 #ifdef PNG_FLOATING_POINT_SUPPORTED 1711 extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, 1712 png_color_16p background_color, int background_gamma_code, 1713 int need_expand, double background_gamma)); 1714 #endif 1715 #define PNG_BACKGROUND_GAMMA_UNKNOWN 0 1716 #define PNG_BACKGROUND_GAMMA_SCREEN 1 1717 #define PNG_BACKGROUND_GAMMA_FILE 2 1718 #define PNG_BACKGROUND_GAMMA_UNIQUE 3 1719 #endif 1720 1721 #ifdef PNG_READ_16_TO_8_SUPPORTED 1722 /* Strip the second byte of information from a 16-bit depth file. */ 1723 extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); 1724 #endif 1725 1726 #ifdef PNG_READ_QUANTIZE_SUPPORTED 1727 /* Turn on quantizing, and reduce the palette to the number of colors 1728 * available. Prior to libpng-1.4.2, this was png_set_dither(). 1729 */ 1730 extern PNG_EXPORT(void,png_set_quantize) PNGARG((png_structp png_ptr, 1731 png_colorp palette, int num_palette, int maximum_colors, 1732 png_uint_16p histogram, int full_quantize)); 1733 #endif 1734 /* This migration aid will be removed from libpng-1.5.0 */ 1735 #define png_set_dither png_set_quantize 1736 1737 #ifdef PNG_READ_GAMMA_SUPPORTED 1738 /* Handle gamma correction. Screen_gamma=(display_exponent) */ 1739 #ifdef PNG_FLOATING_POINT_SUPPORTED 1740 extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, 1741 double screen_gamma, double default_file_gamma)); 1742 #endif 1743 #endif 1744 1745 1746 #ifdef PNG_WRITE_FLUSH_SUPPORTED 1747 /* Set how many lines between output flushes - 0 for no flushing */ 1748 extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); 1749 /* Flush the current PNG output buffer */ 1750 extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); 1751 #endif 1752 1753 /* Optional update palette with requested transformations */ 1754 extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); 1755 1756 /* Optional call to update the users info structure */ 1757 extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, 1758 png_infop info_ptr)); 1759 1760 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1761 /* Read one or more rows of image data. */ 1762 extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, 1763 png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); 1764 #endif 1765 1766 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1767 /* Read a row of data. */ 1768 extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, 1769 png_bytep row, 1770 png_bytep display_row)); 1771 #endif 1772 1773 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1774 /* Read the whole image into memory at once. */ 1775 extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, 1776 png_bytepp image)); 1777 #endif 1778 1779 /* Write a row of image data */ 1780 extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, 1781 png_bytep row)); 1782 1783 /* Write a few rows of image data */ 1784 extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, 1785 png_bytepp row, png_uint_32 num_rows)); 1786 1787 /* Write the image data */ 1788 extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, 1789 png_bytepp image)); 1790 1791 /* Write the end of the PNG file. */ 1792 extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, 1793 png_infop info_ptr)); 1794 1795 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1796 /* Read the end of the PNG file. */ 1797 extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, 1798 png_infop info_ptr)); 1799 #endif 1800 1801 /* Free any memory associated with the png_info_struct */ 1802 extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, 1803 png_infopp info_ptr_ptr)); 1804 1805 /* Free any memory associated with the png_struct and the png_info_structs */ 1806 extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp 1807 png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); 1808 1809 /* Free any memory associated with the png_struct and the png_info_structs */ 1810 extern PNG_EXPORT(void,png_destroy_write_struct) 1811 PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); 1812 1813 /* Set the libpng method of handling chunk CRC errors */ 1814 extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, 1815 int crit_action, int ancil_action)); 1816 1817 /* Values for png_set_crc_action() to say how to handle CRC errors in 1818 * ancillary and critical chunks, and whether to use the data contained 1819 * therein. Note that it is impossible to "discard" data in a critical 1820 * chunk. For versions prior to 0.90, the action was always error/quit, 1821 * whereas in version 0.90 and later, the action for CRC errors in ancillary 1822 * chunks is warn/discard. These values should NOT be changed. 1823 * 1824 * value action:critical action:ancillary 1825 */ 1826 #define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ 1827 #define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ 1828 #define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ 1829 #define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ 1830 #define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ 1831 #define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ 1832 1833 /* These functions give the user control over the scan-line filtering in 1834 * libpng and the compression methods used by zlib. These functions are 1835 * mainly useful for testing, as the defaults should work with most users. 1836 * Those users who are tight on memory or want faster performance at the 1837 * expense of compression can modify them. See the compression library 1838 * header file (zlib.h) for an explination of the compression functions. 1839 */ 1840 1841 /* Set the filtering method(s) used by libpng. Currently, the only valid 1842 * value for "method" is 0. 1843 */ 1844 extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, 1845 int filters)); 1846 1847 /* Flags for png_set_filter() to say which filters to use. The flags 1848 * are chosen so that they don't conflict with real filter types 1849 * below, in case they are supplied instead of the #defined constants. 1850 * These values should NOT be changed. 1851 */ 1852 #define PNG_NO_FILTERS 0x00 1853 #define PNG_FILTER_NONE 0x08 1854 #define PNG_FILTER_SUB 0x10 1855 #define PNG_FILTER_UP 0x20 1856 #define PNG_FILTER_AVG 0x40 1857 #define PNG_FILTER_PAETH 0x80 1858 #define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ 1859 PNG_FILTER_AVG | PNG_FILTER_PAETH) 1860 1861 /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. 1862 * These defines should NOT be changed. 1863 */ 1864 #define PNG_FILTER_VALUE_NONE 0 1865 #define PNG_FILTER_VALUE_SUB 1 1866 #define PNG_FILTER_VALUE_UP 2 1867 #define PNG_FILTER_VALUE_AVG 3 1868 #define PNG_FILTER_VALUE_PAETH 4 1869 #define PNG_FILTER_VALUE_LAST 5 1870 1871 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* EXPERIMENTAL */ 1872 /* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ 1873 * defines, either the default (minimum-sum-of-absolute-differences), or 1874 * the experimental method (weighted-minimum-sum-of-absolute-differences). 1875 * 1876 * Weights are factors >= 1.0, indicating how important it is to keep the 1877 * filter type consistent between rows. Larger numbers mean the current 1878 * filter is that many times as likely to be the same as the "num_weights" 1879 * previous filters. This is cumulative for each previous row with a weight. 1880 * There needs to be "num_weights" values in "filter_weights", or it can be 1881 * NULL if the weights aren't being specified. Weights have no influence on 1882 * the selection of the first row filter. Well chosen weights can (in theory) 1883 * improve the compression for a given image. 1884 * 1885 * Costs are factors >= 1.0 indicating the relative decoding costs of a 1886 * filter type. Higher costs indicate more decoding expense, and are 1887 * therefore less likely to be selected over a filter with lower computational 1888 * costs. There needs to be a value in "filter_costs" for each valid filter 1889 * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't 1890 * setting the costs. Costs try to improve the speed of decompression without 1891 * unduly increasing the compressed image size. 1892 * 1893 * A negative weight or cost indicates the default value is to be used, and 1894 * values in the range [0.0, 1.0) indicate the value is to remain unchanged. 1895 * The default values for both weights and costs are currently 1.0, but may 1896 * change if good general weighting/cost heuristics can be found. If both 1897 * the weights and costs are set to 1.0, this degenerates the WEIGHTED method 1898 * to the UNWEIGHTED method, but with added encoding time/computation. 1899 */ 1900 #ifdef PNG_FLOATING_POINT_SUPPORTED 1901 extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, 1902 int heuristic_method, int num_weights, png_doublep filter_weights, 1903 png_doublep filter_costs)); 1904 #endif 1905 #endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ 1906 1907 /* Heuristic used for row filter selection. These defines should NOT be 1908 * changed. 1909 */ 1910 #define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ 1911 #define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ 1912 #define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ 1913 #define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ 1914 1915 /* Set the library compression level. Currently, valid values range from 1916 * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 1917 * (0 - no compression, 9 - "maximal" compression). Note that tests have 1918 * shown that zlib compression levels 3-6 usually perform as well as level 9 1919 * for PNG images, and do considerably fewer caclulations. In the future, 1920 * these values may not correspond directly to the zlib compression levels. 1921 */ 1922 extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, 1923 int level)); 1924 1925 extern PNG_EXPORT(void,png_set_compression_mem_level) 1926 PNGARG((png_structp png_ptr, int mem_level)); 1927 1928 extern PNG_EXPORT(void,png_set_compression_strategy) 1929 PNGARG((png_structp png_ptr, int strategy)); 1930 1931 extern PNG_EXPORT(void,png_set_compression_window_bits) 1932 PNGARG((png_structp png_ptr, int window_bits)); 1933 1934 extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, 1935 int method)); 1936 1937 /* These next functions are called for input/output, memory, and error 1938 * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, 1939 * and call standard C I/O routines such as fread(), fwrite(), and 1940 * fprintf(). These functions can be made to use other I/O routines 1941 * at run time for those applications that need to handle I/O in a 1942 * different manner by calling png_set_???_fn(). See libpng.txt for 1943 * more information. 1944 */ 1945 1946 #ifdef PNG_STDIO_SUPPORTED 1947 /* Initialize the input/output for the PNG file to the default functions. */ 1948 extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, 1949 png_FILE_p fp)); 1950 #endif 1951 1952 /* Replace the (error and abort), and warning functions with user 1953 * supplied functions. If no messages are to be printed you must still 1954 * write and use replacement functions. The replacement error_fn should 1955 * still do a longjmp to the last setjmp location if you are using this 1956 * method of error handling. If error_fn or warning_fn is NULL, the 1957 * default function will be used. 1958 */ 1959 1960 extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, 1961 png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); 1962 1963 /* Return the user pointer associated with the error functions */ 1964 extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); 1965 1966 /* Replace the default data output functions with a user supplied one(s). 1967 * If buffered output is not used, then output_flush_fn can be set to NULL. 1968 * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time 1969 * output_flush_fn will be ignored (and thus can be NULL). 1970 * It is probably a mistake to use NULL for output_flush_fn if 1971 * write_data_fn is not also NULL unless you have built libpng with 1972 * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's 1973 * default flush function, which uses the standard *FILE structure, will 1974 * be used. 1975 */ 1976 extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, 1977 png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); 1978 1979 /* Replace the default data input function with a user supplied one. */ 1980 extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, 1981 png_voidp io_ptr, png_rw_ptr read_data_fn)); 1982 1983 /* Return the user pointer associated with the I/O functions */ 1984 extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); 1985 1986 extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, 1987 png_read_status_ptr read_row_fn)); 1988 1989 extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, 1990 png_write_status_ptr write_row_fn)); 1991 1992 #ifdef PNG_USER_MEM_SUPPORTED 1993 /* Replace the default memory allocation functions with user supplied one(s). */ 1994 extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, 1995 png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); 1996 /* Return the user pointer associated with the memory functions */ 1997 extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); 1998 #endif 1999 2000 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED 2001 extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp 2002 png_ptr, png_user_transform_ptr read_user_transform_fn)); 2003 #endif 2004 2005 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED 2006 extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp 2007 png_ptr, png_user_transform_ptr write_user_transform_fn)); 2008 #endif 2009 2010 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ 2011 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) 2012 extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp 2013 png_ptr, png_voidp user_transform_ptr, int user_transform_depth, 2014 int user_transform_channels)); 2015 /* Return the user pointer associated with the user transform functions */ 2016 extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) 2017 PNGARG((png_structp png_ptr)); 2018 #endif 2019 2020 #ifdef PNG_USER_CHUNKS_SUPPORTED 2021 extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, 2022 png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); 2023 extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp 2024 png_ptr)); 2025 #endif 2026 2027 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED 2028 /* Sets the function callbacks for the push reader, and a pointer to a 2029 * user-defined structure available to the callback functions. 2030 */ 2031 extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, 2032 png_voidp progressive_ptr, 2033 png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, 2034 png_progressive_end_ptr end_fn)); 2035 2036 /* Returns the user pointer associated with the push read functions */ 2037 extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) 2038 PNGARG((png_structp png_ptr)); 2039 2040 /* Function to be called when data becomes available */ 2041 extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, 2042 png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); 2043 2044 /* Function that combines rows. Not very much different than the 2045 * png_combine_row() call. Is this even used????? 2046 */ 2047 extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, 2048 png_bytep old_row, png_bytep new_row)); 2049 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ 2050 2051 extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, 2052 png_alloc_size_t size)) PNG_ALLOCATED; 2053 /* Added at libpng version 1.4.0 */ 2054 extern PNG_EXPORT(png_voidp,png_calloc) PNGARG((png_structp png_ptr, 2055 png_alloc_size_t size)) PNG_ALLOCATED; 2056 2057 /* Added at libpng version 1.2.4 */ 2058 extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, 2059 png_alloc_size_t size)) PNG_ALLOCATED; 2060 2061 /* Frees a pointer allocated by png_malloc() */ 2062 extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); 2063 2064 /* Free data that was allocated internally */ 2065 extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, 2066 png_infop info_ptr, png_uint_32 free_me, int num)); 2067 /* Reassign responsibility for freeing existing data, whether allocated 2068 * by libpng or by the application */ 2069 extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, 2070 png_infop info_ptr, int freer, png_uint_32 mask)); 2071 /* Assignments for png_data_freer */ 2072 #define PNG_DESTROY_WILL_FREE_DATA 1 2073 #define PNG_SET_WILL_FREE_DATA 1 2074 #define PNG_USER_WILL_FREE_DATA 2 2075 /* Flags for png_ptr->free_me and info_ptr->free_me */ 2076 #define PNG_FREE_HIST 0x0008 2077 #define PNG_FREE_ICCP 0x0010 2078 #define PNG_FREE_SPLT 0x0020 2079 #define PNG_FREE_ROWS 0x0040 2080 #define PNG_FREE_PCAL 0x0080 2081 #define PNG_FREE_SCAL 0x0100 2082 #define PNG_FREE_UNKN 0x0200 2083 #define PNG_FREE_LIST 0x0400 2084 #define PNG_FREE_PLTE 0x1000 2085 #define PNG_FREE_TRNS 0x2000 2086 #define PNG_FREE_TEXT 0x4000 2087 #define PNG_FREE_ALL 0x7fff 2088 #define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ 2089 2090 #ifdef PNG_USER_MEM_SUPPORTED 2091 extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, 2092 png_alloc_size_t size)) PNG_ALLOCATED; 2093 extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, 2094 png_voidp ptr)); 2095 #endif 2096 2097 #ifndef PNG_NO_ERROR_TEXT 2098 /* Fatal error in PNG image of libpng - can't continue */ 2099 extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, 2100 png_const_charp error_message)) PNG_NORETURN; 2101 2102 /* The same, but the chunk name is prepended to the error string. */ 2103 extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, 2104 png_const_charp error_message)) PNG_NORETURN; 2105 2106 #else 2107 /* Fatal error in PNG image of libpng - can't continue */ 2108 extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr)) PNG_NORETURN; 2109 #endif 2110 2111 /* Non-fatal error in libpng. Can continue, but may have a problem. */ 2112 extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, 2113 png_const_charp warning_message)); 2114 2115 /* Non-fatal error in libpng, chunk name is prepended to message. */ 2116 extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, 2117 png_const_charp warning_message)); 2118 2119 #ifdef PNG_BENIGN_ERRORS_SUPPORTED 2120 /* Benign error in libpng. Can continue, but may have a problem. 2121 * User can choose whether to handle as a fatal error or as a warning. */ 2122 extern PNG_EXPORT(void,png_benign_error) PNGARG((png_structp png_ptr, 2123 png_const_charp warning_message)); 2124 2125 /* Same, chunk name is prepended to message. */ 2126 extern PNG_EXPORT(void,png_chunk_benign_error) PNGARG((png_structp png_ptr, 2127 png_const_charp warning_message)); 2128 2129 extern PNG_EXPORT(void,png_set_benign_errors) PNGARG((png_structp 2130 png_ptr, int allowed)); 2131 #endif 2132 2133 /* The png_set_<chunk> functions are for storing values in the png_info_struct. 2134 * Similarly, the png_get_<chunk> calls are used to read values from the 2135 * png_info_struct, either storing the parameters in the passed variables, or 2136 * setting pointers into the png_info_struct where the data is stored. The 2137 * png_get_<chunk> functions return a non-zero value if the data was available 2138 * in info_ptr, or return zero and do not change any of the parameters if the 2139 * data was not available. 2140 * 2141 * These functions should be used instead of directly accessing png_info 2142 * to avoid problems with future changes in the size and internal layout of 2143 * png_info_struct. 2144 */ 2145 /* Returns "flag" if chunk data is valid in info_ptr. */ 2146 extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, 2147 png_infop info_ptr, png_uint_32 flag)); 2148 2149 /* Returns number of bytes needed to hold a transformed row. */ 2150 extern PNG_EXPORT(png_size_t,png_get_rowbytes) PNGARG((png_structp png_ptr, 2151 png_infop info_ptr)); 2152 2153 #ifdef PNG_INFO_IMAGE_SUPPORTED 2154 /* Returns row_pointers, which is an array of pointers to scanlines that was 2155 * returned from png_read_png(). 2156 */ 2157 extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, 2158 png_infop info_ptr)); 2159 /* Set row_pointers, which is an array of pointers to scanlines for use 2160 * by png_write_png(). 2161 */ 2162 extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, 2163 png_infop info_ptr, png_bytepp row_pointers)); 2164 #endif 2165 2166 /* Returns number of color channels in image. */ 2167 extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, 2168 png_infop info_ptr)); 2169 2170 #ifdef PNG_EASY_ACCESS_SUPPORTED 2171 /* Returns image width in pixels. */ 2172 extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp 2173 png_ptr, png_infop info_ptr)); 2174 2175 /* Returns image height in pixels. */ 2176 extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp 2177 png_ptr, png_infop info_ptr)); 2178 2179 /* Returns image bit_depth. */ 2180 extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp 2181 png_ptr, png_infop info_ptr)); 2182 2183 /* Returns image color_type. */ 2184 extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp 2185 png_ptr, png_infop info_ptr)); 2186 2187 /* Returns image filter_type. */ 2188 extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp 2189 png_ptr, png_infop info_ptr)); 2190 2191 /* Returns image interlace_type. */ 2192 extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp 2193 png_ptr, png_infop info_ptr)); 2194 2195 /* Returns image compression_type. */ 2196 extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp 2197 png_ptr, png_infop info_ptr)); 2198 2199 /* Returns image resolution in pixels per meter, from pHYs chunk data. */ 2200 extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp 2201 png_ptr, png_infop info_ptr)); 2202 extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp 2203 png_ptr, png_infop info_ptr)); 2204 extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp 2205 png_ptr, png_infop info_ptr)); 2206 2207 /* Returns pixel aspect ratio, computed from pHYs chunk data. */ 2208 #ifdef PNG_FLOATING_POINT_SUPPORTED 2209 extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp 2210 png_ptr, png_infop info_ptr)); 2211 #endif 2212 2213 /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ 2214 extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp 2215 png_ptr, png_infop info_ptr)); 2216 extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp 2217 png_ptr, png_infop info_ptr)); 2218 extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp 2219 png_ptr, png_infop info_ptr)); 2220 extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp 2221 png_ptr, png_infop info_ptr)); 2222 2223 #endif /* PNG_EASY_ACCESS_SUPPORTED */ 2224 2225 /* Returns pointer to signature string read from PNG header */ 2226 extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, 2227 png_infop info_ptr)); 2228 2229 #ifdef PNG_bKGD_SUPPORTED 2230 extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, 2231 png_infop info_ptr, png_color_16p *background)); 2232 #endif 2233 2234 #ifdef PNG_bKGD_SUPPORTED 2235 extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, 2236 png_infop info_ptr, png_color_16p background)); 2237 #endif 2238 2239 #ifdef PNG_cHRM_SUPPORTED 2240 #ifdef PNG_FLOATING_POINT_SUPPORTED 2241 extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, 2242 png_infop info_ptr, double *white_x, double *white_y, double *red_x, 2243 double *red_y, double *green_x, double *green_y, double *blue_x, 2244 double *blue_y)); 2245 #endif 2246 #ifdef PNG_FIXED_POINT_SUPPORTED 2247 extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, 2248 png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point 2249 *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, 2250 png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point 2251 *int_blue_x, png_fixed_point *int_blue_y)); 2252 #endif 2253 #endif 2254 2255 #ifdef PNG_cHRM_SUPPORTED 2256 #ifdef PNG_FLOATING_POINT_SUPPORTED 2257 extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, 2258 png_infop info_ptr, double white_x, double white_y, double red_x, 2259 double red_y, double green_x, double green_y, double blue_x, double blue_y)); 2260 #endif 2261 #ifdef PNG_FIXED_POINT_SUPPORTED 2262 extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, 2263 png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, 2264 png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point 2265 int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, 2266 png_fixed_point int_blue_y)); 2267 #endif 2268 #endif 2269 2270 #ifdef PNG_gAMA_SUPPORTED 2271 #ifdef PNG_FLOATING_POINT_SUPPORTED 2272 extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, 2273 png_infop info_ptr, double *file_gamma)); 2274 #endif 2275 extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, 2276 png_infop info_ptr, png_fixed_point *int_file_gamma)); 2277 #endif 2278 2279 #ifdef PNG_gAMA_SUPPORTED 2280 #ifdef PNG_FLOATING_POINT_SUPPORTED 2281 extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, 2282 png_infop info_ptr, double file_gamma)); 2283 #endif 2284 extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, 2285 png_infop info_ptr, png_fixed_point int_file_gamma)); 2286 #endif 2287 2288 #ifdef PNG_hIST_SUPPORTED 2289 extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, 2290 png_infop info_ptr, png_uint_16p *hist)); 2291 #endif 2292 2293 #ifdef PNG_hIST_SUPPORTED 2294 extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, 2295 png_infop info_ptr, png_uint_16p hist)); 2296 #endif 2297 2298 extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, 2299 png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, 2300 int *bit_depth, int *color_type, int *interlace_method, 2301 int *compression_method, int *filter_method)); 2302 2303 extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, 2304 png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, 2305 int color_type, int interlace_method, int compression_method, 2306 int filter_method)); 2307 2308 #ifdef PNG_oFFs_SUPPORTED 2309 extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, 2310 png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, 2311 int *unit_type)); 2312 #endif 2313 2314 #ifdef PNG_oFFs_SUPPORTED 2315 extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, 2316 png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, 2317 int unit_type)); 2318 #endif 2319 2320 #ifdef PNG_pCAL_SUPPORTED 2321 extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, 2322 png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, 2323 int *type, int *nparams, png_charp *units, png_charpp *params)); 2324 #endif 2325 2326 #ifdef PNG_pCAL_SUPPORTED 2327 extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, 2328 png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, 2329 int type, int nparams, png_charp units, png_charpp params)); 2330 #endif 2331 2332 #ifdef PNG_pHYs_SUPPORTED 2333 extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, 2334 png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); 2335 #endif 2336 2337 #ifdef PNG_pHYs_SUPPORTED 2338 extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, 2339 png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); 2340 #endif 2341 2342 extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, 2343 png_infop info_ptr, png_colorp *palette, int *num_palette)); 2344 2345 extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, 2346 png_infop info_ptr, png_colorp palette, int num_palette)); 2347 2348 #ifdef PNG_sBIT_SUPPORTED 2349 extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, 2350 png_infop info_ptr, png_color_8p *sig_bit)); 2351 #endif 2352 2353 #ifdef PNG_sBIT_SUPPORTED 2354 extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, 2355 png_infop info_ptr, png_color_8p sig_bit)); 2356 #endif 2357 2358 #ifdef PNG_sRGB_SUPPORTED 2359 extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, 2360 png_infop info_ptr, int *intent)); 2361 #endif 2362 2363 #ifdef PNG_sRGB_SUPPORTED 2364 extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, 2365 png_infop info_ptr, int intent)); 2366 extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, 2367 png_infop info_ptr, int intent)); 2368 #endif 2369 2370 #ifdef PNG_iCCP_SUPPORTED 2371 extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, 2372 png_infop info_ptr, png_charpp name, int *compression_type, 2373 png_charpp profile, png_uint_32 *proflen)); 2374 /* Note to maintainer: profile should be png_bytepp */ 2375 #endif 2376 2377 #ifdef PNG_iCCP_SUPPORTED 2378 extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, 2379 png_infop info_ptr, png_charp name, int compression_type, 2380 png_charp profile, png_uint_32 proflen)); 2381 /* Note to maintainer: profile should be png_bytep */ 2382 #endif 2383 2384 #ifdef PNG_sPLT_SUPPORTED 2385 extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, 2386 png_infop info_ptr, png_sPLT_tpp entries)); 2387 #endif 2388 2389 #ifdef PNG_sPLT_SUPPORTED 2390 extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, 2391 png_infop info_ptr, png_sPLT_tp entries, int nentries)); 2392 #endif 2393 2394 #ifdef PNG_TEXT_SUPPORTED 2395 /* png_get_text also returns the number of text chunks in *num_text */ 2396 extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, 2397 png_infop info_ptr, png_textp *text_ptr, int *num_text)); 2398 #endif 2399 2400 /* Note while png_set_text() will accept a structure whose text, 2401 * language, and translated keywords are NULL pointers, the structure 2402 * returned by png_get_text will always contain regular 2403 * zero-terminated C strings. They might be empty strings but 2404 * they will never be NULL pointers. 2405 */ 2406 2407 #ifdef PNG_TEXT_SUPPORTED 2408 extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, 2409 png_infop info_ptr, png_textp text_ptr, int num_text)); 2410 #endif 2411 2412 #ifdef PNG_tIME_SUPPORTED 2413 extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, 2414 png_infop info_ptr, png_timep *mod_time)); 2415 #endif 2416 2417 #ifdef PNG_tIME_SUPPORTED 2418 extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, 2419 png_infop info_ptr, png_timep mod_time)); 2420 #endif 2421 2422 #ifdef PNG_tRNS_SUPPORTED 2423 extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, 2424 png_infop info_ptr, png_bytep *trans_alpha, int *num_trans, 2425 png_color_16p *trans_color)); 2426 #endif 2427 2428 #ifdef PNG_tRNS_SUPPORTED 2429 extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, 2430 png_infop info_ptr, png_bytep trans_alpha, int num_trans, 2431 png_color_16p trans_color)); 2432 #endif 2433 2434 #ifdef PNG_tRNS_SUPPORTED 2435 #endif 2436 2437 #ifdef PNG_sCAL_SUPPORTED 2438 #ifdef PNG_FLOATING_POINT_SUPPORTED 2439 extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, 2440 png_infop info_ptr, int *unit, double *width, double *height)); 2441 #else 2442 #ifdef PNG_FIXED_POINT_SUPPORTED 2443 extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, 2444 png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); 2445 #endif 2446 #endif 2447 #endif /* PNG_sCAL_SUPPORTED */ 2448 2449 #ifdef PNG_sCAL_SUPPORTED 2450 #ifdef PNG_FLOATING_POINT_SUPPORTED 2451 extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, 2452 png_infop info_ptr, int unit, double width, double height)); 2453 #else 2454 #ifdef PNG_FIXED_POINT_SUPPORTED 2455 extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, 2456 png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); 2457 #endif 2458 #endif 2459 #endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ 2460 2461 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 2462 /* Provide a list of chunks and how they are to be handled, if the built-in 2463 handling or default unknown chunk handling is not desired. Any chunks not 2464 listed will be handled in the default manner. The IHDR and IEND chunks 2465 must not be listed. 2466 keep = 0: follow default behaviour 2467 = 1: do not keep 2468 = 2: keep only if safe-to-copy 2469 = 3: keep even if unsafe-to-copy 2470 */ 2471 extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp 2472 png_ptr, int keep, png_bytep chunk_list, int num_chunks)); 2473 PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep 2474 chunk_name)); 2475 #endif 2476 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED 2477 extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, 2478 png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); 2479 extern PNG_EXPORT(void, png_set_unknown_chunk_location) 2480 PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); 2481 extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp 2482 png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); 2483 #endif 2484 2485 /* Png_free_data() will turn off the "valid" flag for anything it frees. 2486 * If you need to turn it off for a chunk that your application has freed, 2487 * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); 2488 */ 2489 extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, 2490 png_infop info_ptr, int mask)); 2491 2492 #ifdef PNG_INFO_IMAGE_SUPPORTED 2493 /* The "params" pointer is currently not used and is for future expansion. */ 2494 extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, 2495 png_infop info_ptr, 2496 int transforms, 2497 png_voidp params)); 2498 extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, 2499 png_infop info_ptr, 2500 int transforms, 2501 png_voidp params)); 2502 #endif 2503 2504 extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); 2505 extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); 2506 extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp 2507 png_ptr)); 2508 extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); 2509 2510 #ifdef PNG_MNG_FEATURES_SUPPORTED 2511 extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp 2512 png_ptr, png_uint_32 mng_features_permitted)); 2513 #endif 2514 2515 /* For use in png_set_keep_unknown, added to version 1.2.6 */ 2516 #define PNG_HANDLE_CHUNK_AS_DEFAULT 0 2517 #define PNG_HANDLE_CHUNK_NEVER 1 2518 #define PNG_HANDLE_CHUNK_IF_SAFE 2 2519 #define PNG_HANDLE_CHUNK_ALWAYS 3 2520 2521 /* Strip the prepended error numbers ("#nnn ") from error and warning 2522 * messages before passing them to the error or warning handler. 2523 */ 2524 #ifdef PNG_ERROR_NUMBERS_SUPPORTED 2525 extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp 2526 png_ptr, png_uint_32 strip_mode)); 2527 #endif 2528 2529 /* Added in libpng-1.2.6 */ 2530 #ifdef PNG_SET_USER_LIMITS_SUPPORTED 2531 extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp 2532 png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max)); 2533 extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp 2534 png_ptr)); 2535 extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp 2536 png_ptr)); 2537 /* Added in libpng-1.4.0 */ 2538 extern PNG_EXPORT(void,png_set_chunk_cache_max) PNGARG((png_structp 2539 png_ptr, png_uint_32 user_chunk_cache_max)); 2540 extern PNG_EXPORT(png_uint_32,png_get_chunk_cache_max) 2541 PNGARG((png_structp png_ptr)); 2542 /* Added in libpng-1.4.1 */ 2543 extern PNG_EXPORT(void,png_set_chunk_malloc_max) PNGARG((png_structp 2544 png_ptr, png_alloc_size_t user_chunk_cache_max)); 2545 extern PNG_EXPORT(png_alloc_size_t,png_get_chunk_malloc_max) 2546 PNGARG((png_structp png_ptr)); 2547 #endif 2548 2549 #if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) 2550 PNG_EXPORT(png_uint_32,png_get_pixels_per_inch) PNGARG((png_structp png_ptr, 2551 png_infop info_ptr)); 2552 2553 PNG_EXPORT(png_uint_32,png_get_x_pixels_per_inch) PNGARG((png_structp png_ptr, 2554 png_infop info_ptr)); 2555 2556 PNG_EXPORT(png_uint_32,png_get_y_pixels_per_inch) PNGARG((png_structp png_ptr, 2557 png_infop info_ptr)); 2558 2559 PNG_EXPORT(float,png_get_x_offset_inches) PNGARG((png_structp png_ptr, 2560 png_infop info_ptr)); 2561 2562 PNG_EXPORT(float,png_get_y_offset_inches) PNGARG((png_structp png_ptr, 2563 png_infop info_ptr)); 2564 2565 #ifdef PNG_pHYs_SUPPORTED 2566 PNG_EXPORT(png_uint_32,png_get_pHYs_dpi) PNGARG((png_structp png_ptr, 2567 png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); 2568 #endif /* PNG_pHYs_SUPPORTED */ 2569 #endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ 2570 2571 /* Added in libpng-1.4.0 */ 2572 #ifdef PNG_IO_STATE_SUPPORTED 2573 extern PNG_EXPORT(png_uint_32,png_get_io_state) PNGARG((png_structp png_ptr)); 2574 2575 extern PNG_EXPORT(png_bytep,png_get_io_chunk_name) 2576 PNGARG((png_structp png_ptr)); 2577 2578 /* The flags returned by png_get_io_state() are the following: */ 2579 #define PNG_IO_NONE 0x0000 /* no I/O at this moment */ 2580 #define PNG_IO_READING 0x0001 /* currently reading */ 2581 #define PNG_IO_WRITING 0x0002 /* currently writing */ 2582 #define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */ 2583 #define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */ 2584 #define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */ 2585 #define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ 2586 #define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ 2587 #define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ 2588 #endif /* ?PNG_IO_STATE_SUPPORTED */ 2589 2590 /* Maintainer: Put new public prototypes here ^, in libpng.3, and project 2591 * defs 2592 */ 2593 2594 #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED 2595 /* With these routines we avoid an integer divide, which will be slower on 2596 * most machines. However, it does take more operations than the corresponding 2597 * divide method, so it may be slower on a few RISC systems. There are two 2598 * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. 2599 * 2600 * Note that the rounding factors are NOT supposed to be the same! 128 and 2601 * 32768 are correct for the NODIV code; 127 and 32767 are correct for the 2602 * standard method. 2603 * 2604 * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] 2605 */ 2606 2607 /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ 2608 2609 # define png_composite(composite, fg, alpha, bg) \ 2610 { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \ 2611 * (png_uint_16)(alpha) \ 2612 + (png_uint_16)(bg)*(png_uint_16)(255 \ 2613 - (png_uint_16)(alpha)) + (png_uint_16)128); \ 2614 (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } 2615 2616 # define png_composite_16(composite, fg, alpha, bg) \ 2617 { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \ 2618 * (png_uint_32)(alpha) \ 2619 + (png_uint_32)(bg)*(png_uint_32)(65535L \ 2620 - (png_uint_32)(alpha)) + (png_uint_32)32768L); \ 2621 (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } 2622 2623 #else /* Standard method using integer division */ 2624 2625 # define png_composite(composite, fg, alpha, bg) \ 2626 (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ 2627 (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ 2628 (png_uint_16)127) / 255) 2629 2630 # define png_composite_16(composite, fg, alpha, bg) \ 2631 (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ 2632 (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ 2633 (png_uint_32)32767) / (png_uint_32)65535L) 2634 #endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ 2635 2636 #ifdef PNG_USE_READ_MACROS 2637 /* Inline macros to do direct reads of bytes from the input buffer. 2638 * The png_get_int_32() routine assumes we are using two's complement 2639 * format for negative values, which is almost certainly true. 2640 */ 2641 /* We could make special-case BIG_ENDIAN macros that do direct reads here */ 2642 # define png_get_uint_32(buf) \ 2643 (((png_uint_32)(*(buf)) << 24) + \ 2644 ((png_uint_32)(*((buf) + 1)) << 16) + \ 2645 ((png_uint_32)(*((buf) + 2)) << 8) + \ 2646 ((png_uint_32)(*((buf) + 3)))) 2647 # define png_get_uint_16(buf) \ 2648 (((png_uint_32)(*(buf)) << 8) + \ 2649 ((png_uint_32)(*((buf) + 1)))) 2650 #ifdef PNG_GET_INT_32_SUPPORTED 2651 # define png_get_int_32(buf) \ 2652 (((png_int_32)(*(buf)) << 24) + \ 2653 ((png_int_32)(*((buf) + 1)) << 16) + \ 2654 ((png_int_32)(*((buf) + 2)) << 8) + \ 2655 ((png_int_32)(*((buf) + 3)))) 2656 #endif 2657 #else 2658 extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf)); 2659 extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf)); 2660 #ifdef PNG_GET_INT_32_SUPPORTED 2661 extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf)); 2662 #endif 2663 #endif 2664 extern PNG_EXPORT(png_uint_32,png_get_uint_31) 2665 PNGARG((png_structp png_ptr, png_bytep buf)); 2666 /* No png_get_int_16 -- may be added if there's a real need for it. */ 2667 2668 /* Place a 32-bit number into a buffer in PNG byte order (big-endian). */ 2669 extern PNG_EXPORT(void,png_save_uint_32) 2670 PNGARG((png_bytep buf, png_uint_32 i)); 2671 extern PNG_EXPORT(void,png_save_int_32) 2672 PNGARG((png_bytep buf, png_int_32 i)); 2673 2674 /* Place a 16-bit number into a buffer in PNG byte order. 2675 * The parameter is declared unsigned int, not png_uint_16, 2676 * just to avoid potential problems on pre-ANSI C compilers. 2677 */ 2678 extern PNG_EXPORT(void,png_save_uint_16) 2679 PNGARG((png_bytep buf, unsigned int i)); 2680 /* No png_save_int_16 -- may be added if there's a real need for it. */ 2681 2682 /* ************************************************************************* */ 2683 2684 /* Various modes of operation. Note that after an init, mode is set to 2685 * zero automatically when the structure is created. 2686 */ 2687 #define PNG_HAVE_IHDR 0x01 2688 #define PNG_HAVE_PLTE 0x02 2689 #define PNG_HAVE_IDAT 0x04 2690 #define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */ 2691 #define PNG_HAVE_IEND 0x10 2692 #define PNG_HAVE_gAMA 0x20 2693 #define PNG_HAVE_cHRM 0x40 2694 2695 #ifdef __cplusplus 2696 } 2697 #endif 2698 2699 #endif /* PNG_VERSION_INFO_ONLY */ 2700 /* Do not put anything past this line */ 2701 #endif /* PNG_H */ 2702