From a2b5c390f31d7033c7941401841dde71a9cf4b08 Mon Sep 17 00:00:00 2001 From: Glenn Maynard Date: Tue, 18 May 2004 06:44:55 +0000 Subject: [PATCH] move windows libpng out of SDL_image --- stepmania/src/RageSurface_Load_PNG.cpp | 4 +- stepmania/src/libpng/include/png.h | 3283 +++++++++++++++++++++++ stepmania/src/libpng/include/pngconf.h | 1348 ++++++++++ stepmania/src/libpng/include/zconf.h | 279 ++ stepmania/src/libpng/include/zlib.h | 893 ++++++ stepmania/src/libpng/lib/libpng.lib | Bin 0 -> 293904 bytes stepmania/src/libpng/lib/xboxlibpng.lib | Bin 0 -> 351522 bytes 7 files changed, 5805 insertions(+), 2 deletions(-) create mode 100644 stepmania/src/libpng/include/png.h create mode 100644 stepmania/src/libpng/include/pngconf.h create mode 100644 stepmania/src/libpng/include/zconf.h create mode 100644 stepmania/src/libpng/include/zlib.h create mode 100644 stepmania/src/libpng/lib/libpng.lib create mode 100644 stepmania/src/libpng/lib/xboxlibpng.lib diff --git a/stepmania/src/RageSurface_Load_PNG.cpp b/stepmania/src/RageSurface_Load_PNG.cpp index 88532bfd09..bb5e4718cb 100644 --- a/stepmania/src/RageSurface_Load_PNG.cpp +++ b/stepmania/src/RageSurface_Load_PNG.cpp @@ -7,8 +7,8 @@ #include "RageFile.h" #if defined(WIN32) -#include "SDL_image-1.2/VisualC/graphics/include/png.h" -#pragma comment(lib, "SDL_image-1.2/VisualC/graphics/lib/libpng.lib") +#include "libpng/include/png.h" +#pragma comment(lib, "libpng/lib/libpng.lib") #pragma warning(disable: 4611) /* interaction between '_setjmp' and C++ object destruction is non-portable */ #else #include diff --git a/stepmania/src/libpng/include/png.h b/stepmania/src/libpng/include/png.h new file mode 100644 index 0000000000..f059910e62 --- /dev/null +++ b/stepmania/src/libpng/include/png.h @@ -0,0 +1,3283 @@ +/* png.h - header file for PNG reference library + * + * libpng version 1.2.5 - October 3, 2002 + * Copyright (c) 1998-2002 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * Authors and maintainers: + * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat + * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger + * libpng versions 0.97, January 1998, through 1.2.5 - October 3, 2002: Glenn + * See also "Contributing Authors", below. + * + * Note about libpng version numbers: + * + * Due to various miscommunications, unforeseen code incompatibilities + * and occasional factors outside the authors' control, version numbering + * on the library has not always been consistent and straightforward. + * The following table summarizes matters since version 0.89c, which was + * the first widely used release: + * + * source png.h png.h shared-lib + * version string int version + * ------- ------ ----- ---------- + * 0.89c "1.0 beta 3" 0.89 89 1.0.89 + * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] + * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] + * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] + * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] + * 0.97c 0.97 97 2.0.97 + * 0.98 0.98 98 2.0.98 + * 0.99 0.99 98 2.0.99 + * 0.99a-m 0.99 99 2.0.99 + * 1.00 1.00 100 2.1.0 [100 should be 10000] + * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] + * 1.0.1 png.h string is 10001 2.1.0 + * 1.0.1a-e identical to the 10002 from here on, the shared library + * 1.0.2 source version) 10002 is 2.V where V is the source code + * 1.0.2a-b 10003 version, except as noted. + * 1.0.3 10003 + * 1.0.3a-d 10004 + * 1.0.4 10004 + * 1.0.4a-f 10005 + * 1.0.5 (+ 2 patches) 10005 + * 1.0.5a-d 10006 + * 1.0.5e-r 10100 (not source compatible) + * 1.0.5s-v 10006 (not binary compatible) + * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) + * 1.0.6d-f 10007 (still binary incompatible) + * 1.0.6g 10007 + * 1.0.6h 10007 10.6h (testing xy.z so-numbering) + * 1.0.6i 10007 10.6i + * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) + * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) + * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) + * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) + * 1.0.7 1 10007 (still compatible) + * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 + * 1.0.8rc1 1 10008 2.1.0.8rc1 + * 1.0.8 1 10008 2.1.0.8 + * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 + * 1.0.9rc1 1 10009 2.1.0.9rc1 + * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 + * 1.0.9rc2 1 10009 2.1.0.9rc2 + * 1.0.9 1 10009 2.1.0.9 + * 1.0.10beta1 1 10010 2.1.0.10beta1 + * 1.0.10rc1 1 10010 2.1.0.10rc1 + * 1.0.10 1 10010 2.1.0.10 + * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 + * 1.0.11rc1 1 10011 2.1.0.11rc1 + * 1.0.11 1 10011 2.1.0.11 + * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 + * 1.0.12rc1 2 10012 2.1.0.12rc1 + * 1.0.12 2 10012 2.1.0.12 + * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) + * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 + * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 + * 1.2.0rc1 3 10200 3.1.2.0rc1 + * 1.2.0 3 10200 3.1.2.0 + * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 + * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 + * 1.2.1 3 10201 3.1.2.1 + * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 + * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 + * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 + * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 + * 1.0.13 10 10013 10.so.0.1.0.13 + * 1.2.2 12 10202 12.so.0.1.2.2 + * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 + * 1.2.3 12 10203 12.so.0.1.2.3 + * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 + * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 + * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 + * 1.0.14 10 10014 10.so.0.1.0.14 + * 1.2.4 13 10204 12.so.0.1.2.4 + * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 + * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 + * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 + * 1.0.15 10 10015 10.so.0.1.0.15 + * 1.2.5 13 10205 12.so.0.1.2.5 + * + * Henceforth the source version will match the shared-library major + * and minor numbers; the shared-library major version number will be + * used for changes in backward compatibility, as it is intended. The + * PNG_LIBPNG_VER macro, which is not used within libpng but is available + * for applications, is an unsigned integer of the form xyyzz corresponding + * to the source version x.y.z (leading zeros in y and z). Beta versions + * were given the previous public release number plus a letter, until + * version 1.0.6j; from then on they were given the upcoming public + * release number plus "betaNN" or "rcN". + * + * Binary incompatibility exists only when applications make direct access + * to the info_ptr or png_ptr members through png.h, and the compiled + * application is loaded with a different version of the library. + * + * DLLNUM will change each time there are forward or backward changes + * in binary compatibility (e.g., when a new feature is added). + * + * See libpng.txt or libpng.3 for more information. The PNG specification + * is available as RFC 2083 + * and as a W3C Recommendation + */ + +/* + * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: + * + * If you modify libpng you may insert additional notices immediately following + * this sentence. + * + * libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are + * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are + * distributed according to the same disclaimer and license as libpng-1.0.6 + * with the following individuals added to the list of Contributing Authors + * + * Simon-Pierre Cadieux + * Eric S. Raymond + * Gilles Vollant + * + * and with the following additions to the disclaimer: + * + * There is no warranty against interference with your enjoyment of the + * library or against infringement. There is no warranty that our + * efforts or the library will fulfill any of your particular purposes + * or needs. This library is provided with all faults, and the entire + * risk of satisfactory quality, performance, accuracy, and effort is with + * the user. + * + * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are + * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson + * Distributed according to the same disclaimer and license as libpng-0.96, + * with the following individuals added to the list of Contributing Authors: + * + * Tom Lane + * Glenn Randers-Pehrson + * Willem van Schaik + * + * libpng versions 0.89, June 1996, through 0.96, May 1997, are + * Copyright (c) 1996, 1997 Andreas Dilger + * Distributed according to the same disclaimer and license as libpng-0.88, + * with the following individuals added to the list of Contributing Authors: + * + * John Bowler + * Kevin Bracey + * Sam Bushell + * Magnus Holmgren + * Greg Roelofs + * Tom Tanner + * + * libpng versions 0.5, May 1995, through 0.88, January 1996, are + * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. + * + * For the purposes of this copyright and license, "Contributing Authors" + * is defined as the following set of individuals: + * + * Andreas Dilger + * Dave Martindale + * Guy Eric Schalnat + * Paul Schmidt + * Tim Wegner + * + * The PNG Reference Library is supplied "AS IS". The Contributing Authors + * and Group 42, Inc. disclaim all warranties, expressed or implied, + * including, without limitation, the warranties of merchantability and of + * fitness for any purpose. The Contributing Authors and Group 42, Inc. + * assume no liability for direct, indirect, incidental, special, exemplary, + * or consequential damages, which may result from the use of the PNG + * Reference Library, even if advised of the possibility of such damage. + * + * Permission is hereby granted to use, copy, modify, and distribute this + * source code, or portions hereof, for any purpose, without fee, subject + * to the following restrictions: + * + * 1. The origin of this source code must not be misrepresented. + * + * 2. Altered versions must be plainly marked as such and + * must not be misrepresented as being the original source. + * + * 3. This Copyright notice may not be removed or altered from + * any source or altered source distribution. + * + * The Contributing Authors and Group 42, Inc. specifically permit, without + * fee, and encourage the use of this source code as a component to + * supporting the PNG file format in commercial products. If you use this + * source code in a product, acknowledgment is not required but would be + * appreciated. + */ + +/* + * A "png_get_copyright" function is available, for convenient use in "about" + * boxes and the like: + * + * printf("%s",png_get_copyright(NULL)); + * + * Also, the PNG logo (in PNG format, of course) is supplied in the + * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). + */ + +/* + * Libpng is OSI Certified Open Source Software. OSI Certified is a + * certification mark of the Open Source Initiative. + */ + +/* + * The contributing authors would like to thank all those who helped + * with testing, bug fixes, and patience. This wouldn't have been + * possible without all of you. + * + * Thanks to Frank J. T. Wojcik for helping with the documentation. + */ + +/* + * Y2K compliance in libpng: + * ========================= + * + * October 3, 2002 + * + * Since the PNG Development group is an ad-hoc body, we can't make + * an official declaration. + * + * This is your unofficial assurance that libpng from version 0.71 and + * upward through 1.2.5 are Y2K compliant. It is my belief that earlier + * versions were also Y2K compliant. + * + * Libpng only has three year fields. One is a 2-byte unsigned integer + * that will hold years up to 65535. The other two hold the date in text + * format, and will hold years up to 9999. + * + * The integer is + * "png_uint_16 year" in png_time_struct. + * + * The strings are + * "png_charp time_buffer" in png_struct and + * "near_time_buffer", which is a local character string in png.c. + * + * There are seven time-related functions: + * png.c: png_convert_to_rfc_1123() in png.c + * (formerly png_convert_to_rfc_1152() in error) + * png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c + * png_convert_from_time_t() in pngwrite.c + * png_get_tIME() in pngget.c + * png_handle_tIME() in pngrutil.c, called in pngread.c + * png_set_tIME() in pngset.c + * png_write_tIME() in pngwutil.c, called in pngwrite.c + * + * All handle dates properly in a Y2K environment. The + * png_convert_from_time_t() function calls gmtime() to convert from system + * clock time, which returns (year - 1900), which we properly convert to + * the full 4-digit year. There is a possibility that applications using + * libpng are not passing 4-digit years into the png_convert_to_rfc_1123() + * function, or that they are incorrectly passing only a 2-digit year + * instead of "year - 1900" into the png_convert_from_struct_tm() function, + * but this is not under our control. The libpng documentation has always + * stated that it works with 4-digit years, and the APIs have been + * documented as such. + * + * The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned + * integer to hold the year, and can hold years as large as 65535. + * + * zlib, upon which libpng depends, is also Y2K compliant. It contains + * no date-related code. + * + * Glenn Randers-Pehrson + * libpng maintainer + * PNG Development Group + */ + +#ifndef PNG_H +#define PNG_H + +/* This is not the place to learn how to use libpng. The file libpng.txt + * describes how to use libpng, and the file example.c summarizes it + * with some code on which to build. This file is useful for looking + * at the actual function definitions and structure components. + */ + +/* Version information for png.h - this should match the version in png.c */ +#define PNG_LIBPNG_VER_STRING "1.2.5" + +#define PNG_LIBPNG_VER_SONUM 0 +#define PNG_LIBPNG_VER_DLLNUM %DLLNUM% + +/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ +#define PNG_LIBPNG_VER_MAJOR 1 +#define PNG_LIBPNG_VER_MINOR 2 +#define PNG_LIBPNG_VER_RELEASE 5 +/* This should match the numeric part of the final component of + * PNG_LIBPNG_VER_STRING, omitting any leading zero: */ + +#define PNG_LIBPNG_VER_BUILD 0 + +#define PNG_LIBPNG_BUILD_ALPHA 1 +#define PNG_LIBPNG_BUILD_BETA 2 +#define PNG_LIBPNG_BUILD_RC 3 +#define PNG_LIBPNG_BUILD_STABLE 4 +#define PNG_LIBPNG_BUILD_TYPEMASK 7 +#define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with STABLE only */ +#define PNG_LIBPNG_BUILD_TYPE 4 + +/* Careful here. At one time, Guy wanted to use 082, but that would be octal. + * We must not include leading zeros. + * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only + * version 1.0.0 was mis-numbered 100 instead of 10000). From + * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release */ +#define PNG_LIBPNG_VER 10205 /* 1.2.5 */ + +#ifndef PNG_VERSION_INFO_ONLY + +/* include the compression library's header */ +#include "zlib.h" + +/* include all user configurable info, including optional assembler routines */ +#include "pngconf.h" + +/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* This file is arranged in several sections. The first section contains + * structure and type definitions. The second section contains the external + * library functions, while the third has the internal library functions, + * which applications aren't expected to use directly. + */ + +#ifndef PNG_NO_TYPECAST_NULL +#define int_p_NULL (int *)NULL +#define png_bytep_NULL (png_bytep)NULL +#define png_bytepp_NULL (png_bytepp)NULL +#define png_doublep_NULL (png_doublep)NULL +#define png_error_ptr_NULL (png_error_ptr)NULL +#define png_flush_ptr_NULL (png_flush_ptr)NULL +#define png_free_ptr_NULL (png_free_ptr)NULL +#define png_infopp_NULL (png_infopp)NULL +#define png_malloc_ptr_NULL (png_malloc_ptr)NULL +#define png_read_status_ptr_NULL (png_read_status_ptr)NULL +#define png_rw_ptr_NULL (png_rw_ptr)NULL +#define png_structp_NULL (png_structp)NULL +#define png_uint_16p_NULL (png_uint_16p)NULL +#define png_voidp_NULL (png_voidp)NULL +#define png_write_status_ptr_NULL (png_write_status_ptr)NULL +#else +#define int_p_NULL NULL +#define png_bytep_NULL NULL +#define png_bytepp_NULL NULL +#define png_doublep_NULL NULL +#define png_error_ptr_NULL NULL +#define png_flush_ptr_NULL NULL +#define png_free_ptr_NULL NULL +#define png_infopp_NULL NULL +#define png_malloc_ptr_NULL NULL +#define png_read_status_ptr_NULL NULL +#define png_rw_ptr_NULL NULL +#define png_structp_NULL NULL +#define png_uint_16p_NULL NULL +#define png_voidp_NULL NULL +#define png_write_status_ptr_NULL NULL +#endif + +/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ +#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) +/* Version information for C files, stored in png.c. This had better match + * the version above. + */ +#ifdef PNG_USE_GLOBAL_ARRAYS +PNG_EXPORT_VAR (const char) png_libpng_ver[18]; + /* need room for 99.99.99beta99z */ +#else +#define png_libpng_ver png_get_header_ver(NULL) +#endif + +#ifdef PNG_USE_GLOBAL_ARRAYS +/* This was removed in version 1.0.5c */ +/* Structures to facilitate easy interlacing. See png.c for more details */ +PNG_EXPORT_VAR (const int FARDATA) png_pass_start[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_inc[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_ystart[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_yinc[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_mask[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_dsp_mask[7]; +#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW +PNG_EXPORT_VAR (const int FARDATA) png_pass_width[7]; +#endif +/* This isn't currently used. If you need it, see png.c for more details. +PNG_EXPORT_VAR (const int FARDATA) png_pass_height[7]; +*/ +#endif + +#endif /* PNG_NO_EXTERN */ + +/* Three color definitions. The order of the red, green, and blue, (and the + * exact size) is not important, although the size of the fields need to + * be png_byte or png_uint_16 (as defined below). + */ +typedef struct png_color_struct +{ + png_byte red; + png_byte green; + png_byte blue; +} png_color; +typedef png_color FAR * png_colorp; +typedef png_color FAR * FAR * png_colorpp; + +typedef struct png_color_16_struct +{ + png_byte index; /* used for palette files */ + png_uint_16 red; /* for use in red green blue files */ + png_uint_16 green; + png_uint_16 blue; + png_uint_16 gray; /* for use in grayscale files */ +} png_color_16; +typedef png_color_16 FAR * png_color_16p; +typedef png_color_16 FAR * FAR * png_color_16pp; + +typedef struct png_color_8_struct +{ + png_byte red; /* for use in red green blue files */ + png_byte green; + png_byte blue; + png_byte gray; /* for use in grayscale files */ + png_byte alpha; /* for alpha channel files */ +} png_color_8; +typedef png_color_8 FAR * png_color_8p; +typedef png_color_8 FAR * FAR * png_color_8pp; + +/* + * The following two structures are used for the in-core representation + * of sPLT chunks. + */ +typedef struct png_sPLT_entry_struct +{ + png_uint_16 red; + png_uint_16 green; + png_uint_16 blue; + png_uint_16 alpha; + png_uint_16 frequency; +} png_sPLT_entry; +typedef png_sPLT_entry FAR * png_sPLT_entryp; +typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; + +/* When the depth of the sPLT palette is 8 bits, the color and alpha samples + * occupy the LSB of their respective members, and the MSB of each member + * is zero-filled. The frequency member always occupies the full 16 bits. + */ + +typedef struct png_sPLT_struct +{ + png_charp name; /* palette name */ + png_byte depth; /* depth of palette samples */ + png_sPLT_entryp entries; /* palette entries */ + png_int_32 nentries; /* number of palette entries */ +} png_sPLT_t; +typedef png_sPLT_t FAR * png_sPLT_tp; +typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; + +#ifdef PNG_TEXT_SUPPORTED +/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file, + * and whether that contents is compressed or not. The "key" field + * points to a regular zero-terminated C string. The "text", "lang", and + * "lang_key" fields can be regular C strings, empty strings, or NULL pointers. + * However, the * structure returned by png_get_text() will always contain + * regular zero-terminated C strings (possibly empty), never NULL pointers, + * so they can be safely used in printf() and other string-handling functions. + */ +typedef struct png_text_struct +{ + int compression; /* compression value: + -1: tEXt, none + 0: zTXt, deflate + 1: iTXt, none + 2: iTXt, deflate */ + png_charp key; /* keyword, 1-79 character description of "text" */ + png_charp text; /* comment, may be an empty string (ie "") + or a NULL pointer */ + png_size_t text_length; /* length of the text string */ +#ifdef PNG_iTXt_SUPPORTED + png_size_t itxt_length; /* length of the itxt string */ + png_charp lang; /* language code, 0-79 characters + or a NULL pointer */ + png_charp lang_key; /* keyword translated UTF-8 string, 0 or more + chars or a NULL pointer */ +#endif +} png_text; +typedef png_text FAR * png_textp; +typedef png_text FAR * FAR * png_textpp; +#endif + +/* Supported compression types for text in PNG files (tEXt, and zTXt). + * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */ +#define PNG_TEXT_COMPRESSION_NONE_WR -3 +#define PNG_TEXT_COMPRESSION_zTXt_WR -2 +#define PNG_TEXT_COMPRESSION_NONE -1 +#define PNG_TEXT_COMPRESSION_zTXt 0 +#define PNG_ITXT_COMPRESSION_NONE 1 +#define PNG_ITXT_COMPRESSION_zTXt 2 +#define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */ + +/* png_time is a way to hold the time in an machine independent way. + * Two conversions are provided, both from time_t and struct tm. There + * is no portable way to convert to either of these structures, as far + * as I know. If you know of a portable way, send it to me. As a side + * note - PNG has always been Year 2000 compliant! + */ +typedef struct png_time_struct +{ + png_uint_16 year; /* full year, as in, 1995 */ + png_byte month; /* month of year, 1 - 12 */ + png_byte day; /* day of month, 1 - 31 */ + png_byte hour; /* hour of day, 0 - 23 */ + png_byte minute; /* minute of hour, 0 - 59 */ + png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ +} png_time; +typedef png_time FAR * png_timep; +typedef png_time FAR * FAR * png_timepp; + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +/* png_unknown_chunk is a structure to hold queued chunks for which there is + * no specific support. The idea is that we can use this to queue + * up private chunks for output even though the library doesn't actually + * know about their semantics. + */ +typedef struct png_unknown_chunk_t +{ + png_byte name[5]; + png_byte *data; + png_size_t size; + + /* libpng-using applications should NOT directly modify this byte. */ + png_byte location; /* mode of operation at read time */ +} +png_unknown_chunk; +typedef png_unknown_chunk FAR * png_unknown_chunkp; +typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; +#endif + +/* png_info is a structure that holds the information in a PNG file so + * that the application can find out the characteristics of the image. + * If you are reading the file, this structure will tell you what is + * in the PNG file. If you are writing the file, fill in the information + * you want to put into the PNG file, then call png_write_info(). + * The names chosen should be very close to the PNG specification, so + * consult that document for information about the meaning of each field. + * + * With libpng < 0.95, it was only possible to directly set and read the + * the values in the png_info_struct, which meant that the contents and + * order of the values had to remain fixed. With libpng 0.95 and later, + * however, there are now functions that abstract the contents of + * png_info_struct from the application, so this makes it easier to use + * libpng with dynamic libraries, and even makes it possible to use + * libraries that don't have all of the libpng ancillary chunk-handing + * functionality. + * + * In any case, the order of the parameters in png_info_struct should NOT + * be changed for as long as possible to keep compatibility with applications + * that use the old direct-access method with png_info_struct. + * + * The following members may have allocated storage attached that should be + * cleaned up before the structure is discarded: palette, trans, text, + * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, + * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these + * are automatically freed when the info structure is deallocated, if they were + * allocated internally by libpng. This behavior can be changed by means + * of the png_data_freer() function. + * + * More allocation details: all the chunk-reading functions that + * change these members go through the corresponding png_set_* + * functions. A function to clear these members is available: see + * png_free_data(). The png_set_* functions do not depend on being + * able to point info structure members to any of the storage they are + * passed (they make their own copies), EXCEPT that the png_set_text + * functions use the same storage passed to them in the text_ptr or + * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns + * functions do not make their own copies. + */ +typedef struct png_info_struct +{ + /* the following are necessary for every PNG file */ + png_uint_32 width; /* width of image in pixels (from IHDR) */ + png_uint_32 height; /* height of image in pixels (from IHDR) */ + png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */ + png_uint_32 rowbytes; /* bytes needed to hold an untransformed row */ + png_colorp palette; /* array of color values (valid & PNG_INFO_PLTE) */ + png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */ + png_uint_16 num_trans; /* number of transparent palette color (tRNS) */ + png_byte bit_depth; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */ + png_byte color_type; /* see PNG_COLOR_TYPE_ below (from IHDR) */ + /* The following three should have been named *_method not *_type */ + png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */ + png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ + png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ + + /* The following is informational only on read, and not used on writes. */ + png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */ + png_byte pixel_depth; /* number of bits per pixel */ + png_byte spare_byte; /* to align the data, and for future use */ + png_byte signature[8]; /* magic bytes read by libpng from start of file */ + + /* The rest of the data is optional. If you are reading, check the + * valid field to see if the information in these are valid. If you + * are writing, set the valid field to those chunks you want written, + * and initialize the appropriate fields below. + */ + +#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) + /* The gAMA chunk describes the gamma characteristics of the system + * on which the image was created, normally in the range [1.0, 2.5]. + * Data is valid if (valid & PNG_INFO_gAMA) is non-zero. + */ + float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */ +#endif + +#if defined(PNG_sRGB_SUPPORTED) + /* GR-P, 0.96a */ + /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ + png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */ +#endif + +#if defined(PNG_TEXT_SUPPORTED) + /* The tEXt, and zTXt chunks contain human-readable textual data in + * uncompressed, compressed, and optionally compressed forms, respectively. + * The data in "text" is an array of pointers to uncompressed, + * null-terminated C strings. Each chunk has a keyword that describes the + * textual data contained in that chunk. Keywords are not required to be + * unique, and the text string may be empty. Any number of text chunks may + * be in an image. + */ + int num_text; /* number of comments read/to write */ + int max_text; /* current size of text array */ + png_textp text; /* array of comments read/to write */ +#endif /* PNG_TEXT_SUPPORTED */ + +#if defined(PNG_tIME_SUPPORTED) + /* The tIME chunk holds the last time the displayed image data was + * modified. See the png_time struct for the contents of this struct. + */ + png_time mod_time; +#endif + +#if defined(PNG_sBIT_SUPPORTED) + /* The sBIT chunk specifies the number of significant high-order bits + * in the pixel data. Values are in the range [1, bit_depth], and are + * only specified for the channels in the pixel data. The contents of + * the low-order bits is not specified. Data is valid if + * (valid & PNG_INFO_sBIT) is non-zero. + */ + png_color_8 sig_bit; /* significant bits in color channels */ +#endif + +#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ +defined(PNG_READ_BACKGROUND_SUPPORTED) + /* The tRNS chunk supplies transparency data for paletted images and + * other image types that don't need a full alpha channel. There are + * "num_trans" transparency values for a paletted image, stored in the + * same order as the palette colors, starting from index 0. Values + * for the data are in the range [0, 255], ranging from fully transparent + * to fully opaque, respectively. For non-paletted images, there is a + * single color specified that should be treated as fully transparent. + * Data is valid if (valid & PNG_INFO_tRNS) is non-zero. + */ + png_bytep trans; /* transparent values for paletted image */ + png_color_16 trans_values; /* transparent color for non-palette image */ +#endif + +#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + /* The bKGD chunk gives the suggested image background color if the + * display program does not have its own background color and the image + * is needs to composited onto a background before display. The colors + * in "background" are normally in the same color space/depth as the + * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. + */ + png_color_16 background; +#endif + +#if defined(PNG_oFFs_SUPPORTED) + /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards + * and downwards from the top-left corner of the display, page, or other + * application-specific co-ordinate space. See the PNG_OFFSET_ defines + * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. + */ + png_int_32 x_offset; /* x offset on page */ + png_int_32 y_offset; /* y offset on page */ + png_byte offset_unit_type; /* offset units type */ +#endif + +#if defined(PNG_pHYs_SUPPORTED) + /* The pHYs chunk gives the physical pixel density of the image for + * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ + * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. + */ + png_uint_32 x_pixels_per_unit; /* horizontal pixel density */ + png_uint_32 y_pixels_per_unit; /* vertical pixel density */ + png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */ +#endif + +#if defined(PNG_hIST_SUPPORTED) + /* The hIST chunk contains the relative frequency or importance of the + * various palette entries, so that a viewer can intelligently select a + * reduced-color palette, if required. Data is an array of "num_palette" + * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) + * is non-zero. + */ + png_uint_16p hist; +#endif + +#ifdef PNG_cHRM_SUPPORTED + /* The cHRM chunk describes the CIE color characteristics of the monitor + * on which the PNG was created. This data allows the viewer to do gamut + * mapping of the input image to ensure that the viewer sees the same + * colors in the image as the creator. Values are in the range + * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. + */ +#ifdef PNG_FLOATING_POINT_SUPPORTED + float x_white; + float y_white; + float x_red; + float y_red; + float x_green; + float y_green; + float x_blue; + float y_blue; +#endif +#endif + +#if defined(PNG_pCAL_SUPPORTED) + /* The pCAL chunk describes a transformation between the stored pixel + * values and original physical data values used to create the image. + * The integer range [0, 2^bit_depth - 1] maps to the floating-point + * range given by [pcal_X0, pcal_X1], and are further transformed by a + * (possibly non-linear) transformation function given by "pcal_type" + * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ + * defines below, and the PNG-Group's PNG extensions document for a + * complete description of the transformations and how they should be + * implemented, and for a description of the ASCII parameter strings. + * Data values are valid if (valid & PNG_INFO_pCAL) non-zero. + */ + png_charp pcal_purpose; /* pCAL chunk description string */ + png_int_32 pcal_X0; /* minimum value */ + png_int_32 pcal_X1; /* maximum value */ + png_charp pcal_units; /* Latin-1 string giving physical units */ + png_charpp pcal_params; /* ASCII strings containing parameter values */ + png_byte pcal_type; /* equation type (see PNG_EQUATION_ below) */ + png_byte pcal_nparams; /* number of parameters given in pcal_params */ +#endif + +/* New members added in libpng-1.0.6 */ +#ifdef PNG_FREE_ME_SUPPORTED + png_uint_32 free_me; /* flags items libpng is responsible for freeing */ +#endif + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) + /* storage for unknown chunks that the library doesn't recognize. */ + png_unknown_chunkp unknown_chunks; + png_size_t unknown_chunks_num; +#endif + +#if defined(PNG_iCCP_SUPPORTED) + /* iCCP chunk data. */ + png_charp iccp_name; /* profile name */ + png_charp iccp_profile; /* International Color Consortium profile data */ + /* Note to maintainer: should be png_bytep */ + png_uint_32 iccp_proflen; /* ICC profile data length */ + png_byte iccp_compression; /* Always zero */ +#endif + +#if defined(PNG_sPLT_SUPPORTED) + /* data on sPLT chunks (there may be more than one). */ + png_sPLT_tp splt_palettes; + png_uint_32 splt_palettes_num; +#endif + +#if defined(PNG_sCAL_SUPPORTED) + /* The sCAL chunk describes the actual physical dimensions of the + * subject matter of the graphic. The chunk contains a unit specification + * a byte value, and two ASCII strings representing floating-point + * values. The values are width and height corresponsing to one pixel + * in the image. This external representation is converted to double + * here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero. + */ + png_byte scal_unit; /* unit of physical scale */ +#ifdef PNG_FLOATING_POINT_SUPPORTED + double scal_pixel_width; /* width of one pixel */ + double scal_pixel_height; /* height of one pixel */ +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED + png_charp scal_s_width; /* string containing height */ + png_charp scal_s_height; /* string containing width */ +#endif +#endif + +#if defined(PNG_INFO_IMAGE_SUPPORTED) + /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */ + /* Data valid if (valid & PNG_INFO_IDAT) non-zero */ + png_bytepp row_pointers; /* the image bits */ +#endif + +#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED) + png_fixed_point int_gamma; /* gamma of image, if (valid & PNG_INFO_gAMA) */ +#endif + +#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED) + png_fixed_point int_x_white; + png_fixed_point int_y_white; + png_fixed_point int_x_red; + png_fixed_point int_y_red; + png_fixed_point int_x_green; + png_fixed_point int_y_green; + png_fixed_point int_x_blue; + png_fixed_point int_y_blue; +#endif + +} png_info; + +typedef png_info FAR * png_infop; +typedef png_info FAR * FAR * png_infopp; + +/* Maximum positive integer used in PNG is (2^31)-1 */ +#define PNG_MAX_UINT ((png_uint_32)0x7fffffffL) + +/* These describe the color_type field in png_info. */ +/* color type masks */ +#define PNG_COLOR_MASK_PALETTE 1 +#define PNG_COLOR_MASK_COLOR 2 +#define PNG_COLOR_MASK_ALPHA 4 + +/* color types. Note that not all combinations are legal */ +#define PNG_COLOR_TYPE_GRAY 0 +#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE) +#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR) +#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) +#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA) +/* aliases */ +#define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA +#define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA + +/* This is for compression type. PNG 1.0-1.2 only define the single type. */ +#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */ +#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE + +/* This is for filter type. PNG 1.0-1.2 only define the single type. */ +#define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */ +#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */ +#define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE + +/* These are for the interlacing type. These values should NOT be changed. */ +#define PNG_INTERLACE_NONE 0 /* Non-interlaced image */ +#define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */ +#define PNG_INTERLACE_LAST 2 /* Not a valid value */ + +/* These are for the oFFs chunk. These values should NOT be changed. */ +#define PNG_OFFSET_PIXEL 0 /* Offset in pixels */ +#define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */ +#define PNG_OFFSET_LAST 2 /* Not a valid value */ + +/* These are for the pCAL chunk. These values should NOT be changed. */ +#define PNG_EQUATION_LINEAR 0 /* Linear transformation */ +#define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */ +#define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */ +#define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */ +#define PNG_EQUATION_LAST 4 /* Not a valid value */ + +/* These are for the sCAL chunk. These values should NOT be changed. */ +#define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */ +#define PNG_SCALE_METER 1 /* meters per pixel */ +#define PNG_SCALE_RADIAN 2 /* radians per pixel */ +#define PNG_SCALE_LAST 3 /* Not a valid value */ + +/* These are for the pHYs chunk. These values should NOT be changed. */ +#define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */ +#define PNG_RESOLUTION_METER 1 /* pixels/meter */ +#define PNG_RESOLUTION_LAST 2 /* Not a valid value */ + +/* These are for the sRGB chunk. These values should NOT be changed. */ +#define PNG_sRGB_INTENT_PERCEPTUAL 0 +#define PNG_sRGB_INTENT_RELATIVE 1 +#define PNG_sRGB_INTENT_SATURATION 2 +#define PNG_sRGB_INTENT_ABSOLUTE 3 +#define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */ + +/* This is for text chunks */ +#define PNG_KEYWORD_MAX_LENGTH 79 + +/* Maximum number of entries in PLTE/sPLT/tRNS arrays */ +#define PNG_MAX_PALETTE_LENGTH 256 + +/* These determine if an ancillary chunk's data has been successfully read + * from the PNG header, or if the application has filled in the corresponding + * data in the info_struct to be written into the output file. The values + * of the PNG_INFO_ defines should NOT be changed. + */ +#define PNG_INFO_gAMA 0x0001 +#define PNG_INFO_sBIT 0x0002 +#define PNG_INFO_cHRM 0x0004 +#define PNG_INFO_PLTE 0x0008 +#define PNG_INFO_tRNS 0x0010 +#define PNG_INFO_bKGD 0x0020 +#define PNG_INFO_hIST 0x0040 +#define PNG_INFO_pHYs 0x0080 +#define PNG_INFO_oFFs 0x0100 +#define PNG_INFO_tIME 0x0200 +#define PNG_INFO_pCAL 0x0400 +#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ +#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ +#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ +#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ +#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ + +/* This is used for the transformation routines, as some of them + * change these values for the row. It also should enable using + * the routines for other purposes. + */ +typedef struct png_row_info_struct +{ + png_uint_32 width; /* width of row */ + png_uint_32 rowbytes; /* number of bytes in row */ + png_byte color_type; /* color type of row */ + png_byte bit_depth; /* bit depth of row */ + png_byte channels; /* number of channels (1, 2, 3, or 4) */ + png_byte pixel_depth; /* bits per pixel (depth * channels) */ +} png_row_info; + +typedef png_row_info FAR * png_row_infop; +typedef png_row_info FAR * FAR * png_row_infopp; + +/* These are the function types for the I/O functions and for the functions + * that allow the user to override the default I/O functions with his or her + * own. The png_error_ptr type should match that of user-supplied warning + * and error functions, while the png_rw_ptr type should match that of the + * user read/write data functions. + */ +typedef struct png_struct_def png_struct; +typedef png_struct FAR * png_structp; + +typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); +typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); +typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); +typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, + int)); +typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, + int)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); +typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); +typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, + png_uint_32, int)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, + png_row_infop, png_bytep)); +#endif + +#if defined(PNG_USER_CHUNKS_SUPPORTED) +typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); +#endif +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); +#endif + +/* Transform masks for the high-level interface */ +#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ +#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ +#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ +#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ +#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ +#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ +#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ +#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ +#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ +#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ +#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ +#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ +#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */ + +/* Flags for MNG supported features */ +#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 +#define PNG_FLAG_MNG_FILTER_64 0x04 +#define PNG_ALL_MNG_FEATURES 0x05 + +typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); +typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); + +/* The structure that holds the information to read and write PNG files. + * The only people who need to care about what is inside of this are the + * people who will be modifying the library for their own special needs. + * It should NOT be accessed directly by an application, except to store + * the jmp_buf. + */ + +struct png_struct_def +{ +#ifdef PNG_SETJMP_SUPPORTED + jmp_buf jmpbuf; /* used in png_error */ +#endif + png_error_ptr error_fn; /* function for printing errors and aborting */ + png_error_ptr warning_fn; /* function for printing warnings */ + png_voidp error_ptr; /* user supplied struct for error functions */ + png_rw_ptr write_data_fn; /* function for writing output data */ + png_rw_ptr read_data_fn; /* function for reading input data */ + png_voidp io_ptr; /* ptr to application struct for I/O functions */ + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) + png_user_transform_ptr read_user_transform_fn; /* user read transform */ +#endif + +#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) + png_user_transform_ptr write_user_transform_fn; /* user write transform */ +#endif + +/* These were added in libpng-1.0.2 */ +#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) + png_voidp user_transform_ptr; /* user supplied struct for user transform */ + png_byte user_transform_depth; /* bit depth of user transformed pixels */ + png_byte user_transform_channels; /* channels in user transformed pixels */ +#endif +#endif + + png_uint_32 mode; /* tells us where we are in the PNG file */ + png_uint_32 flags; /* flags indicating various things to libpng */ + png_uint_32 transformations; /* which transformations to perform */ + + z_stream zstream; /* pointer to decompression structure (below) */ + png_bytep zbuf; /* buffer for zlib */ + png_size_t zbuf_size; /* size of zbuf */ + int zlib_level; /* holds zlib compression level */ + int zlib_method; /* holds zlib compression method */ + int zlib_window_bits; /* holds zlib compression window bits */ + int zlib_mem_level; /* holds zlib compression memory level */ + int zlib_strategy; /* holds zlib compression strategy */ + + png_uint_32 width; /* width of image in pixels */ + png_uint_32 height; /* height of image in pixels */ + png_uint_32 num_rows; /* number of rows in current pass */ + png_uint_32 usr_width; /* width of row at start of write */ + png_uint_32 rowbytes; /* size of row in bytes */ + png_uint_32 irowbytes; /* size of current interlaced row in bytes */ + png_uint_32 iwidth; /* width of current interlaced row in pixels */ + png_uint_32 row_number; /* current row in interlace pass */ + png_bytep prev_row; /* buffer to save previous (unfiltered) row */ + png_bytep row_buf; /* buffer to save current (unfiltered) row */ + png_bytep sub_row; /* buffer to save "sub" row when filtering */ + png_bytep up_row; /* buffer to save "up" row when filtering */ + png_bytep avg_row; /* buffer to save "avg" row when filtering */ + png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ + png_row_info row_info; /* used for transformation routines */ + + png_uint_32 idat_size; /* current IDAT size for read */ + png_uint_32 crc; /* current chunk CRC value */ + png_colorp palette; /* palette from the input file */ + png_uint_16 num_palette; /* number of color entries in palette */ + png_uint_16 num_trans; /* number of transparency values */ + png_byte chunk_name[5]; /* null-terminated name of current chunk */ + png_byte compression; /* file compression type (always 0) */ + png_byte filter; /* file filter type (always 0) */ + png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ + png_byte pass; /* current interlace pass (0 - 6) */ + png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ + png_byte color_type; /* color type of file */ + png_byte bit_depth; /* bit depth of file */ + png_byte usr_bit_depth; /* bit depth of users row */ + png_byte pixel_depth; /* number of bits per pixel */ + png_byte channels; /* number of channels in file */ + png_byte usr_channels; /* channels at start of write */ + png_byte sig_bytes; /* magic bytes read/written from start of file */ + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +#ifdef PNG_LEGACY_SUPPORTED + png_byte filler; /* filler byte for pixel expansion */ +#else + png_uint_16 filler; /* filler bytes for pixel expansion */ +#endif +#endif + +#if defined(PNG_bKGD_SUPPORTED) + png_byte background_gamma_type; +# ifdef PNG_FLOATING_POINT_SUPPORTED + float background_gamma; +# endif + png_color_16 background; /* background color in screen gamma space */ +#if defined(PNG_READ_GAMMA_SUPPORTED) + png_color_16 background_1; /* background normalized to gamma 1.0 */ +#endif +#endif /* PNG_bKGD_SUPPORTED */ + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) + png_flush_ptr output_flush_fn;/* Function for flushing output */ + png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ + png_uint_32 flush_rows; /* number of rows written since last flush */ +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + int gamma_shift; /* number of "insignificant" bits 16-bit gamma */ +#ifdef PNG_FLOATING_POINT_SUPPORTED + float gamma; /* file gamma value */ + float screen_gamma; /* screen gamma value (display_exponent) */ +#endif +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_bytep gamma_table; /* gamma table for 8-bit depth files */ + png_bytep gamma_from_1; /* converts from 1.0 to screen */ + png_bytep gamma_to_1; /* converts from file to 1.0 */ + png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ + png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ + png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) + png_color_8 sig_bit; /* significant bits in each available channel */ +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) + png_color_8 shift; /* shift for significant bit tranformation */ +#endif + +#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ + || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_bytep trans; /* transparency values for paletted files */ + png_color_16 trans_values; /* transparency values for non-paletted files */ +#endif + + png_read_status_ptr read_row_fn; /* called after each row is decoded */ + png_write_status_ptr write_row_fn; /* called after each row is encoded */ +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED + png_progressive_info_ptr info_fn; /* called after header data fully read */ + png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */ + png_progressive_end_ptr end_fn; /* called after image is complete */ + png_bytep save_buffer_ptr; /* current location in save_buffer */ + png_bytep save_buffer; /* buffer for previously read data */ + png_bytep current_buffer_ptr; /* current location in current_buffer */ + png_bytep current_buffer; /* buffer for recently used data */ + png_uint_32 push_length; /* size of current input chunk */ + png_uint_32 skip_length; /* bytes to skip in input data */ + png_size_t save_buffer_size; /* amount of data now in save_buffer */ + png_size_t save_buffer_max; /* total size of save_buffer */ + png_size_t buffer_size; /* total amount of available input data */ + png_size_t current_buffer_size; /* amount of data now in current_buffer */ + int process_mode; /* what push library is currently doing */ + int cur_palette; /* current push library palette index */ + +# if defined(PNG_TEXT_SUPPORTED) + png_size_t current_text_size; /* current size of text input data */ + png_size_t current_text_left; /* how much text left to read in input */ + png_charp current_text; /* current text chunk buffer */ + png_charp current_text_ptr; /* current location in current_text */ +# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */ + +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) +/* for the Borland special 64K segment handler */ + png_bytepp offset_table_ptr; + png_bytep offset_table; + png_uint_16 offset_table_number; + png_uint_16 offset_table_count; + png_uint_16 offset_table_count_free; +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) + png_bytep palette_lookup; /* lookup table for dithering */ + png_bytep dither_index; /* index translation for palette files */ +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) + png_uint_16p hist; /* histogram */ +#endif + +#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) + png_byte heuristic_method; /* heuristic for row filter selection */ + png_byte num_prev_filters; /* number of weights for previous rows */ + png_bytep prev_filters; /* filter type(s) of previous row(s) */ + png_uint_16p filter_weights; /* weight(s) for previous line(s) */ + png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ + png_uint_16p filter_costs; /* relative filter calculation cost */ + png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ +#endif + +#if defined(PNG_TIME_RFC1123_SUPPORTED) + png_charp time_buffer; /* String to hold RFC 1123 time text */ +#endif + +/* New members added in libpng-1.0.6 */ + +#ifdef PNG_FREE_ME_SUPPORTED + png_uint_32 free_me; /* flags items libpng is responsible for freeing */ +#endif + +#if defined(PNG_USER_CHUNKS_SUPPORTED) + png_voidp user_chunk_ptr; + png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ +#endif + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) + int num_chunk_list; + png_bytep chunk_list; +#endif + +/* New members added in libpng-1.0.3 */ +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) + png_byte rgb_to_gray_status; + /* These were changed from png_byte in libpng-1.0.6 */ + png_uint_16 rgb_to_gray_red_coeff; + png_uint_16 rgb_to_gray_green_coeff; + png_uint_16 rgb_to_gray_blue_coeff; +#endif + +/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ +#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ + defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ + defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +/* changed from png_byte to png_uint_32 at version 1.2.0 */ +#ifdef PNG_1_0_X + png_byte mng_features_permitted; +#else + png_uint_32 mng_features_permitted; +#endif /* PNG_1_0_X */ +#endif + +/* New member added in libpng-1.0.7 */ +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_fixed_point int_gamma; +#endif + +/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ +#if defined(PNG_MNG_FEATURES_SUPPORTED) + png_byte filter_type; +#endif + +#if defined(PNG_1_0_X) || (defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD)) +/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ + png_uint_32 row_buf_size; +#endif + +/* New members added in libpng-1.2.0 */ +#if !defined(PNG_1_0_X) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) + png_byte mmx_bitdepth_threshold; + png_uint_32 mmx_rowbytes_threshold; + png_uint_32 asm_flags; +#endif + +/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ +#ifdef PNG_USER_MEM_SUPPORTED + png_voidp mem_ptr; /* user supplied struct for mem functions */ + png_malloc_ptr malloc_fn; /* function for allocating memory */ + png_free_ptr free_fn; /* function for freeing memory */ +#endif + +/* New member added in libpng-1.0.13 and 1.2.0 */ + png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ + +#if defined(PNG_READ_DITHER_SUPPORTED) +/* The following three members were added at version 1.0.14 and 1.2.4 */ + png_bytep dither_sort; /* working sort array */ + png_bytep index_to_palette; /* where the original index currently is */ + /* in the palette */ + png_bytep palette_to_index; /* which original index points to this */ + /* palette color */ +#endif + +}; + + +/* This prevents a compiler error in png.c if png.c and png.h are both at + version 1.2.5 + */ +typedef png_structp version_1_2_5; + +typedef png_struct FAR * FAR * png_structpp; + +/* Here are the function definitions most commonly used. This is not + * the place to find out how to use libpng. See libpng.txt for the + * full explanation, see example.c for the summary. This just provides + * a simple one line description of the use of each function. + */ + +/* Returns the version number of the library */ +extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); + +/* Tell lib we have already handled the first magic bytes. + * Handling more than 8 bytes from the beginning of the file is an error. + */ +extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, + int num_bytes)); + +/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a + * PNG file. Returns zero if the supplied bytes match the 8-byte PNG + * signature, and non-zero otherwise. Having num_to_check == 0 or + * start > 7 will always fail (ie return non-zero). + */ +extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, + png_size_t num_to_check)); + +/* Simple signature checking function. This is the same as calling + * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). + */ +extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); + +/* Allocate and initialize png_ptr struct for reading, and any other memory. */ +extern PNG_EXPORT(png_structp,png_create_read_struct) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn)); + +/* Allocate and initialize png_ptr struct for writing, and any other memory */ +extern PNG_EXPORT(png_structp,png_create_write_struct) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn)); + +extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) + PNGARG((png_structp png_ptr)); + +extern PNG_EXPORT(void,png_set_compression_buffer_size) + PNGARG((png_structp png_ptr, png_uint_32 size)); + +/* Reset the compression stream */ +extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); + +/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ +#ifdef PNG_USER_MEM_SUPPORTED +extern PNG_EXPORT(png_structp,png_create_read_struct_2) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +extern PNG_EXPORT(png_structp,png_create_write_struct_2) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +#endif + +/* Write a PNG chunk - size, type, (optional) data, CRC. */ +extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, + png_bytep chunk_name, png_bytep data, png_size_t length)); + +/* Write the start of a PNG chunk - length and chunk name. */ +extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, + png_bytep chunk_name, png_uint_32 length)); + +/* Write the data of a PNG chunk started with png_write_chunk_start(). */ +extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); + +/* Allocate and initialize the info structure */ +extern PNG_EXPORT(png_infop,png_create_info_struct) + PNGARG((png_structp png_ptr)); + +/* Initialize the info structure (old interface - DEPRECATED) */ +extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)); +#undef png_info_init +#define png_info_init(info_ptr) png_info_init_3(&info_ptr, sizeof(png_info)); +extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, + png_size_t png_info_struct_size)); + +/* Writes all the PNG information before the image. */ +extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr)); +extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* read the information before the actual image data. */ +extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#if defined(PNG_TIME_RFC1123_SUPPORTED) +extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) + PNGARG((png_structp png_ptr, png_timep ptime)); +#endif + +#if !defined(_WIN32_WCE) +/* "time.h" functions are not supported on WindowsCE */ +#if defined(PNG_WRITE_tIME_SUPPORTED) +/* convert from a struct tm to png_time */ +extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, + struct tm FAR * ttime)); + +/* convert from time_t to png_time. Uses gmtime() */ +extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, + time_t ttime)); +#endif /* PNG_WRITE_tIME_SUPPORTED */ +#endif /* _WIN32_WCE */ + +#if defined(PNG_READ_EXPAND_SUPPORTED) +/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ +extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +/* Use blue, green, red order for pixels. */ +extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +/* Expand the grayscale to 24-bit RGB if necessary. */ +extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +/* Reduce RGB to grayscale. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, + int error_action, double red, double green )); +#endif +extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, + int error_action, png_fixed_point red, png_fixed_point green )); +extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp + png_ptr)); +#endif + +extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, + png_colorp palette)); + +#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +/* Add a filler byte to 24-bit RGB images. */ +extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, + png_uint_32 filler, int flags)); +/* The values of the PNG_FILLER_ defines should NOT be changed */ +#define PNG_FILLER_BEFORE 0 +#define PNG_FILLER_AFTER 1 +#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +/* Swap bytes in 16-bit depth files. */ +extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) +/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ +extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +/* Swap packing order of pixels in bytes. */ +extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +/* Converts files to legal bit depths. */ +extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, + png_color_8p true_bits)); +#endif + +#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ + defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* Have the code handle the interlacing. Returns the number of passes. */ +extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +/* Invert monochrome files */ +extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_BACKGROUND_SUPPORTED) +/* Handle alpha and tRNS by replacing with a background color. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, + png_color_16p background_color, int background_gamma_code, + int need_expand, double background_gamma)); +#endif +#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +#define PNG_BACKGROUND_GAMMA_SCREEN 1 +#define PNG_BACKGROUND_GAMMA_FILE 2 +#define PNG_BACKGROUND_GAMMA_UNIQUE 3 +#endif + +#if defined(PNG_READ_16_TO_8_SUPPORTED) +/* strip the second byte of information from a 16-bit depth file. */ +extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) +/* Turn on dithering, and reduce the palette to the number of colors available. */ +extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, + png_colorp palette, int num_palette, int maximum_colors, + png_uint_16p histogram, int full_dither)); +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) +/* Handle gamma correction. Screen_gamma=(display_exponent) */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, + double screen_gamma, double default_file_gamma)); +#endif +#endif + +#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ + defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ +/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ +extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, + int empty_plte_permitted)); +#endif + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +/* Set how many lines between output flushes - 0 for no flushing */ +extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); +/* Flush the current PNG output buffer */ +extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); +#endif + +/* optional update palette with requested transformations */ +extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); + +/* optional call to update the users info structure */ +extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* read one or more rows of image data. */ +extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, + png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); + +/* read a row of data. */ +extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, + png_bytep row, + png_bytep display_row)); + +/* read the whole image into memory at once. */ +extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, + png_bytepp image)); + +/* write a row of image data */ +extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, + png_bytep row)); + +/* write a few rows of image data */ +extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, + png_bytepp row, png_uint_32 num_rows)); + +/* write the image data */ +extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, + png_bytepp image)); + +/* writes the end of the PNG file. */ +extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* read the end of the PNG file. */ +extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* free any memory associated with the png_info_struct */ +extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, + png_infopp info_ptr_ptr)); + +/* free any memory associated with the png_struct and the png_info_structs */ +extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp + png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); + +/* free all memory used by the read (old method - NOT DLL EXPORTED) */ +extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, + png_infop end_info_ptr)); + +/* free any memory associated with the png_struct and the png_info_structs */ +extern PNG_EXPORT(void,png_destroy_write_struct) + PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); + +/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ +extern void png_write_destroy PNGARG((png_structp png_ptr)); + +/* set the libpng method of handling chunk CRC errors */ +extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, + int crit_action, int ancil_action)); + +/* Values for png_set_crc_action() to say how to handle CRC errors in + * ancillary and critical chunks, and whether to use the data contained + * therein. Note that it is impossible to "discard" data in a critical + * chunk. For versions prior to 0.90, the action was always error/quit, + * whereas in version 0.90 and later, the action for CRC errors in ancillary + * chunks is warn/discard. These values should NOT be changed. + * + * value action:critical action:ancillary + */ +#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ +#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ +#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ +#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ +#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ +#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ + +/* These functions give the user control over the scan-line filtering in + * libpng and the compression methods used by zlib. These functions are + * mainly useful for testing, as the defaults should work with most users. + * Those users who are tight on memory or want faster performance at the + * expense of compression can modify them. See the compression library + * header file (zlib.h) for an explination of the compression functions. + */ + +/* set the filtering method(s) used by libpng. Currently, the only valid + * value for "method" is 0. + */ +extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, + int filters)); + +/* Flags for png_set_filter() to say which filters to use. The flags + * are chosen so that they don't conflict with real filter types + * below, in case they are supplied instead of the #defined constants. + * These values should NOT be changed. + */ +#define PNG_NO_FILTERS 0x00 +#define PNG_FILTER_NONE 0x08 +#define PNG_FILTER_SUB 0x10 +#define PNG_FILTER_UP 0x20 +#define PNG_FILTER_AVG 0x40 +#define PNG_FILTER_PAETH 0x80 +#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ + PNG_FILTER_AVG | PNG_FILTER_PAETH) + +/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. + * These defines should NOT be changed. + */ +#define PNG_FILTER_VALUE_NONE 0 +#define PNG_FILTER_VALUE_SUB 1 +#define PNG_FILTER_VALUE_UP 2 +#define PNG_FILTER_VALUE_AVG 3 +#define PNG_FILTER_VALUE_PAETH 4 +#define PNG_FILTER_VALUE_LAST 5 + +#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ +/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ + * defines, either the default (minimum-sum-of-absolute-differences), or + * the experimental method (weighted-minimum-sum-of-absolute-differences). + * + * Weights are factors >= 1.0, indicating how important it is to keep the + * filter type consistent between rows. Larger numbers mean the current + * filter is that many times as likely to be the same as the "num_weights" + * previous filters. This is cumulative for each previous row with a weight. + * There needs to be "num_weights" values in "filter_weights", or it can be + * NULL if the weights aren't being specified. Weights have no influence on + * the selection of the first row filter. Well chosen weights can (in theory) + * improve the compression for a given image. + * + * Costs are factors >= 1.0 indicating the relative decoding costs of a + * filter type. Higher costs indicate more decoding expense, and are + * therefore less likely to be selected over a filter with lower computational + * costs. There needs to be a value in "filter_costs" for each valid filter + * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't + * setting the costs. Costs try to improve the speed of decompression without + * unduly increasing the compressed image size. + * + * A negative weight or cost indicates the default value is to be used, and + * values in the range [0.0, 1.0) indicate the value is to remain unchanged. + * The default values for both weights and costs are currently 1.0, but may + * change if good general weighting/cost heuristics can be found. If both + * the weights and costs are set to 1.0, this degenerates the WEIGHTED method + * to the UNWEIGHTED method, but with added encoding time/computation. + */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, + int heuristic_method, int num_weights, png_doublep filter_weights, + png_doublep filter_costs)); +#endif +#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ + +/* Heuristic used for row filter selection. These defines should NOT be + * changed. + */ +#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ +#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ +#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ +#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ + +/* Set the library compression level. Currently, valid values range from + * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 + * (0 - no compression, 9 - "maximal" compression). Note that tests have + * shown that zlib compression levels 3-6 usually perform as well as level 9 + * for PNG images, and do considerably fewer caclulations. In the future, + * these values may not correspond directly to the zlib compression levels. + */ +extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, + int level)); + +extern PNG_EXPORT(void,png_set_compression_mem_level) + PNGARG((png_structp png_ptr, int mem_level)); + +extern PNG_EXPORT(void,png_set_compression_strategy) + PNGARG((png_structp png_ptr, int strategy)); + +extern PNG_EXPORT(void,png_set_compression_window_bits) + PNGARG((png_structp png_ptr, int window_bits)); + +extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, + int method)); + +/* These next functions are called for input/output, memory, and error + * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, + * and call standard C I/O routines such as fread(), fwrite(), and + * fprintf(). These functions can be made to use other I/O routines + * at run time for those applications that need to handle I/O in a + * different manner by calling png_set_???_fn(). See libpng.txt for + * more information. + */ + +#if !defined(PNG_NO_STDIO) +/* Initialize the input/output for the PNG file to the default functions. */ +extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); +#endif + +/* Replace the (error and abort), and warning functions with user + * supplied functions. If no messages are to be printed you must still + * write and use replacement functions. The replacement error_fn should + * still do a longjmp to the last setjmp location if you are using this + * method of error handling. If error_fn or warning_fn is NULL, the + * default function will be used. + */ + +extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, + png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); + +/* Return the user pointer associated with the error functions */ +extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); + +/* Replace the default data output functions with a user supplied one(s). + * If buffered output is not used, then output_flush_fn can be set to NULL. + * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time + * output_flush_fn will be ignored (and thus can be NULL). + */ +extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, + png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); + +/* Replace the default data input function with a user supplied one. */ +extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, + png_voidp io_ptr, png_rw_ptr read_data_fn)); + +/* Return the user pointer associated with the I/O functions */ +extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); + +extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, + png_read_status_ptr read_row_fn)); + +extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, + png_write_status_ptr write_row_fn)); + +#ifdef PNG_USER_MEM_SUPPORTED +/* Replace the default memory allocation functions with user supplied one(s). */ +extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +/* Return the user pointer associated with the memory functions */ +extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp + png_ptr, png_user_transform_ptr read_user_transform_fn)); +#endif + +#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp + png_ptr, png_user_transform_ptr write_user_transform_fn)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp + png_ptr, png_voidp user_transform_ptr, int user_transform_depth, + int user_transform_channels)); +/* Return the user pointer associated with the user transform functions */ +extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) + PNGARG((png_structp png_ptr)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, + png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp + png_ptr)); +#endif + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +/* Sets the function callbacks for the push reader, and a pointer to a + * user-defined structure available to the callback functions. + */ +extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, + png_voidp progressive_ptr, + png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, + png_progressive_end_ptr end_fn)); + +/* returns the user pointer associated with the push read functions */ +extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) + PNGARG((png_structp png_ptr)); + +/* function to be called when data becomes available */ +extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); + +/* function that combines rows. Not very much different than the + * png_combine_row() call. Is this even used????? + */ +extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, + png_bytep old_row, png_bytep new_row)); +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, + png_uint_32 size)); + +#if defined(PNG_1_0_X) +# define png_malloc_warn png_malloc +#else +/* Added at libpng version 1.2.4 */ +extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, + png_uint_32 size)); +#endif + +/* frees a pointer allocated by png_malloc() */ +extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); + +#if defined(PNG_1_0_X) +/* Function to allocate memory for zlib. */ +extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, + uInt size)); + +/* Function to free memory for zlib */ +extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); +#endif + +/* Free data that was allocated internally */ +extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 free_me, int num)); +#ifdef PNG_FREE_ME_SUPPORTED +/* Reassign responsibility for freeing existing data, whether allocated + * by libpng or by the application */ +extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, + png_infop info_ptr, int freer, png_uint_32 mask)); +#endif +/* assignments for png_data_freer */ +#define PNG_DESTROY_WILL_FREE_DATA 1 +#define PNG_SET_WILL_FREE_DATA 1 +#define PNG_USER_WILL_FREE_DATA 2 +/* Flags for png_ptr->free_me and info_ptr->free_me */ +#define PNG_FREE_HIST 0x0008 +#define PNG_FREE_ICCP 0x0010 +#define PNG_FREE_SPLT 0x0020 +#define PNG_FREE_ROWS 0x0040 +#define PNG_FREE_PCAL 0x0080 +#define PNG_FREE_SCAL 0x0100 +#define PNG_FREE_UNKN 0x0200 +#define PNG_FREE_LIST 0x0400 +#define PNG_FREE_PLTE 0x1000 +#define PNG_FREE_TRNS 0x2000 +#define PNG_FREE_TEXT 0x4000 +#define PNG_FREE_ALL 0x7fff +#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ + +#ifdef PNG_USER_MEM_SUPPORTED +extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, + png_uint_32 size)); +extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, + png_voidp ptr)); +#endif + +extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, + png_voidp s1, png_voidp s2, png_uint_32 size)); + +extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, + png_voidp s1, int value, png_uint_32 size)); + +#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ +extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, + int check)); +#endif /* USE_FAR_KEYWORD */ + +/* Fatal error in PNG image of libpng - can't continue */ +extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, + png_const_charp error_message)); + +/* The same, but the chunk name is prepended to the error string. */ +extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, + png_const_charp error_message)); + +/* Non-fatal error in libpng. Can continue, but may have a problem. */ +extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, + png_const_charp warning_message)); + +/* Non-fatal error in libpng, chunk name is prepended to message. */ +extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, + png_const_charp warning_message)); + +/* The png_set_ functions are for storing values in the png_info_struct. + * Similarly, the png_get_ calls are used to read values from the + * png_info_struct, either storing the parameters in the passed variables, or + * setting pointers into the png_info_struct where the data is stored. The + * png_get_ functions return a non-zero value if the data was available + * in info_ptr, or return zero and do not change any of the parameters if the + * data was not available. + * + * These functions should be used instead of directly accessing png_info + * to avoid problems with future changes in the size and internal layout of + * png_info_struct. + */ +/* Returns "flag" if chunk data is valid in info_ptr. */ +extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, +png_infop info_ptr, png_uint_32 flag)); + +/* Returns number of bytes needed to hold a transformed row. */ +extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_INFO_IMAGE_SUPPORTED) +/* Returns row_pointers, which is an array of pointers to scanlines that was +returned from png_read_png(). */ +extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, +png_infop info_ptr)); +/* Set row_pointers, which is an array of pointers to scanlines for use +by png_write_png(). */ +extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytepp row_pointers)); +#endif + +/* Returns number of color channels in image. */ +extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#ifdef PNG_EASY_ACCESS_SUPPORTED +/* Returns image width in pixels. */ +extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image height in pixels. */ +extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image bit_depth. */ +extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image color_type. */ +extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image filter_type. */ +extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image interlace_type. */ +extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image compression_type. */ +extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image resolution in pixels per meter, from pHYs chunk data. */ +extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns pixel aspect ratio, computed from pHYs chunk data. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +#endif + +/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +#endif /* PNG_EASY_ACCESS_SUPPORTED */ + +/* Returns pointer to signature string read from PNG header */ +extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_bKGD_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_16p *background)); +#endif + +#if defined(PNG_bKGD_SUPPORTED) +extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_16p background)); +#endif + +#if defined(PNG_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, double *white_x, double *white_y, double *red_x, + double *red_y, double *green_x, double *green_y, double *blue_x, + double *blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point + *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, + png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point + *int_blue_x, png_fixed_point *int_blue_y)); +#endif +#endif + +#if defined(PNG_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, double white_x, double white_y, double red_x, + double red_y, double green_x, double green_y, double blue_x, double blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, + png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point + int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +#endif +#endif + +#if defined(PNG_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, + png_infop info_ptr, double *file_gamma)); +#endif +extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point *int_file_gamma)); +#endif + +#if defined(PNG_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, + png_infop info_ptr, double file_gamma)); +#endif +extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_file_gamma)); +#endif + +#if defined(PNG_hIST_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_16p *hist)); +#endif + +#if defined(PNG_hIST_SUPPORTED) +extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_16p hist)); +#endif + +extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, + int *bit_depth, int *color_type, int *interlace_method, + int *compression_method, int *filter_method)); + +extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, + int color_type, int interlace_method, int compression_method, + int filter_method)); + +#if defined(PNG_oFFs_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, + int *unit_type)); +#endif + +#if defined(PNG_oFFs_SUPPORTED) +extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, + int unit_type)); +#endif + +#if defined(PNG_pCAL_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, + int *type, int *nparams, png_charp *units, png_charpp *params)); +#endif + +#if defined(PNG_pCAL_SUPPORTED) +extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, + int type, int nparams, png_charp units, png_charpp params)); +#endif + +#if defined(PNG_pHYs_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +#endif + +#if defined(PNG_pHYs_SUPPORTED) +extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +#endif + +extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_colorp *palette, int *num_palette)); + +extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_colorp palette, int num_palette)); + +#if defined(PNG_sBIT_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_8p *sig_bit)); +#endif + +#if defined(PNG_sBIT_SUPPORTED) +extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_8p sig_bit)); +#endif + +#if defined(PNG_sRGB_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *intent)); +#endif + +#if defined(PNG_sRGB_SUPPORTED) +extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, + png_infop info_ptr, int intent)); +extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, int intent)); +#endif + +#if defined(PNG_iCCP_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charpp name, int *compression_type, + png_charpp profile, png_uint_32 *proflen)); + /* Note to maintainer: profile should be png_bytepp */ +#endif + +#if defined(PNG_iCCP_SUPPORTED) +extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp name, int compression_type, + png_charp profile, png_uint_32 proflen)); + /* Note to maintainer: profile should be png_bytep */ +#endif + +#if defined(PNG_sPLT_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_sPLT_tpp entries)); +#endif + +#if defined(PNG_sPLT_SUPPORTED) +extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_sPLT_tp entries, int nentries)); +#endif + +#if defined(PNG_TEXT_SUPPORTED) +/* png_get_text also returns the number of text chunks in *num_text */ +extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp *text_ptr, int *num_text)); +#endif + +/* + * Note while png_set_text() will accept a structure whose text, + * language, and translated keywords are NULL pointers, the structure + * returned by png_get_text will always contain regular + * zero-terminated C strings. They might be empty strings but + * they will never be NULL pointers. + */ + +#if defined(PNG_TEXT_SUPPORTED) +extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp text_ptr, int num_text)); +#endif + +#if defined(PNG_tIME_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_timep *mod_time)); +#endif + +#if defined(PNG_tIME_SUPPORTED) +extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_timep mod_time)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep *trans, int *num_trans, + png_color_16p *trans_values)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep trans, int num_trans, + png_color_16p trans_values)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +#endif + +#if defined(PNG_sCAL_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *unit, double *width, double *height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); +#endif +#endif +#endif /* PNG_sCAL_SUPPORTED */ + +#if defined(PNG_sCAL_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, int unit, double width, double height)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, + png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); +#endif +#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +/* provide a list of chunks and how they are to be handled, if the built-in + handling or default unknown chunk handling is not desired. Any chunks not + listed will be handled in the default manner. The IHDR and IEND chunks + must not be listed. + keep = 0: follow default behavour + = 1: do not keep + = 2: keep only if safe-to-copy + = 3: keep even if unsafe-to-copy +*/ +extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp + png_ptr, int keep, png_bytep chunk_list, int num_chunks)); +extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); +extern PNG_EXPORT(void, png_set_unknown_chunk_location) + PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); +extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp + png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); +#endif +#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep + chunk_name)); +#endif + +/* Png_free_data() will turn off the "valid" flag for anything it frees. + If you need to turn it off for a chunk that your application has freed, + you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */ +extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, + png_infop info_ptr, int mask)); + +#if defined(PNG_INFO_IMAGE_SUPPORTED) +/* The "params" pointer is currently not used and is for future expansion. */ +extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, + png_infop info_ptr, + int transforms, + png_voidp params)); +extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, + png_infop info_ptr, + int transforms, + png_voidp params)); +#endif + +/* Define PNG_DEBUG at compile time for debugging information. Higher + * numbers for PNG_DEBUG mean more debugging information. This has + * only been added since version 0.95 so it is not implemented throughout + * libpng yet, but more support will be added as needed. + */ +#ifdef PNG_DEBUG +#if (PNG_DEBUG > 0) +#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) +#include +#if (PNG_DEBUG > 1) +#define png_debug(l,m) _RPT0(_CRT_WARN,m) +#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1) +#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2) +#endif +#else /* PNG_DEBUG_FILE || !_MSC_VER */ +#ifndef PNG_DEBUG_FILE +#define PNG_DEBUG_FILE stderr +#endif /* PNG_DEBUG_FILE */ +#if (PNG_DEBUG > 1) +#define png_debug(l,m) \ +{ \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ +} +#define png_debug1(l,m,p1) \ +{ \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ +} +#define png_debug2(l,m,p1,p2) \ +{ \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ +} +#endif /* (PNG_DEBUG > 1) */ +#endif /* _MSC_VER */ +#endif /* (PNG_DEBUG > 0) */ +#endif /* PNG_DEBUG */ +#ifndef png_debug +#define png_debug(l, m) +#endif +#ifndef png_debug1 +#define png_debug1(l, m, p1) +#endif +#ifndef png_debug2 +#define png_debug2(l, m, p1, p2) +#endif + +extern PNG_EXPORT(png_bytep,png_sig_bytes) PNGARG((void)); + +extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); + +#ifdef PNG_MNG_FEATURES_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp + png_ptr, png_uint_32 mng_features_permitted)); +#endif + +/* Added to version 1.2.0 */ +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ +#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ +#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 +#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 +#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 +#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 +#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 +#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 +#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ + +#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ + | PNG_ASM_FLAG_MMX_READ_INTERLACE \ + | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ + | PNG_ASM_FLAG_MMX_READ_FILTER_UP \ + | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ + | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) +#define PNG_MMX_WRITE_FLAGS ( 0 ) + +#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ + | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ + | PNG_MMX_READ_FLAGS \ + | PNG_MMX_WRITE_FLAGS ) + +#define PNG_SELECT_READ 1 +#define PNG_SELECT_WRITE 2 + + +#if !defined(PNG_1_0_X) +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) + PNGARG((int flag_select, int *compilerID)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) + PNGARG((int flag_select)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_asm_flags) + PNGARG((png_structp png_ptr)); + +/* pngget.c */ +extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) + PNGARG((png_structp png_ptr)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) + PNGARG((png_structp png_ptr)); + +/* pngset.c */ +extern PNG_EXPORT(void,png_set_asm_flags) + PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); + +/* pngset.c */ +extern PNG_EXPORT(void,png_set_mmx_thresholds) + PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, + png_uint_32 mmx_rowbytes_threshold)); + +#endif /* PNG_1_0_X */ +#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ + +#if !defined(PNG_1_0_X) +/* png.c, pnggccrd.c, or pngvcrd.c */ +extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); + +/* Strip the prepended error numbers ("#nnn ") from error and warning + * messages before passing them to the error or warning handler. */ +#ifdef PNG_ERROR_NUMBERS_SUPPORTED +extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp + png_ptr, png_uint_32 strip_mode)); +#endif +#endif /* PNG_1_0_X */ + +/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */ + +#define PNG_HEADER_VERSION_STRING \ + " libpng version 1.2.5 - October 3, 2002 (header)\n" + +#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED +/* With these routines we avoid an integer divide, which will be slower on + * most machines. However, it does take more operations than the corresponding + * divide method, so it may be slower on a few RISC systems. There are two + * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. + * + * Note that the rounding factors are NOT supposed to be the same! 128 and + * 32768 are correct for the NODIV code; 127 and 32767 are correct for the + * standard method. + * + * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] + */ + + /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ + +# define png_composite(composite, fg, alpha, bg) \ + { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ + + (png_uint_16)(bg)*(png_uint_16)(255 - \ + (png_uint_16)(alpha)) + (png_uint_16)128); \ + (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } + +# define png_composite_16(composite, fg, alpha, bg) \ + { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ + + (png_uint_32)(bg)*(png_uint_32)(65535L - \ + (png_uint_32)(alpha)) + (png_uint_32)32768L); \ + (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } + +#else /* standard method using integer division */ + +# define png_composite(composite, fg, alpha, bg) \ + (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ + (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ + (png_uint_16)127) / 255) + +# define png_composite_16(composite, fg, alpha, bg) \ + (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ + (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ + (png_uint_32)32767) / (png_uint_32)65535L) + +#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ + +/* These next functions are used internally in the code. They generally + * shouldn't be used unless you are writing code to add or replace some + * functionality in libpng. More information about most functions can + * be found in the files where the functions are located. + */ + +#if defined(PNG_INTERNAL) + +/* Various modes of operation. Note that after an init, mode is set to + * zero automatically when the structure is created. + */ +#define PNG_HAVE_IHDR 0x01 +#define PNG_HAVE_PLTE 0x02 +#define PNG_HAVE_IDAT 0x04 +#define PNG_AFTER_IDAT 0x08 +#define PNG_HAVE_IEND 0x10 +#define PNG_HAVE_gAMA 0x20 +#define PNG_HAVE_cHRM 0x40 +#define PNG_HAVE_sRGB 0x80 +#define PNG_HAVE_CHUNK_HEADER 0x100 +#define PNG_WROTE_tIME 0x200 +#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 +#define PNG_BACKGROUND_IS_GRAY 0x800 +#define PNG_HAVE_PNG_SIGNATURE 0x1000 + +/* flags for the transformations the PNG library does on the image data */ +#define PNG_BGR 0x0001 +#define PNG_INTERLACE 0x0002 +#define PNG_PACK 0x0004 +#define PNG_SHIFT 0x0008 +#define PNG_SWAP_BYTES 0x0010 +#define PNG_INVERT_MONO 0x0020 +#define PNG_DITHER 0x0040 +#define PNG_BACKGROUND 0x0080 +#define PNG_BACKGROUND_EXPAND 0x0100 + /* 0x0200 unused */ +#define PNG_16_TO_8 0x0400 +#define PNG_RGBA 0x0800 +#define PNG_EXPAND 0x1000 +#define PNG_GAMMA 0x2000 +#define PNG_GRAY_TO_RGB 0x4000 +#define PNG_FILLER 0x8000L +#define PNG_PACKSWAP 0x10000L +#define PNG_SWAP_ALPHA 0x20000L +#define PNG_STRIP_ALPHA 0x40000L +#define PNG_INVERT_ALPHA 0x80000L +#define PNG_USER_TRANSFORM 0x100000L +#define PNG_RGB_TO_GRAY_ERR 0x200000L +#define PNG_RGB_TO_GRAY_WARN 0x400000L +#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ + +/* flags for png_create_struct */ +#define PNG_STRUCT_PNG 0x0001 +#define PNG_STRUCT_INFO 0x0002 + +/* Scaling factor for filter heuristic weighting calculations */ +#define PNG_WEIGHT_SHIFT 8 +#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) +#define PNG_COST_SHIFT 3 +#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) + +/* flags for the png_ptr->flags rather than declaring a byte for each one */ +#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 +#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 +#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 +#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 +#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 +#define PNG_FLAG_ZLIB_FINISHED 0x0020 +#define PNG_FLAG_ROW_INIT 0x0040 +#define PNG_FLAG_FILLER_AFTER 0x0080 +#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 +#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 +#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 +#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 +#define PNG_FLAG_FREE_PLTE 0x1000 +#define PNG_FLAG_FREE_TRNS 0x2000 +#define PNG_FLAG_FREE_HIST 0x4000 +#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L +#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L +#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L +#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L +#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L +#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L + +/* For use in png_set_keep_unknown, png_handle_as_unknown */ +#define HANDLE_CHUNK_AS_DEFAULT 0 +#define HANDLE_CHUNK_NEVER 1 +#define HANDLE_CHUNK_IF_SAFE 2 +#define HANDLE_CHUNK_ALWAYS 3 + +#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ + PNG_FLAG_CRC_ANCILLARY_NOWARN) + +#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ + PNG_FLAG_CRC_CRITICAL_IGNORE) + +#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ + PNG_FLAG_CRC_CRITICAL_MASK) + +/* save typing and make code easier to understand */ +#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ + abs((int)((c1).green) - (int)((c2).green)) + \ + abs((int)((c1).blue) - (int)((c2).blue))) + +/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ +#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) +/* place to hold the signature string for a PNG file. */ +#ifdef PNG_USE_GLOBAL_ARRAYS + PNG_EXPORT_VAR (const png_byte FARDATA) png_sig[8]; +#else +#define png_sig png_sig_bytes(NULL) +#endif +#endif /* PNG_NO_EXTERN */ + +/* Constant strings for known chunk types. If you need to add a chunk, + * define the name here, and add an invocation of the macro in png.c and + * wherever it's needed. + */ +#define PNG_IHDR const png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} +#define PNG_IDAT const png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} +#define PNG_IEND const png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} +#define PNG_PLTE const png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} +#define PNG_bKGD const png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} +#define PNG_cHRM const png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} +#define PNG_gAMA const png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} +#define PNG_hIST const png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} +#define PNG_iCCP const png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} +#define PNG_iTXt const png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} +#define PNG_oFFs const png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} +#define PNG_pCAL const png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} +#define PNG_sCAL const png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} +#define PNG_pHYs const png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} +#define PNG_sBIT const png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} +#define PNG_sPLT const png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} +#define PNG_sRGB const png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} +#define PNG_tEXt const png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} +#define PNG_tIME const png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} +#define PNG_tRNS const png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} +#define PNG_zTXt const png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} + +#ifdef PNG_USE_GLOBAL_ARRAYS +PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_IDAT[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_IEND[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_PLTE[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_bKGD[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_cHRM[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_gAMA[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_hIST[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_iCCP[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_iTXt[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_oFFs[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_pCAL[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_sCAL[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_pHYs[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_sBIT[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_sPLT[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_sRGB[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_tEXt[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_tIME[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_tRNS[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_zTXt[5]; +#endif /* PNG_USE_GLOBAL_ARRAYS */ + + +/* Inline macros to do direct reads of bytes from the input buffer. These + * require that you are using an architecture that uses PNG byte ordering + * (MSB first) and supports unaligned data storage. I think that PowerPC + * in big-endian mode and 680x0 are the only ones that will support this. + * The x86 line of processors definitely do not. The png_get_int_32() + * routine also assumes we are using two's complement format for negative + * values, which is almost certainly true. + */ +#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED) +# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) +# define png_get_int_32(buf) ( *((png_int_32p) (buf))) +# endif +# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) +# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) +#else +# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) +PNG_EXTERN png_int_32 png_get_int_32 PNGARG((png_bytep buf)); +# endif +PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf)); +PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf)); +#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ + +/* Initialize png_ptr struct for reading, and allocate any other memory. + * (old interface - DEPRECATED - use png_create_read_struct instead). + */ +extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)); +#undef png_read_init +#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ + PNG_LIBPNG_VER_STRING, sizeof(png_struct)); +extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size)); +extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t + png_info_size)); + +/* Initialize png_ptr struct for writing, and allocate any other memory. + * (old interface - DEPRECATED - use png_create_write_struct instead). + */ +extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)); +#undef png_write_init +#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ + PNG_LIBPNG_VER_STRING, sizeof(png_struct)); +extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size)); +extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t + png_info_size)); + +/* Allocate memory for an internal libpng struct */ +PNG_EXTERN png_voidp png_create_struct PNGARG((int type)); + +/* Free memory from internal libpng struct */ +PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); + +PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr + malloc_fn, png_voidp mem_ptr)); +PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, + png_free_ptr free_fn, png_voidp mem_ptr)); + +/* Free any memory that info_ptr points to and reset struct. */ +PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_1_0_X +/* Function to allocate memory for zlib. */ +PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size)); + +/* Function to free memory for zlib */ +PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); + +/* Next four functions are used internally as callbacks. PNGAPI is required + * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */ + +PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t length)); +#endif + +PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +#if !defined(PNG_NO_STDIO) +PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)); +#endif +#endif +#else /* PNG_1_0_X */ +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t length)); +#endif +#endif /* PNG_1_0_X */ + +/* Reset the CRC variable */ +PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); + +/* Write the "data" buffer to whatever output you are using. */ +PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +/* Read data from whatever input you are using into the "data" buffer */ +PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +/* Read bytes into buf, and update png_ptr->crc */ +PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, + png_size_t length)); + +/* Decompress data in a chunk that uses compression */ +#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ + defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) +PNG_EXTERN png_charp png_decompress_chunk PNGARG((png_structp png_ptr, + int comp_type, png_charp chunkdata, png_size_t chunklength, + png_size_t prefix_length, png_size_t *data_length)); +#endif + +/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ +PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); + +/* Read the CRC from the file and compare it to the libpng calculated CRC */ +PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); + +/* Calculate the CRC over a section of data. Note that we are only + * passing a maximum of 64K on systems that have this as a memory limit, + * since this is the maximum buffer size we can specify. + */ +PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, + png_size_t length)); + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); +#endif + + +/* Place a 32-bit number into a buffer in PNG byte order (big-endian). + * The only currently known PNG chunks that use signed numbers are + * the ancillary extension chunks, oFFs and pCAL. + */ +PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i)); + +#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) +PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i)); +#endif + +/* Place a 16-bit number into a buffer in PNG byte order. + * The parameter is declared unsigned int, not png_uint_16, + * just to avoid potential problems on pre-ANSI C compilers. + */ +PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, unsigned int i)); + +/* simple function to write the signature */ +PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)); + +/* write various chunks */ + +/* Write the IHDR chunk, and update the png_struct with the necessary + * information. + */ +PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, + png_uint_32 height, + int bit_depth, int color_type, int compression_method, int filter_method, + int interlace_method)); + +PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, + png_uint_32 num_pal)); + +PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); + +#if defined(PNG_WRITE_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point + file_gamma)); +#endif +#endif + +#if defined(PNG_WRITE_sBIT_SUPPORTED) +PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, + int color_type)); +#endif + +#if defined(PNG_WRITE_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, + double white_x, double white_y, + double red_x, double red_y, double green_x, double green_y, + double blue_x, double blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, + png_fixed_point int_white_x, png_fixed_point int_white_y, + png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point + int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +#endif +#endif + +#if defined(PNG_WRITE_sRGB_SUPPORTED) +PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, + int intent)); +#endif + +#if defined(PNG_WRITE_iCCP_SUPPORTED) +PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, + png_charp name, int compression_type, + png_charp profile, int proflen)); + /* Note to maintainer: profile should be png_bytep */ +#endif + +#if defined(PNG_WRITE_sPLT_SUPPORTED) +PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, + png_sPLT_tp palette)); +#endif + +#if defined(PNG_WRITE_tRNS_SUPPORTED) +PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, + png_color_16p values, int number, int color_type)); +#endif + +#if defined(PNG_WRITE_bKGD_SUPPORTED) +PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, + png_color_16p values, int color_type)); +#endif + +#if defined(PNG_WRITE_hIST_SUPPORTED) +PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, + int num_hist)); +#endif + +#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ + defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) +PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, + png_charp key, png_charpp new_key)); +#endif + +#if defined(PNG_WRITE_tEXt_SUPPORTED) +PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, + png_charp text, png_size_t text_len)); +#endif + +#if defined(PNG_WRITE_zTXt_SUPPORTED) +PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, + png_charp text, png_size_t text_len, int compression)); +#endif + +#if defined(PNG_WRITE_iTXt_SUPPORTED) +PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, + int compression, png_charp key, png_charp lang, png_charp lang_key, + png_charp text)); +#endif + +#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */ +PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp text_ptr, int num_text)); +#endif + +#if defined(PNG_WRITE_oFFs_SUPPORTED) +PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, + png_int_32 x_offset, png_int_32 y_offset, int unit_type)); +#endif + +#if defined(PNG_WRITE_pCAL_SUPPORTED) +PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, + png_int_32 X0, png_int_32 X1, int type, int nparams, + png_charp units, png_charpp params)); +#endif + +#if defined(PNG_WRITE_pHYs_SUPPORTED) +PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, + png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, + int unit_type)); +#endif + +#if defined(PNG_WRITE_tIME_SUPPORTED) +PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, + png_timep mod_time)); +#endif + +#if defined(PNG_WRITE_sCAL_SUPPORTED) +#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) +PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, + int unit, double width, double height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, + int unit, png_charp width, png_charp height)); +#endif +#endif +#endif + +/* Called when finished processing a row of data */ +PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); + +/* Internal use only. Called before first row of data */ +PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); + +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)); +#endif + +/* combine a row of data, dealing with alpha, etc. if requested */ +PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, + int mask)); + +#if defined(PNG_READ_INTERLACING_SUPPORTED) +/* expand an interlaced row */ +/* OLD pre-1.0.9 interface: +PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, + png_bytep row, int pass, png_uint_32 transformations)); + */ +PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); +#endif + +/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ + +#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* grab pixels out of a row for an interlaced pass */ +PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, + png_bytep row, int pass)); +#endif + +/* unfilter a row */ +PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, + png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter)); + +/* Choose the best filter to use and filter the row data */ +PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, + png_row_infop row_info)); + +/* Write out the filtered row. */ +PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, + png_bytep filtered_row)); +/* finish a row while reading, dealing with interlacing passes, etc. */ +PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); + +/* initialize the row buffers, etc. */ +PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); +/* optional call to update the users info structure */ +PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* these are the functions that do the transformations */ +#if defined(PNG_READ_FILLER_SUPPORTED) +PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 filler, png_uint_32 flags)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ + defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 flags)); +#endif + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop + row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) +PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) +PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, + png_color_8p sig_bits)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_16_TO_8_SUPPORTED) +PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) +PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, + png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); + +# if defined(PNG_CORRECT_PALETTE_SUPPORTED) +PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, + png_colorp palette, int num_palette)); +# endif +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_WRITE_PACK_SUPPORTED) +PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 bit_depth)); +#endif + +#if defined(PNG_WRITE_SHIFT_SUPPORTED) +PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, + png_color_8p bit_depth)); +#endif + +#if defined(PNG_READ_BACKGROUND_SUPPORTED) +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, + png_color_16p trans_values, png_color_16p background, + png_color_16p background_1, + png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, + png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, + png_uint_16pp gamma_16_to_1, int gamma_shift)); +#else +PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, + png_color_16p trans_values, png_color_16p background)); +#endif +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, + png_bytep gamma_table, png_uint_16pp gamma_16_table, + int gamma_shift)); +#endif + +#if defined(PNG_READ_EXPAND_SUPPORTED) +PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, + png_bytep row, png_colorp palette, png_bytep trans, int num_trans)); +PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, + png_bytep row, png_color_16p trans_value)); +#endif + +/* The following decodes the appropriate chunks, and does error correction, + * then calls the appropriate callback for the chunk if it is valid. + */ + +/* decode the IHDR chunk */ +PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); + +#if defined(PNG_READ_bKGD_SUPPORTED) +PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_cHRM_SUPPORTED) +PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_gAMA_SUPPORTED) +PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_hIST_SUPPORTED) +PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_iCCP_SUPPORTED) +extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif /* PNG_READ_iCCP_SUPPORTED */ + +#if defined(PNG_READ_iTXt_SUPPORTED) +PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_oFFs_SUPPORTED) +PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_pCAL_SUPPORTED) +PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_pHYs_SUPPORTED) +PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sBIT_SUPPORTED) +PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sCAL_SUPPORTED) +PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sPLT_SUPPORTED) +extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif /* PNG_READ_sPLT_SUPPORTED */ + +#if defined(PNG_READ_sRGB_SUPPORTED) +PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tEXt_SUPPORTED) +PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tIME_SUPPORTED) +PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tRNS_SUPPORTED) +PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_zTXt_SUPPORTED) +PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); + +PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, + png_bytep chunk_name)); + +/* handle the transformations for reading and writing */ +PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); + +PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, + png_uint_32 length)); +PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t buffer_length)); +PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t buffer_length)); +PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); +PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); +#if defined(PNG_READ_tEXt_SUPPORTED) +PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif +#if defined(PNG_READ_zTXt_SUPPORTED) +PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif +#if defined(PNG_READ_iTXt_SUPPORTED) +PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif + +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +#ifdef PNG_MNG_FEATURES_SUPPORTED +PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, + png_bytep row)); +PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +/* png.c */ /* PRIVATE */ +PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)); +#endif +/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ + +#endif /* PNG_INTERNAL */ + +#ifdef __cplusplus +} +#endif + +#endif /* PNG_VERSION_INFO_ONLY */ +/* do not put anything past this line */ +#endif /* PNG_H */ diff --git a/stepmania/src/libpng/include/pngconf.h b/stepmania/src/libpng/include/pngconf.h new file mode 100644 index 0000000000..4a425dd1aa --- /dev/null +++ b/stepmania/src/libpng/include/pngconf.h @@ -0,0 +1,1348 @@ +/* pngconf.h - machine configurable file for libpng + * + * libpng 1.2.5 - October 3, 2002 + * For conditions of distribution and use, see copyright notice in png.h + * Copyright (c) 1998-2002 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + */ + +/* Any machine specific code is near the front of this file, so if you + * are configuring libpng for a machine, you may want to read the section + * starting here down to where it starts to typedef png_color, png_text, + * and png_info. + */ + +#ifndef PNGCONF_H +#define PNGCONF_H + +/* This is the size of the compression buffer, and thus the size of + * an IDAT chunk. Make this whatever size you feel is best for your + * machine. One of these will be allocated per png_struct. When this + * is full, it writes the data to the disk, and does some other + * calculations. Making this an extremely small size will slow + * the library down, but you may want to experiment to determine + * where it becomes significant, if you are concerned with memory + * usage. Note that zlib allocates at least 32Kb also. For readers, + * this describes the size of the buffer available to read the data in. + * Unless this gets smaller than the size of a row (compressed), + * it should not make much difference how big this is. + */ + +#ifndef PNG_ZBUF_SIZE +# define PNG_ZBUF_SIZE 8192 +#endif + +/* Enable if you want a write-only libpng */ + +#ifndef PNG_NO_READ_SUPPORTED +# define PNG_READ_SUPPORTED +#endif + +/* Enable if you want a read-only libpng */ + +#ifndef PNG_NO_WRITE_SUPPORTED +# define PNG_WRITE_SUPPORTED +#endif + +/* Enabled by default in 1.2.0. You can disable this if you don't need to + support PNGs that are embedded in MNG datastreams */ +#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) +# ifndef PNG_MNG_FEATURES_SUPPORTED +# define PNG_MNG_FEATURES_SUPPORTED +# endif +#endif + +#ifndef PNG_NO_FLOATING_POINT_SUPPORTED +# ifndef PNG_FLOATING_POINT_SUPPORTED +# define PNG_FLOATING_POINT_SUPPORTED +# endif +#endif + +/* If you are running on a machine where you cannot allocate more + * than 64K of memory at once, uncomment this. While libpng will not + * normally need that much memory in a chunk (unless you load up a very + * large file), zlib needs to know how big of a chunk it can use, and + * libpng thus makes sure to check any memory allocation to verify it + * will fit into memory. +#define PNG_MAX_MALLOC_64K + */ +#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) +# define PNG_MAX_MALLOC_64K +#endif + +/* Special munging to support doing things the 'cygwin' way: + * 'Normal' png-on-win32 defines/defaults: + * PNG_BUILD_DLL -- building dll + * PNG_USE_DLL -- building an application, linking to dll + * (no define) -- building static library, or building an + * application and linking to the static lib + * 'Cygwin' defines/defaults: + * PNG_BUILD_DLL -- (ignored) building the dll + * (no define) -- (ignored) building an application, linking to the dll + * PNG_STATIC -- (ignored) building the static lib, or building an + * application that links to the static lib. + * ALL_STATIC -- (ignored) building various static libs, or building an + * application that links to the static libs. + * Thus, + * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and + * this bit of #ifdefs will define the 'correct' config variables based on + * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but + * unnecessary. + * + * Also, the precedence order is: + * ALL_STATIC (since we can't #undef something outside our namespace) + * PNG_BUILD_DLL + * PNG_STATIC + * (nothing) == PNG_USE_DLL + * + * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent + * of auto-import in binutils, we no longer need to worry about + * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, + * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes + * to __declspec() stuff. However, we DO need to worry about + * PNG_BUILD_DLL and PNG_STATIC because those change some defaults + * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. + */ +#if defined(__CYGWIN__) +# if defined(ALL_STATIC) +# if defined(PNG_BUILD_DLL) +# undef PNG_BUILD_DLL +# endif +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if defined(PNG_DLL) +# undef PNG_DLL +# endif +# if !defined(PNG_STATIC) +# define PNG_STATIC +# endif +# else +# if defined (PNG_BUILD_DLL) +# if defined(PNG_STATIC) +# undef PNG_STATIC +# endif +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if !defined(PNG_DLL) +# define PNG_DLL +# endif +# else +# if defined(PNG_STATIC) +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if defined(PNG_DLL) +# undef PNG_DLL +# endif +# else +# if !defined(PNG_USE_DLL) +# define PNG_USE_DLL +# endif +# if !defined(PNG_DLL) +# define PNG_DLL +# endif +# endif +# endif +# endif +#endif + +/* This protects us against compilers that run on a windowing system + * and thus don't have or would rather us not use the stdio types: + * stdin, stdout, and stderr. The only one currently used is stderr + * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will + * prevent these from being compiled and used. #defining PNG_NO_STDIO + * will also prevent these, plus will prevent the entire set of stdio + * macros and functions (FILE *, printf, etc.) from being compiled and used, + * unless (PNG_DEBUG > 0) has been #defined. + * + * #define PNG_NO_CONSOLE_IO + * #define PNG_NO_STDIO + */ + +#if defined(_WIN32_WCE) +# include + /* Console I/O functions are not supported on WindowsCE */ +# define PNG_NO_CONSOLE_IO +# ifdef PNG_DEBUG +# undef PNG_DEBUG +# endif +#endif + +#ifdef PNG_BUILD_DLL +# ifndef PNG_CONSOLE_IO_SUPPORTED +# ifndef PNG_NO_CONSOLE_IO +# define PNG_NO_CONSOLE_IO +# endif +# endif +#endif + +# ifdef PNG_NO_STDIO +# ifndef PNG_NO_CONSOLE_IO +# define PNG_NO_CONSOLE_IO +# endif +# ifdef PNG_DEBUG +# if (PNG_DEBUG > 0) +# include +# endif +# endif +# else +# if !defined(_WIN32_WCE) +/* "stdio.h" functions are not supported on WindowsCE */ +# include +# endif +# endif + +/* This macro protects us against machines that don't have function + * prototypes (ie K&R style headers). If your compiler does not handle + * function prototypes, define this macro and use the included ansi2knr. + * I've always been able to use _NO_PROTO as the indicator, but you may + * need to drag the empty declaration out in front of here, or change the + * ifdef to suit your own needs. + */ +#ifndef PNGARG + +#ifdef OF /* zlib prototype munger */ +# define PNGARG(arglist) OF(arglist) +#else + +#ifdef _NO_PROTO +# define PNGARG(arglist) () +# ifndef PNG_TYPECAST_NULL +# define PNG_TYPECAST_NULL +# endif +#else +# define PNGARG(arglist) arglist +#endif /* _NO_PROTO */ + +#endif /* OF */ + +#endif /* PNGARG */ + +/* Try to determine if we are compiling on a Mac. Note that testing for + * just __MWERKS__ is not good enough, because the Codewarrior is now used + * on non-Mac platforms. + */ +#ifndef MACOS +# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ + defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) +# define MACOS +# endif +#endif + +/* enough people need this for various reasons to include it here */ +#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) +# include +#endif + +#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) +# define PNG_SETJMP_SUPPORTED +#endif + +#ifdef PNG_SETJMP_SUPPORTED +/* This is an attempt to force a single setjmp behaviour on Linux. If + * the X config stuff didn't define _BSD_SOURCE we wouldn't need this. + */ + +# ifdef __linux__ +# ifdef _BSD_SOURCE +# define PNG_SAVE_BSD_SOURCE +# undef _BSD_SOURCE +# endif +# ifdef _SETJMP_H + __png.h__ already includes setjmp.h; + __dont__ include it again.; +# endif +# endif /* __linux__ */ + + /* include setjmp.h for error handling */ +# include + +# ifdef __linux__ +# ifdef PNG_SAVE_BSD_SOURCE +# define _BSD_SOURCE +# undef PNG_SAVE_BSD_SOURCE +# endif +# endif /* __linux__ */ +#endif /* PNG_SETJMP_SUPPORTED */ + +#ifdef BSD +# include +#else +# include +#endif + +/* Other defines for things like memory and the like can go here. */ +#ifdef PNG_INTERNAL + +#include + +/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which + * aren't usually used outside the library (as far as I know), so it is + * debatable if they should be exported at all. In the future, when it is + * possible to have run-time registry of chunk-handling functions, some of + * these will be made available again. +#define PNG_EXTERN extern + */ +#define PNG_EXTERN + +/* Other defines specific to compilers can go here. Try to keep + * them inside an appropriate ifdef/endif pair for portability. + */ + +#if defined(PNG_FLOATING_POINT_SUPPORTED) +# if defined(MACOS) + /* We need to check that hasn't already been included earlier + * as it seems it doesn't agree with , yet we should really use + * if possible. + */ +# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) +# include +# endif +# else +# include +# endif +# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) + /* Amiga SAS/C: We must include builtin FPU functions when compiling using + * MATH=68881 + */ +# include +# endif +#endif + +/* Codewarrior on NT has linking problems without this. */ +#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) +# define PNG_ALWAYS_EXTERN +#endif + +/* For some reason, Borland C++ defines memcmp, etc. in mem.h, not + * stdlib.h like it should (I think). Or perhaps this is a C++ + * "feature"? + */ +#ifdef __TURBOC__ +# include +# include "alloc.h" +#endif + +#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ + defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) +# include +#endif + +/* This controls how fine the dithering gets. As this allocates + * a largish chunk of memory (32K), those who are not as concerned + * with dithering quality can decrease some or all of these. + */ +#ifndef PNG_DITHER_RED_BITS +# define PNG_DITHER_RED_BITS 5 +#endif +#ifndef PNG_DITHER_GREEN_BITS +# define PNG_DITHER_GREEN_BITS 5 +#endif +#ifndef PNG_DITHER_BLUE_BITS +# define PNG_DITHER_BLUE_BITS 5 +#endif + +/* This controls how fine the gamma correction becomes when you + * are only interested in 8 bits anyway. Increasing this value + * results in more memory being used, and more pow() functions + * being called to fill in the gamma tables. Don't set this value + * less then 8, and even that may not work (I haven't tested it). + */ + +#ifndef PNG_MAX_GAMMA_8 +# define PNG_MAX_GAMMA_8 11 +#endif + +/* This controls how much a difference in gamma we can tolerate before + * we actually start doing gamma conversion. + */ +#ifndef PNG_GAMMA_THRESHOLD +# define PNG_GAMMA_THRESHOLD 0.05 +#endif + +#endif /* PNG_INTERNAL */ + +/* The following uses const char * instead of char * for error + * and warning message functions, so some compilers won't complain. + * If you do not want to use const, define PNG_NO_CONST here. + */ + +#ifndef PNG_NO_CONST +# define PNG_CONST const +#else +# define PNG_CONST +#endif + +/* The following defines give you the ability to remove code from the + * library that you will not be using. I wish I could figure out how to + * automate this, but I can't do that without making it seriously hard + * on the users. So if you are not using an ability, change the #define + * to and #undef, and that part of the library will not be compiled. If + * your linker can't find a function, you may want to make sure the + * ability is defined here. Some of these depend upon some others being + * defined. I haven't figured out all the interactions here, so you may + * have to experiment awhile to get everything to compile. If you are + * creating or using a shared library, you probably shouldn't touch this, + * as it will affect the size of the structures, and this will cause bad + * things to happen if the library and/or application ever change. + */ + +/* Any features you will not be using can be undef'ed here */ + +/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user + * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS + * on the compile line, then pick and choose which ones to define without + * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED + * if you only want to have a png-compliant reader/writer but don't need + * any of the extra transformations. This saves about 80 kbytes in a + * typical installation of the library. (PNG_NO_* form added in version + * 1.0.1c, for consistency) + */ + +/* The size of the png_text structure changed in libpng-1.0.6 when + * iTXt is supported. It is turned off by default, to support old apps + * that malloc the png_text structure instead of calling png_set_text() + * and letting libpng malloc it. It will be turned on by default in + * libpng-1.3.0. + */ + +#ifndef PNG_iTXt_SUPPORTED +# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) +# define PNG_NO_READ_iTXt +# endif +# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) +# define PNG_NO_WRITE_iTXt +# endif +#endif + +/* The following support, added after version 1.0.0, can be turned off here en + * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility + * with old applications that require the length of png_struct and png_info + * to remain unchanged. + */ + +#ifdef PNG_LEGACY_SUPPORTED +# define PNG_NO_FREE_ME +# define PNG_NO_READ_UNKNOWN_CHUNKS +# define PNG_NO_WRITE_UNKNOWN_CHUNKS +# define PNG_NO_READ_USER_CHUNKS +# define PNG_NO_READ_iCCP +# define PNG_NO_WRITE_iCCP +# define PNG_NO_READ_iTXt +# define PNG_NO_WRITE_iTXt +# define PNG_NO_READ_sCAL +# define PNG_NO_WRITE_sCAL +# define PNG_NO_READ_sPLT +# define PNG_NO_WRITE_sPLT +# define PNG_NO_INFO_IMAGE +# define PNG_NO_READ_RGB_TO_GRAY +# define PNG_NO_READ_USER_TRANSFORM +# define PNG_NO_WRITE_USER_TRANSFORM +# define PNG_NO_USER_MEM +# define PNG_NO_READ_EMPTY_PLTE +# define PNG_NO_MNG_FEATURES +# define PNG_NO_FIXED_POINT_SUPPORTED +#endif + +/* Ignore attempt to turn off both floating and fixed point support */ +#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ + !defined(PNG_NO_FIXED_POINT_SUPPORTED) +# define PNG_FIXED_POINT_SUPPORTED +#endif + +#ifndef PNG_NO_FREE_ME +# define PNG_FREE_ME_SUPPORTED +#endif + +#if defined(PNG_READ_SUPPORTED) + +#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ + !defined(PNG_NO_READ_TRANSFORMS) +# define PNG_READ_TRANSFORMS_SUPPORTED +#endif + +#ifdef PNG_READ_TRANSFORMS_SUPPORTED +# ifndef PNG_NO_READ_EXPAND +# define PNG_READ_EXPAND_SUPPORTED +# endif +# ifndef PNG_NO_READ_SHIFT +# define PNG_READ_SHIFT_SUPPORTED +# endif +# ifndef PNG_NO_READ_PACK +# define PNG_READ_PACK_SUPPORTED +# endif +# ifndef PNG_NO_READ_BGR +# define PNG_READ_BGR_SUPPORTED +# endif +# ifndef PNG_NO_READ_SWAP +# define PNG_READ_SWAP_SUPPORTED +# endif +# ifndef PNG_NO_READ_PACKSWAP +# define PNG_READ_PACKSWAP_SUPPORTED +# endif +# ifndef PNG_NO_READ_INVERT +# define PNG_READ_INVERT_SUPPORTED +# endif +# ifndef PNG_NO_READ_DITHER +# define PNG_READ_DITHER_SUPPORTED +# endif +# ifndef PNG_NO_READ_BACKGROUND +# define PNG_READ_BACKGROUND_SUPPORTED +# endif +# ifndef PNG_NO_READ_16_TO_8 +# define PNG_READ_16_TO_8_SUPPORTED +# endif +# ifndef PNG_NO_READ_FILLER +# define PNG_READ_FILLER_SUPPORTED +# endif +# ifndef PNG_NO_READ_GAMMA +# define PNG_READ_GAMMA_SUPPORTED +# endif +# ifndef PNG_NO_READ_GRAY_TO_RGB +# define PNG_READ_GRAY_TO_RGB_SUPPORTED +# endif +# ifndef PNG_NO_READ_SWAP_ALPHA +# define PNG_READ_SWAP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_INVERT_ALPHA +# define PNG_READ_INVERT_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_STRIP_ALPHA +# define PNG_READ_STRIP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_USER_TRANSFORM +# define PNG_READ_USER_TRANSFORM_SUPPORTED +# endif +# ifndef PNG_NO_READ_RGB_TO_GRAY +# define PNG_READ_RGB_TO_GRAY_SUPPORTED +# endif +#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ + +#if !defined(PNG_NO_PROGRESSIVE_READ) && \ + !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive */ +# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ +#endif /* about interlacing capability! You'll */ + /* still have interlacing unless you change the following line: */ + +#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */ + +#ifndef PNG_NO_READ_COMPOSITE_NODIV +# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ +# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ +# endif +#endif + +/* Deprecated, will be removed from version 2.0.0. + Use PNG_MNG_FEATURES_SUPPORTED instead. */ +#ifndef PNG_NO_READ_EMPTY_PLTE +# define PNG_READ_EMPTY_PLTE_SUPPORTED +#endif + +#endif /* PNG_READ_SUPPORTED */ + +#if defined(PNG_WRITE_SUPPORTED) + +# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ + !defined(PNG_NO_WRITE_TRANSFORMS) +# define PNG_WRITE_TRANSFORMS_SUPPORTED +#endif + +#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED +# ifndef PNG_NO_WRITE_SHIFT +# define PNG_WRITE_SHIFT_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_PACK +# define PNG_WRITE_PACK_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_BGR +# define PNG_WRITE_BGR_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_SWAP +# define PNG_WRITE_SWAP_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_PACKSWAP +# define PNG_WRITE_PACKSWAP_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_INVERT +# define PNG_WRITE_INVERT_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_FILLER +# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ +# endif +# ifndef PNG_NO_WRITE_SWAP_ALPHA +# define PNG_WRITE_SWAP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_INVERT_ALPHA +# define PNG_WRITE_INVERT_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_USER_TRANSFORM +# define PNG_WRITE_USER_TRANSFORM_SUPPORTED +# endif +#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +# ifndef PNG_NO_USER_TRANSFORM_PTR +# define PNG_USER_TRANSFORM_PTR_SUPPORTED +# endif +#endif + +#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant + encoders, but can cause trouble + if left undefined */ + +#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ + defined(PNG_FLOATING_POINT_SUPPORTED) +# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +#endif + +#ifndef PNG_1_0_X +#ifndef PNG_NO_ERROR_NUMBERS +#define PNG_ERROR_NUMBERS_SUPPORTED +#endif +#endif /* PNG_1_0_X */ + +#ifndef PNG_NO_WRITE_FLUSH +# define PNG_WRITE_FLUSH_SUPPORTED +#endif + +/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ +#ifndef PNG_NO_WRITE_EMPTY_PLTE +# define PNG_WRITE_EMPTY_PLTE_SUPPORTED +#endif + +#endif /* PNG_WRITE_SUPPORTED */ + +#ifndef PNG_NO_STDIO +# define PNG_TIME_RFC1123_SUPPORTED +#endif + +/* This adds extra functions in pngget.c for accessing data from the + * info pointer (added in version 0.99) + * png_get_image_width() + * png_get_image_height() + * png_get_bit_depth() + * png_get_color_type() + * png_get_compression_type() + * png_get_filter_type() + * png_get_interlace_type() + * png_get_pixel_aspect_ratio() + * png_get_pixels_per_meter() + * png_get_x_offset_pixels() + * png_get_y_offset_pixels() + * png_get_x_offset_microns() + * png_get_y_offset_microns() + */ +#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) +# define PNG_EASY_ACCESS_SUPPORTED +#endif + +/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 + even when PNG_USE_PNGVCRD or PNG_USE_PNGGCCRD is not defined */ +#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) +# ifndef PNG_ASSEMBLER_CODE_SUPPORTED +# define PNG_ASSEMBLER_CODE_SUPPORTED +# endif +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_MMX_CODE_SUPPORTED +# endif +#endif + +/* If you are sure that you don't need thread safety and you are compiling + with PNG_USE_PNGCCRD for an MMX application, you can define this for + faster execution. See pnggccrd.c. +#define PNG_THREAD_UNSAFE_OK +*/ + +#if !defined(PNG_1_0_X) +#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) +# define PNG_USER_MEM_SUPPORTED +#endif +#endif /* PNG_1_0_X */ + +/* These are currently experimental features, define them if you want */ + +/* very little testing */ +/* +#ifdef PNG_READ_SUPPORTED +# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +# endif +#endif +*/ + +/* This is only for PowerPC big-endian and 680x0 systems */ +/* some testing */ +/* +#ifdef PNG_READ_SUPPORTED +# ifndef PNG_PNG_READ_BIG_ENDIAN_SUPPORTED +# define PNG_READ_BIG_ENDIAN_SUPPORTED +# endif +#endif +*/ + +/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ +/* +#define PNG_NO_POINTER_INDEXING +*/ + +/* These functions are turned off by default, as they will be phased out. */ +/* +#define PNG_USELESS_TESTS_SUPPORTED +#define PNG_CORRECT_PALETTE_SUPPORTED +*/ + +/* Any chunks you are not interested in, you can undef here. The + * ones that allocate memory may be expecially important (hIST, + * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info + * a bit smaller. + */ + +#if defined(PNG_READ_SUPPORTED) && \ + !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ + !defined(PNG_NO_READ_ANCILLARY_CHUNKS) +# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +#endif + +#if defined(PNG_WRITE_SUPPORTED) && \ + !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ + !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) +# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +#endif + +#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED + +#ifdef PNG_NO_READ_TEXT +# define PNG_NO_READ_iTXt +# define PNG_NO_READ_tEXt +# define PNG_NO_READ_zTXt +#endif +#ifndef PNG_NO_READ_bKGD +# define PNG_READ_bKGD_SUPPORTED +# define PNG_bKGD_SUPPORTED +#endif +#ifndef PNG_NO_READ_cHRM +# define PNG_READ_cHRM_SUPPORTED +# define PNG_cHRM_SUPPORTED +#endif +#ifndef PNG_NO_READ_gAMA +# define PNG_READ_gAMA_SUPPORTED +# define PNG_gAMA_SUPPORTED +#endif +#ifndef PNG_NO_READ_hIST +# define PNG_READ_hIST_SUPPORTED +# define PNG_hIST_SUPPORTED +#endif +#ifndef PNG_NO_READ_iCCP +# define PNG_READ_iCCP_SUPPORTED +# define PNG_iCCP_SUPPORTED +#endif +#ifndef PNG_NO_READ_iTXt +# ifndef PNG_READ_iTXt_SUPPORTED +# define PNG_READ_iTXt_SUPPORTED +# endif +# ifndef PNG_iTXt_SUPPORTED +# define PNG_iTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_READ_oFFs +# define PNG_READ_oFFs_SUPPORTED +# define PNG_oFFs_SUPPORTED +#endif +#ifndef PNG_NO_READ_pCAL +# define PNG_READ_pCAL_SUPPORTED +# define PNG_pCAL_SUPPORTED +#endif +#ifndef PNG_NO_READ_sCAL +# define PNG_READ_sCAL_SUPPORTED +# define PNG_sCAL_SUPPORTED +#endif +#ifndef PNG_NO_READ_pHYs +# define PNG_READ_pHYs_SUPPORTED +# define PNG_pHYs_SUPPORTED +#endif +#ifndef PNG_NO_READ_sBIT +# define PNG_READ_sBIT_SUPPORTED +# define PNG_sBIT_SUPPORTED +#endif +#ifndef PNG_NO_READ_sPLT +# define PNG_READ_sPLT_SUPPORTED +# define PNG_sPLT_SUPPORTED +#endif +#ifndef PNG_NO_READ_sRGB +# define PNG_READ_sRGB_SUPPORTED +# define PNG_sRGB_SUPPORTED +#endif +#ifndef PNG_NO_READ_tEXt +# define PNG_READ_tEXt_SUPPORTED +# define PNG_tEXt_SUPPORTED +#endif +#ifndef PNG_NO_READ_tIME +# define PNG_READ_tIME_SUPPORTED +# define PNG_tIME_SUPPORTED +#endif +#ifndef PNG_NO_READ_tRNS +# define PNG_READ_tRNS_SUPPORTED +# define PNG_tRNS_SUPPORTED +#endif +#ifndef PNG_NO_READ_zTXt +# define PNG_READ_zTXt_SUPPORTED +# define PNG_zTXt_SUPPORTED +#endif +#ifndef PNG_NO_READ_UNKNOWN_CHUNKS +# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_UNKNOWN_CHUNKS_SUPPORTED +# endif +# ifndef PNG_NO_HANDLE_AS_UNKNOWN +# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# endif +#endif +#if !defined(PNG_NO_READ_USER_CHUNKS) && \ + defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +# define PNG_READ_USER_CHUNKS_SUPPORTED +# define PNG_USER_CHUNKS_SUPPORTED +# ifdef PNG_NO_READ_UNKNOWN_CHUNKS +# undef PNG_NO_READ_UNKNOWN_CHUNKS +# endif +# ifdef PNG_NO_HANDLE_AS_UNKNOWN +# undef PNG_NO_HANDLE_AS_UNKNOWN +# endif +#endif +#ifndef PNG_NO_READ_OPT_PLTE +# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ +#endif /* optional PLTE chunk in RGB and RGBA images */ +#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ + defined(PNG_READ_zTXt_SUPPORTED) +# define PNG_READ_TEXT_SUPPORTED +# define PNG_TEXT_SUPPORTED +#endif + +#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ + +#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED + +#ifdef PNG_NO_WRITE_TEXT +# define PNG_NO_WRITE_iTXt +# define PNG_NO_WRITE_tEXt +# define PNG_NO_WRITE_zTXt +#endif +#ifndef PNG_NO_WRITE_bKGD +# define PNG_WRITE_bKGD_SUPPORTED +# ifndef PNG_bKGD_SUPPORTED +# define PNG_bKGD_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_cHRM +# define PNG_WRITE_cHRM_SUPPORTED +# ifndef PNG_cHRM_SUPPORTED +# define PNG_cHRM_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_gAMA +# define PNG_WRITE_gAMA_SUPPORTED +# ifndef PNG_gAMA_SUPPORTED +# define PNG_gAMA_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_hIST +# define PNG_WRITE_hIST_SUPPORTED +# ifndef PNG_hIST_SUPPORTED +# define PNG_hIST_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_iCCP +# define PNG_WRITE_iCCP_SUPPORTED +# ifndef PNG_iCCP_SUPPORTED +# define PNG_iCCP_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_iTXt +# ifndef PNG_WRITE_iTXt_SUPPORTED +# define PNG_WRITE_iTXt_SUPPORTED +# endif +# ifndef PNG_iTXt_SUPPORTED +# define PNG_iTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_oFFs +# define PNG_WRITE_oFFs_SUPPORTED +# ifndef PNG_oFFs_SUPPORTED +# define PNG_oFFs_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_pCAL +# define PNG_WRITE_pCAL_SUPPORTED +# ifndef PNG_pCAL_SUPPORTED +# define PNG_pCAL_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sCAL +# define PNG_WRITE_sCAL_SUPPORTED +# ifndef PNG_sCAL_SUPPORTED +# define PNG_sCAL_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_pHYs +# define PNG_WRITE_pHYs_SUPPORTED +# ifndef PNG_pHYs_SUPPORTED +# define PNG_pHYs_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sBIT +# define PNG_WRITE_sBIT_SUPPORTED +# ifndef PNG_sBIT_SUPPORTED +# define PNG_sBIT_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sPLT +# define PNG_WRITE_sPLT_SUPPORTED +# ifndef PNG_sPLT_SUPPORTED +# define PNG_sPLT_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sRGB +# define PNG_WRITE_sRGB_SUPPORTED +# ifndef PNG_sRGB_SUPPORTED +# define PNG_sRGB_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tEXt +# define PNG_WRITE_tEXt_SUPPORTED +# ifndef PNG_tEXt_SUPPORTED +# define PNG_tEXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tIME +# define PNG_WRITE_tIME_SUPPORTED +# ifndef PNG_tIME_SUPPORTED +# define PNG_tIME_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tRNS +# define PNG_WRITE_tRNS_SUPPORTED +# ifndef PNG_tRNS_SUPPORTED +# define PNG_tRNS_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_zTXt +# define PNG_WRITE_zTXt_SUPPORTED +# ifndef PNG_zTXt_SUPPORTED +# define PNG_zTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS +# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_UNKNOWN_CHUNKS_SUPPORTED +# endif +# ifndef PNG_NO_HANDLE_AS_UNKNOWN +# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# endif +# endif +#endif +#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ + defined(PNG_WRITE_zTXt_SUPPORTED) +# define PNG_WRITE_TEXT_SUPPORTED +# ifndef PNG_TEXT_SUPPORTED +# define PNG_TEXT_SUPPORTED +# endif +#endif + +#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ + +/* Turn this off to disable png_read_png() and + * png_write_png() and leave the row_pointers member + * out of the info structure. + */ +#ifndef PNG_NO_INFO_IMAGE +# define PNG_INFO_IMAGE_SUPPORTED +#endif + +/* need the time information for reading tIME chunks */ +#if defined(PNG_tIME_SUPPORTED) +# if !defined(_WIN32_WCE) + /* "time.h" functions are not supported on WindowsCE */ +# include +# endif +#endif + +/* Some typedefs to get us started. These should be safe on most of the + * common platforms. The typedefs should be at least as large as the + * numbers suggest (a png_uint_32 must be at least 32 bits long), but they + * don't have to be exactly that size. Some compilers dislike passing + * unsigned shorts as function parameters, so you may be better off using + * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may + * want to have unsigned int for png_uint_32 instead of unsigned long. + */ + +typedef unsigned long png_uint_32; +typedef long png_int_32; +typedef unsigned short png_uint_16; +typedef short png_int_16; +typedef unsigned char png_byte; + +/* This is usually size_t. It is typedef'ed just in case you need it to + change (I'm not sure if you will or not, so I thought I'd be safe) */ +typedef size_t png_size_t; + +/* The following is needed for medium model support. It cannot be in the + * PNG_INTERNAL section. Needs modification for other compilers besides + * MSC. Model independent support declares all arrays and pointers to be + * large using the far keyword. The zlib version used must also support + * model independent data. As of version zlib 1.0.4, the necessary changes + * have been made in zlib. The USE_FAR_KEYWORD define triggers other + * changes that are needed. (Tim Wegner) + */ + +/* Separate compiler dependencies (problem here is that zlib.h always + defines FAR. (SJT) */ +#ifdef __BORLANDC__ +# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) +# define LDATA 1 +# else +# define LDATA 0 +# endif + /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ +# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) +# define PNG_MAX_MALLOC_64K +# if (LDATA != 1) +# ifndef FAR +# define FAR __far +# endif +# define USE_FAR_KEYWORD +# endif /* LDATA != 1 */ + /* Possibly useful for moving data out of default segment. + * Uncomment it if you want. Could also define FARDATA as + * const if your compiler supports it. (SJT) +# define FARDATA FAR + */ +# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ +#endif /* __BORLANDC__ */ + + +/* Suggest testing for specific compiler first before testing for + * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, + * making reliance oncertain keywords suspect. (SJT) + */ + +/* MSC Medium model */ +#if defined(FAR) +# if defined(M_I86MM) +# define USE_FAR_KEYWORD +# define FARDATA FAR +# include +# endif +#endif + +/* SJT: default case */ +#ifndef FAR +# define FAR +#endif + +/* At this point FAR is always defined */ +#ifndef FARDATA +# define FARDATA +#endif + +/* Typedef for floating-point numbers that are converted + to fixed-point with a multiple of 100,000, e.g., int_gamma */ +typedef png_int_32 png_fixed_point; + +/* Add typedefs for pointers */ +typedef void FAR * png_voidp; +typedef png_byte FAR * png_bytep; +typedef png_uint_32 FAR * png_uint_32p; +typedef png_int_32 FAR * png_int_32p; +typedef png_uint_16 FAR * png_uint_16p; +typedef png_int_16 FAR * png_int_16p; +typedef PNG_CONST char FAR * png_const_charp; +typedef char FAR * png_charp; +typedef png_fixed_point FAR * png_fixed_point_p; + +#ifndef PNG_NO_STDIO +#if defined(_WIN32_WCE) +typedef HANDLE png_FILE_p; +#else +typedef FILE * png_FILE_p; +#endif +#endif + +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double FAR * png_doublep; +#endif + +/* Pointers to pointers; i.e. arrays */ +typedef png_byte FAR * FAR * png_bytepp; +typedef png_uint_32 FAR * FAR * png_uint_32pp; +typedef png_int_32 FAR * FAR * png_int_32pp; +typedef png_uint_16 FAR * FAR * png_uint_16pp; +typedef png_int_16 FAR * FAR * png_int_16pp; +typedef PNG_CONST char FAR * FAR * png_const_charpp; +typedef char FAR * FAR * png_charpp; +typedef png_fixed_point FAR * FAR * png_fixed_point_pp; +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double FAR * FAR * png_doublepp; +#endif + +/* Pointers to pointers to pointers; i.e., pointer to array */ +typedef char FAR * FAR * FAR * png_charppp; + +/* libpng typedefs for types in zlib. If zlib changes + * or another compression library is used, then change these. + * Eliminates need to change all the source files. + */ +typedef charf * png_zcharp; +typedef charf * FAR * png_zcharpp; +typedef z_stream FAR * png_zstreamp; + +/* + * Define PNG_BUILD_DLL if the module being built is a Windows + * LIBPNG DLL. + * + * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. + * It is equivalent to Microsoft predefined macro _DLL that is + * automatically defined when you compile using the share + * version of the CRT (C Run-Time library) + * + * The cygwin mods make this behavior a little different: + * Define PNG_BUILD_DLL if you are building a dll for use with cygwin + * Define PNG_STATIC if you are building a static library for use with cygwin, + * -or- if you are building an application that you want to link to the + * static library. + * PNG_USE_DLL is defined by default (no user action needed) unless one of + * the other flags is defined. + */ + +#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) +# define PNG_DLL +#endif +/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. + * When building a static lib, default to no GLOBAL ARRAYS, but allow + * command-line override + */ +#if defined(__CYGWIN__) +# if !defined(PNG_STATIC) +# if defined(PNG_USE_GLOBAL_ARRAYS) +# undef PNG_USE_GLOBAL_ARRAYS +# endif +# if !defined(PNG_USE_LOCAL_ARRAYS) +# define PNG_USE_LOCAL_ARRAYS +# endif +# else +# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) +# if defined(PNG_USE_GLOBAL_ARRAYS) +# undef PNG_USE_GLOBAL_ARRAYS +# endif +# endif +# endif +# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +# define PNG_USE_LOCAL_ARRAYS +# endif +#endif + +/* Do not use global arrays (helps with building DLL's) + * They are no longer used in libpng itself, since version 1.0.5c, + * but might be required for some pre-1.0.5c applications. + */ +#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +# if defined(PNG_NO_GLOBAL_ARRAYS) || (defined(__GNUC__) && defined(PNG_DLL)) +# define PNG_USE_LOCAL_ARRAYS +# else +# define PNG_USE_GLOBAL_ARRAYS +# endif +#endif + +#if defined(__CYGWIN__) +# undef PNGAPI +# define PNGAPI __cdecl +# undef PNG_IMPEXP +# define PNG_IMPEXP +#endif + +/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", + * you may get warnings regarding the linkage of png_zalloc and png_zfree. + * Don't ignore those warnings; you must also reset the default calling + * convention in your compiler to match your PNGAPI, and you must build + * zlib and your applications the same way you build libpng. + */ + +#ifndef PNGAPI + +#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) +# ifndef PNG_NO_MODULEDEF +# define PNG_NO_MODULEDEF +# endif +#endif + +#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) +# define PNG_IMPEXP +#endif + +#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ + (( defined(_Windows) || defined(_WINDOWS) || \ + defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) + +# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) +# define PNGAPI __cdecl +# else +# define PNGAPI _cdecl +# endif + +# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ + 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) +# define PNG_IMPEXP +# endif + +# if !defined(PNG_IMPEXP) + +# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol +# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol + + /* Borland/Microsoft */ +# if defined(_MSC_VER) || defined(__BORLANDC__) +# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) +# define PNG_EXPORT PNG_EXPORT_TYPE1 +# else +# define PNG_EXPORT PNG_EXPORT_TYPE2 +# if defined(PNG_BUILD_DLL) +# define PNG_IMPEXP __export +# else +# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in + VC++ */ +# endif /* Exists in Borland C++ for + C++ classes (== huge) */ +# endif +# endif + +# if !defined(PNG_IMPEXP) +# if defined(PNG_BUILD_DLL) +# define PNG_IMPEXP __declspec(dllexport) +# else +# define PNG_IMPEXP __declspec(dllimport) +# endif +# endif +# endif /* PNG_IMPEXP */ +#else /* !(DLL || non-cygwin WINDOWS) */ +# if (defined(__IBMC__) || defined(IBMCPP__)) && defined(__OS2__) +# define PNGAPI _System +# define PNG_IMPEXP +# else +# if 0 /* ... other platforms, with other meanings */ +# else +# define PNGAPI +# define PNG_IMPEXP +# endif +# endif +#endif +#endif + +#ifndef PNGAPI +# define PNGAPI +#endif +#ifndef PNG_IMPEXP +# define PNG_IMPEXP +#endif + +#ifndef PNG_EXPORT +# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol +#endif + +#ifdef PNG_USE_GLOBAL_ARRAYS +# ifndef PNG_EXPORT_VAR +# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type +# endif +#endif + +/* User may want to use these so they are not in PNG_INTERNAL. Any library + * functions that are passed far data must be model independent. + */ + +#ifndef PNG_ABORT +# define PNG_ABORT() abort() +#endif + +#ifdef PNG_SETJMP_SUPPORTED +# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) +#else +# define png_jmpbuf(png_ptr) \ + (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) +#endif + +#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ +/* use this to make far-to-near assignments */ +# define CHECK 1 +# define NOCHECK 0 +# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) +# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) +# define png_strcpy _fstrcpy +# define png_strlen _fstrlen +# define png_memcmp _fmemcmp /* SJT: added */ +# define png_memcpy _fmemcpy +# define png_memset _fmemset +#else /* use the usual functions */ +# define CVT_PTR(ptr) (ptr) +# define CVT_PTR_NOCHECK(ptr) (ptr) +# define png_strcpy strcpy +# define png_strlen strlen +# define png_memcmp memcmp /* SJT: added */ +# define png_memcpy memcpy +# define png_memset memset +#endif +/* End of memory model independent support */ + +/* Just a little check that someone hasn't tried to define something + * contradictory. + */ +#if (PNG_ZBUF_SIZE > 65536) && defined(PNG_MAX_MALLOC_64K) +# undef PNG_ZBUF_SIZE +# define PNG_ZBUF_SIZE 65536 +#endif + +#ifdef PNG_READ_SUPPORTED +/* Prior to libpng-1.0.9, this block was in pngasmrd.h */ +#if defined(PNG_INTERNAL) + +/* These are the default thresholds before the MMX code kicks in; if either + * rowbytes or bitdepth is below the threshold, plain C code is used. These + * can be overridden at runtime via the png_set_mmx_thresholds() call in + * libpng 1.2.0 and later. The values below were chosen by Intel. + */ + +#ifndef PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT +# define PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT 128 /* >= */ +#endif +#ifndef PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT +# define PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT 9 /* >= */ +#endif + +/* Set this in the makefile for VC++ on Pentium, not here. */ +/* Platform must be Pentium. Makefile must assemble and load pngvcrd.c . + * MMX will be detected at run time and used if present. + */ +#ifdef PNG_USE_PNGVCRD +# define PNG_HAVE_ASSEMBLER_COMBINE_ROW +# define PNG_HAVE_ASSEMBLER_READ_INTERLACE +# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW +#endif + +/* Set this in the makefile for gcc/as on Pentium, not here. */ +/* Platform must be Pentium. Makefile must assemble and load pnggccrd.c . + * MMX will be detected at run time and used if present. + */ +#ifdef PNG_USE_PNGGCCRD +# define PNG_HAVE_ASSEMBLER_COMBINE_ROW +# define PNG_HAVE_ASSEMBLER_READ_INTERLACE +# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW +#endif +/* - see pnggccrd.c for info about what is currently enabled */ + +#endif /* PNG_INTERNAL */ +#endif /* PNG_READ_SUPPORTED */ + +#endif /* PNGCONF_H */ + diff --git a/stepmania/src/libpng/include/zconf.h b/stepmania/src/libpng/include/zconf.h new file mode 100644 index 0000000000..eb0ae2e1a0 --- /dev/null +++ b/stepmania/src/libpng/include/zconf.h @@ -0,0 +1,279 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2002 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef _ZCONF_H +#define _ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + */ +#ifdef Z_PREFIX +# define deflateInit_ z_deflateInit_ +# define deflate z_deflate +# define deflateEnd z_deflateEnd +# define inflateInit_ z_inflateInit_ +# define inflate z_inflate +# define inflateEnd z_inflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateSetDictionary z_deflateSetDictionary +# define deflateCopy z_deflateCopy +# define deflateReset z_deflateReset +# define deflateParams z_deflateParams +# define inflateInit2_ z_inflateInit2_ +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateReset z_inflateReset +# define compress z_compress +# define compress2 z_compress2 +# define uncompress z_uncompress +# define adler32 z_adler32 +# define crc32 z_crc32 +# define get_crc_table z_get_crc_table + +# define Byte z_Byte +# define uInt z_uInt +# define uLong z_uLong +# define Bytef z_Bytef +# define charf z_charf +# define intf z_intf +# define uIntf z_uIntf +# define uLongf z_uLongf +# define voidpf z_voidpf +# define voidp z_voidp +#endif + +#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32) +# define WIN32 +#endif +#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386) +# ifndef __32BIT__ +# define __32BIT__ +# endif +#endif +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#if defined(MSDOS) && !defined(__32BIT__) +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC) +# define STDC +#endif +#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__) +# ifndef STDC +# define STDC +# endif +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const +# endif +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Old Borland C incorrectly complains about missing returns: */ +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500) +# define NEED_DUMMY_RETURN +#endif + + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +#endif +#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__)) +# ifndef __32BIT__ +# define SMALL_MEDIUM +# define FAR _far +# endif +#endif + +/* Compile with -DZLIB_DLL for Windows DLL support */ +#if defined(ZLIB_DLL) +# if defined(_WINDOWS) || defined(WINDOWS) +# ifdef FAR +# undef FAR +# endif +# include +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR _cdecl _export +# endif +# endif +# if defined (__BORLANDC__) +# if (__BORLANDC__ >= 0x0500) && defined (WIN32) +# include +# define ZEXPORT __declspec(dllexport) WINAPI +# define ZEXPORTRVA __declspec(dllexport) WINAPIV +# else +# if defined (_Windows) && defined (__DLL__) +# define ZEXPORT _export +# define ZEXPORTVA _export +# endif +# endif +# endif +#endif + +#if defined (__BEOS__) +# if defined (ZLIB_DLL) +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +#endif + +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif +#ifndef ZEXTERN +# define ZEXTERN extern +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(MACOS) && !defined(TARGET_OS_MAC) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#ifdef HAVE_UNISTD_H +# include /* for off_t */ +# include /* for SEEK_* and off_t */ +# define z_off_t off_t +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif +#ifndef z_off_t +# define z_off_t long +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(inflate_blocks,"INBL") +# pragma map(inflate_blocks_new,"INBLNE") +# pragma map(inflate_blocks_free,"INBLFR") +# pragma map(inflate_blocks_reset,"INBLRE") +# pragma map(inflate_codes_free,"INCOFR") +# pragma map(inflate_codes,"INCO") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_flush,"INFLU") +# pragma map(inflate_mask,"INMA") +# pragma map(inflate_set_dictionary,"INSEDI2") +# pragma map(inflate_copyright,"INCOPY") +# pragma map(inflate_trees_bits,"INTRBI") +# pragma map(inflate_trees_dynamic,"INTRDY") +# pragma map(inflate_trees_fixed,"INTRFI") +# pragma map(inflate_trees_free,"INTRFR") +#endif + +#endif /* _ZCONF_H */ diff --git a/stepmania/src/libpng/include/zlib.h b/stepmania/src/libpng/include/zlib.h new file mode 100644 index 0000000000..52cb529f6f --- /dev/null +++ b/stepmania/src/libpng/include/zlib.h @@ -0,0 +1,893 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.1.4, March 11th, 2002 + + Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef _ZLIB_H +#define _ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.1.4" + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never + crash even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: ascii or binary */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_in holds the total size of + the uncompressed data and may be saved for use in the decompressor + (particularly if the decompressor wants to decompress everything in + a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +/* Allowed flush values; see deflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_ASCII 1 +#define Z_UNKNOWN 2 +/* Possible values of the data_type field */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is + not compatible with the zlib.h header file used by the application. + This check is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. + If zalloc and zfree are set to Z_NULL, deflateInit updates them to + use default allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at + all (the input data is simply copied a block at a time). + Z_DEFAULT_COMPRESSION requests a default compromise between speed and + compression (currently equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if level is not a valid compression level, + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). + msg is set to null if there is no error message. deflateInit does not + perform any compression: this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce some + output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). + Some output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating avail_in or avail_out accordingly; avail_out + should never be zero before the call. The application can consume the + compressed output when it wants, for example when the output buffer is full + (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK + and with zero avail_out, it must be called again after making room in the + output buffer because there might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In particular + avail_in is zero after the call if enough output space has been provided + before the call.) Flushing may degrade compression for some compression + algorithms and so it should be used only when necessary. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + the compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there + was enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the + stream are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least + 0.1% larger than avail_in plus 12 bytes. If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update data_type if it can make a good guess about + the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered + binary. This field is only for information purposes and does not affect + the compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, + msg may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the exact + value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller. msg is set to null if there is no error + message. inflateInit does not perform any decompression apart from reading + the zlib header if present: this will be done by inflate(). (So next_in and + avail_in may be modified, but next_out and avail_out are unchanged.) +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may some + introduce some output latency (reading input without producing any output) + except when forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there + is no more input data or no more space in the output buffer (see below + about the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating the next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). If inflate returns Z_OK and with zero avail_out, it + must be called again after making room in the output buffer because there + might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much + output as possible to the output buffer. The flushing behavior of inflate is + not specified for values of the flush parameter other than Z_SYNC_FLUSH + and Z_FINISH, but the current implementation actually flushes as much output + as possible anyway. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step + (a single call of inflate), the parameter flush should be set to + Z_FINISH. In this case all pending input is processed and all pending + output is flushed; avail_out must be large enough to hold all the + uncompressed data. (The size of the uncompressed data may have been saved + by the compressor for this purpose.) The next operation on this stream must + be inflateEnd to deallocate the decompression state. The use of Z_FINISH + is never required, but can be used to inform inflate that a faster routine + may be used for the single inflate() call. + + If a preset dictionary is needed at this point (see inflateSetDictionary + below), inflate sets strm-adler to the adler32 checksum of the + dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise + it sets strm->adler to the adler32 checksum of all output produced + so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or + an error code as described below. At the end of the stream, inflate() + checks that its computed adler32 checksum is equal to that saved by the + compressor and returns Z_STREAM_END only if the checksum is correct. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect + adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent + (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if no progress is possible or if there was not + enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR + case, the application may then call inflateSync to look for a good + compression block. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by + the caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but + is slow and reduces compression ratio; memLevel=9 uses maximum memory + for optimal speed. The default value is 8. See zconf.h for total memory + usage as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match). Filtered data consists mostly of small values with a + somewhat random distribution. In this case, the compression algorithm is + tuned to compress them better. The effect of Z_FILTERED is to force more + Huffman coding and less string matching; it is somewhat intermediate + between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects + the compression ratio but not the correctness of the compressed output even + if it is not set appropriately. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid + method). msg is set to null if there is no error message. deflateInit2 does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. This function must be called + immediately after deflateInit, deflateInit2 or deflateReset, before any + call of deflate. The compressor and decompressor must use exactly the same + dictionary (see inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size in + deflate or deflate2. Thus the strings most likely to be useful should be + put at the end of the dictionary, not at the front. + + Upon return of this function, strm->adler is set to the Adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The Adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if the compression method is bsort). deflateSetDictionary does not + perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and + can consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. + The stream will keep the same compression level and any other attributes + that may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different + strategy. If the compression level is changed, the input available so far + is compressed with the old level (and may be flushed); the new level will + take effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to + be compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR + if strm->avail_out was zero. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. If a compressed stream with a larger window size is given as + input, inflate() will return with the error code Z_DATA_ERROR instead of + trying to allocate a larger window. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative + memLevel). msg is set to null if there is no error message. inflateInit2 + does not perform any decompression apart from reading the zlib header if + present: this will be done by inflate(). (So next_in and avail_in may be + modified, but next_out and avail_out are unchanged.) +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate + if this call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the Adler32 value returned by this call of + inflate. The compressor and decompressor must use exactly the same + dictionary (see deflateSetDictionary). + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect Adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a full flush point (see above the + description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR + if no more input was provided, Z_DATA_ERROR if no flush point has been found, + or Z_STREAM_ERROR if the stream structure was inconsistent. In the success + case, the application may save the current current value of total_in which + indicates where valid compressed data was found. In the error case, the + application may repeatedly call inflateSync, providing more input each time, + until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. + The stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + + + /* utility functions */ + +/* + The following utility functions are implemented on top of the + basic stream-oriented functions. To simplify the interface, some + default options are assumed (compression level and memory usage, + standard memory allocation functions). The source code of these + utility functions can easily be modified if you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be at least 0.1% larger than + sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the + compressed buffer. + This function can be used to compress a whole file at once if the + input file is mmap'ed. + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least 0.1% larger than sourceLen plus + 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + This function can be used to decompress a whole file at once if the + input file is mmap'ed. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted. +*/ + + +typedef voidp gzFile; + +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +/* + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb") but can also include a compression level + ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for + Huffman only compression as in "wb1h". (See the description + of deflateInit2 for more information about the strategy parameter.) + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. + + gzopen returns NULL if the file could not be opened or if there was + insufficient memory to allocate the (de)compression state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). */ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen() associates a gzFile with the file descriptor fd. File + descriptors are obtained from calls like open, dup, creat, pipe or + fileno (in the file has been previously opened with fopen). + The mode parameter is as in gzopen. + The next call of gzclose on the returned gzFile will also close the + file descriptor fd, just like fclose(fdopen(fd), mode) closes the file + descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). + gzdopen returns NULL if there was insufficient memory to allocate + the (de)compression state. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. + If the input file was not in gzip format, gzread copies the given number + of bytes into the buffer. + gzread returns the number of uncompressed bytes actually read (0 for + end of file, -1 for error). */ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + const voidp buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes actually written + (0 in case of error). +*/ + +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the args to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written (0 in case of error). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or + a newline character is read and transferred to buf, or an end-of-file + condition is encountered. The string is then terminated with a null + character. + gzgets returns buf, or Z_NULL in case of error. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. + gzputc returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte + or -1 in case of end of file or error. +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter + flush is as in the deflate() function. The return value is the zlib + error number (see function gzerror below). gzflush returns Z_OK if + the flush parameter is Z_FINISH and all output could be flushed. + gzflush should be called only when strictly necessary because it can + degrade compression. +*/ + +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); +/* + Sets the starting position for the next gzread or gzwrite on the + given compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +/* + Returns the starting position for the next gzread or gzwrite on the + given compressed file. This position represents a number of bytes in the + uncompressed data stream. + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns 1 when EOF has previously been detected reading the given + input stream, otherwise zero. +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file + and deallocates all the (de)compression state. The return value is the zlib + error number (see function gzerror below). +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the + given compressed file. errnum is set to zlib error number. If an + error occurred in the file system and not in the compression library, + errnum is set to Z_ERRNO and the application may consult errno + to get the exact error code. +*/ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the + compression library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); + +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is NULL, this function returns + the required initial value for the checksum. + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running crc with the bytes buf[0..len-1] and return the updated + crc. If buf is NULL, this function returns the required initial value + for the crc. Pre- and post-conditioning (one's complement) is performed + within this function so it shouldn't be done by the application. + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) + + +#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +ZEXTERN const char * ZEXPORT zError OF((int err)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* _ZLIB_H */ diff --git a/stepmania/src/libpng/lib/libpng.lib b/stepmania/src/libpng/lib/libpng.lib new file mode 100644 index 0000000000000000000000000000000000000000..e603d0260f9d6a8e7272ebe872097cff442e6723 GIT binary patch literal 293904 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

9fv(Vj#YR@T0u|}OVzJpG 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

X@@Qq|6<5@op2mjemc=ct ziyIf2!1WEni@Tf_bLaIlFJDVhMWfNxog*8gFrXS;9>+<+vG`iCKYRH|=YUc=l$Psb z1*7fUV}udAv&RV4ySabl7(qZE*;e$igR#BBV+W(n!efV`{nulMVq1a74wg#x4;~}b z@x&y$)iGk)ETtyI4MjQx_}2}`9guhpk?PT7q(O3A0rh4-YJ7~xIiC11bskT!#POCm zal9o?9A80*Z9AR}jvjA7u)W6faPiJm@B9@S z=x#Xf*F54^RcdXQGrrAuab}sK+<=e#)YsNte}%*8vR)fl2|9V@dHAviSDsgI0)_*Q z5bl9oab7*LtBm2sBYFnySFUx8bft!HL}08Q9B=)KcruA4!`Rxc?il9WME6=peC&qg z$mrTZjI+jt&H67^2m>hW*xI47^fcEdTT!aJ~v1=dyb9tBzrdU9LwjDX%s%_(fj$3TS@EQ0 z*O?WsTXwA}t9Y0FmW$sC@mnc=r-|Px@jG4oR*T;m;&-O_oh5#2#P3PsceePo&~L@N z={>a`%lL*|E;qhEIm@!Etm0K`#k;=Le`OzO+W)=Zp@iAj-+UvxH~U)C{x@Hz;$`2m ze4-xVugmV;^Fr;cN1`3;CN2jPr**b>fzw+#g$AXGR-aY7P*L=#G=W~;-~HD7c?#8c zg{f~-7py3w-fe#5eog(XqKtaB`H}l{1zuH@QLm=woaqbCS8$t`Vklw3U7^&Y*HprF zMN^AuSnB*liP4JQD#kaB)+#nye~E0(L0t3{8?BWhFFXXki;UKL0B*<&S8TL?9N}I< zxB;pPJk#)@(Rz7;aqA35Usd>gQH0TeYHfom*A&6$;`7%C_X81@vcTfw)Wk($=&8kL zFTy+{g;Q&5Z6<*eIo2tn;f1Gtz542>QPi3q6sG@SIIT`1(JDrb4UM6q);o9-tsii9b7^vi+?6c{& z%hs$(o}mXCKd>e>ZQ$+Ihfd8-9I|AcKg(3<@77$`v2Wrs#B>TiRmxI)Tkxqx2)N&`YJ8ZP{yF!G?I z_$ojU_;Zi#fl&n^_;a!Nr7*yfCSb}}MH$6P18?OgyY4V@=mvzIX$nhA8jzGqMHvlA z!lH++B2<)X@X=LF4UJN!A1PKGq#qeoghF?T+tl zFJ>XqI+T_9@kQ}XmO9=jsN=vNpE_!b)Txt3D(Gh$rf;}3Hv2cHhM+<;ZhYYNUsxa9cGFWoJ?qd*KOeg0-lq=l9e*;t>T`pq?*7&d-J5^k`G;5b z#dn0)meoBsSk={amF2DfI;nc+qxHjW9ku;|m#o+SBynT!UqA6u#ZvcEmHt1BpS1sm zduM**t#94iJovfq*q+|^y#wm+zyA;aKKSgy)Y|8rkDc`N&(>V^#NYoz!*ds2sr=%a zTdsNL(bHp(|M1?!_ndqF!*{Rx{Aa%VnB^Nkxc|%dmtR!9eOmN8&(%CK|KO}|e`3qX z6(ahH%^QEowfYKwY9Sz{CIuMz6HGh4*WEw-Ld}c2D!#D)+sRh#^A{eJMBNQy;!lnfdK6Pru3WDa)(-zgGQ;zSqh=^zK7d{p;F0-~5-} z_$@as9z63`RW}T;pZnCiFD!U6^O4Ozt^Kj@=e;A(Kk)nC|MtP#?GN5}#!qg)>-v|! z_Vm+RKlQ{{AAacBmgTQKAO2nM_nzo&|Nb|BUUly>|Kjg>e!AeKX9II*{?i-2ipAG& zuCz}4_WI|qeZKcwzrB69anpnSuG{X8{mWVDp6`EU|HuW4U+i1{nGH2Ru5i!#-UFwX zpLfND)2@B6?YsYc(X1bQ=g&WK&w|QSa?)&Y}ww(L?fmu)OfAZtD7oYmwk-LB1H=O?IIsbb4gSTFH;RA2{a>HFC z8{GHJ`HzoOZyz17b3L=3S6^*=cFBr6zyG)Y{N?Zc z;^xP`<351?faZO!=pRAtldbrV>4RD*Y_e)H)Eun15rANwJ`!C|e~^KwOd(}5jlW#8TN+v@aC zZFSQx&VMeu=t~q;(}AWpZ9C3lkfj2$=Qq_&?-KBNDHu?v9+Jh_bif=Zi;)86* z_2{mT>Mrmp;_Wwd*LQW-W4eo$sXUhVkX2(dgW%H;|9i!%(Hw4mWcG=(Y8qE|RpaJc zjIai)Mk_aY?lqV$>V~J3A3kibL>fC+spPXyH0hh!r%J{?$uUz$t|+5h>Hpwj1G1r$34NJJdn%0-~Y<;;EN%T^Jc#3gQ zbyOhvDYCw#HM5!*j;$}v%SP4!uOr->A}rObsx<7D+lrE+`q8)|^3%iCmw6o7U4TzV z;QI&x&rE#OA{^OEfX@Z@loK2jvCfPmlbB_Il=JX8wVGVUQ;KtIMmVPk%gRxNa|4Sl zm19VrB8FwD_&j(qPaC?F5j@4pu@d3Bk;(f{=3$6_6bp9|!aa>J@6z%a4|T6n_3Xf! zcqOfi@s!HnU8t}QgqeLh4@cCYRD691vr&XA72ijZ@sAdM^yV9gn3+q)9Wv9T>c6XoIVfbIGaVs=tHsg zI2W&5LC-!yWD^giTdKU>2$Ph;sZ)?Qy?;_^X-n_K)>Kq2Gy`IeeEqwG;B9(glad#!) zH1HL?t<~Y=z6F0AUQaG+HN3w?DKA45%w1jvH$zt8ci>Z{1n})+uGPA$TX&7Zbq#yF zMR#r2U7yxnU(sFvpu0$V@2no*y&}7=7Bc*|E!!T!yX@$^@i#2nz6WRerW(bvje2i- zYvm=D@xOso^h#9zF^tqD{I@ zSavyT%d;IVPyQ+!TH3T10kc~#MVOv!rS<%`dNP$C&AJeDX-}rkYHPc;di_5)?LJg7 z@b2np$93x_u0p0rtX!uIH3!RqZbSLf8atfvmZ?RAZCM>{4E zj7^gCi)nzyKa*NbS5{?T&AR4gL$wq^+wa$xXMaDQOE$IVMr(8HYj~}==9O)&Dce|E zwzcl!t+fb#G16K;kE&{Gosz1`x~em-S|oE0qUBkl1ZWoJPX$Y`9v;T_uV5Q2P5ay4 zvTU1+SJ@5o+FrA4t0m_;RDY%Aj!L-Oermbx9dxSJ_8QB!L*zIkHKVn?(lY)Fc(Sg_ ztG<9xsTqVY{x2+Gt!3LDq>?^zNj6lUxjGZ9&UDnL64}s2S=W~I!RkG~thsd$^>WV> zN76?s)>jNvtlslN)vQNbS9K>V();S0_79wMU3Sl#ukUqL-iVm84`rWN@OZ_O*+*Da zq_=h}$ulhXwJ+o~)826Fi?nIMed}uWx|u+#X@Bdgy5#BEy&UQ0S|xQ>I#i!K_zOgd z5~OCgt*gG7GM=nFbZXOnl;r^`OWU4Q9bPBvz6zqLWZZKG-aZHxlcAi}x@s_0i#pjx zgP?7XW!r7|MX^@wtW;O!>c*?#O&=+T40#%gmYR+dP@LntE!)1vUs<+&fjP=j%iEq! z%~-{9x8~5IrrnW9g!>?wM)yyhn{_#;3#PlR?;;JyPKWYtWI)NSU&>4LaE(+p%Qo6A zLRY8aps$8nSItRI!-m-*2i26Qx~#dbMAd}m>zVPa3Tl*`5y`E;D7R|mO@a236xtukH?YjnWrF$HEU9p1AjPF zrBenr!ijyPr%b6vX8ESD7;xB?U^!lkGBO%z*>(*%L-WS>Wr7%AcK8Nnuj#uVY)AIU z>)#kC%Z*-?i_~LZ;^CU{1D0(c;+V9(v3lMEcY>wMzKvkzxv}|~3K2F{&HeTUmfL#r zIWqPZ;j7Hu{b@v>u`lI-?2)X!A^k9ln)zt8W!t^Ta{8k!pwNHMTub5lDqQ0^%eK$s zH|w8|)Svj}HK4v?)5Jdii5F12ExEB4)-kho2Lmk4jq#qE8w0Jb&W%;`*RI+HuIjA6 zx?)epUYku*ZnBT>tg*tM{vt4(o>NQo!qop0#I>v~8JRv%WHm z@9`W7Mxql7_GVm_=s4+(bClG{?YYI;+=F(>xEctMoL|d|S9W#TR+_-Fd!uY~h|d!w zUf_wr!8VBK7aN^OT2U6^GaZS~$8dk*g^X(vMtgfxt|zm_`mQ$c+qH2IY6D`k=Y?|1 zecP#rWkMU_qG&R=Z^Jh{H1Si;ZYQwizFTO8H-L#Txth*G(t=lSeWVKbnbfO?Drpa|?Exyr&X0j>!G7K= zI~-@^wmWk>D$m&Nd^b_KXXr?I);iegJe+a9yuO0sbXI3?Y^Zp3hx6T*%BwBoe*x?r z&RmP*>YQbK2YITlEVqo`0+$O;TUlyjcHJvBo6EMN+;wGDYN_~LBz`Xyzw^cKJn>s6 zerv>UW!sa9?`I!cFfomC+O~J+r`|=uw$5!smQvN38~d_HZn|{mqS_rUmj5bbKYQb) z=clT())vcsm7{IWS2ND)^)qt8BbMXJWu=1nwD$Cm<>6yuB8`m?YnquH#*A2TUYL^^msg$`)ad4UGRL{GjsR9 zx&Qnpy*-)Q)WNK)CHu_I%8m58I{O@6KQ?#Yn@^noFTS2kb?RW*O-Hg428GtIJ%2*{y@=Tt%Wj>*~&i8g|xIgWn_G&&2YDZl|uG2u9e8#!y>+_){V7EXEwAly9zBlf58)%QU2Q=Pi${{3{kimD)u0X z-R;W-hfp*E%XmAn0K3t9CbDbi*R?&Ld<{{WVqgq{<M?wpp(4s>=v>17%Q+`r2 z!Aqp>8Yo|V=pUPQ6My&V-C#k=4*k^yD7O`#Iwg*8Cv&CnUC&(K#5afS(qaFl!=|BJ z_3+i<1C9Vbddii$3i@^6GhJD6Ej2_fDB$;~8mP7>#?Ik6WA0h$E%WD~!<`5EN37Mk z_yxO_Sjw382+H>43#fO?uE5FVY!v{yie6#4Z>crwx-=VVIsc)a47nMLkKn}SgX6w{ z^{e>{_AdCBwmlopNI!TB@>8Ci-Jbn7mU{Z(N|4L+*3}i3kDWw0`|Rg1`|Jp<&fdwV zp&mrgv%uAN%fX7CjN@7*dnX0RewL=S?KPL=K2BcCu6>qW8N{qiqkgvYw%b1mg58rV z>$yrPv)s3PY=&hQC9E8px##8SEBl*JRamUhtA1YJk+gd(NkW2{;ErjMUP%7EvOHyi{$#qg;u8?JhX*6 zI2�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 fhoT7B3!dXIht(4#*eIbcwBaEc47h+X7TW&