From 2a2f56f510a5879809d544a642376d21715f36f7 Mon Sep 17 00:00:00 2001 From: helixhorned Date: Fri, 20 Jul 2012 21:57:53 +0000 Subject: [PATCH] Add custom-built lean zlib and libpng and enable PNG screenshots on Windows. Instructions on how I built the libs are in Windows/src/minipng.dfa. git-svn-id: https://svn.eduke32.com/eduke32@2843 1a8010ca-5511-0410-912e-c29ae57300e0 --- polymer/eduke32/Makefile.common | 5 +- polymer/eduke32/Windows/include/png.h | 2671 ++++++++++++++++++ polymer/eduke32/Windows/include/pngconf.h | 596 ++++ polymer/eduke32/Windows/include/pnglibconf.h | 180 ++ polymer/eduke32/Windows/lib/libpng_mini.a | Bin 0 -> 28750 bytes polymer/eduke32/Windows/lib/libz_mini.a | Bin 0 -> 41646 bytes polymer/eduke32/Windows/src/minipng.dfa | 55 + polymer/eduke32/build/Makefile.shared | 18 +- 8 files changed, 3514 insertions(+), 11 deletions(-) create mode 100755 polymer/eduke32/Windows/include/png.h create mode 100755 polymer/eduke32/Windows/include/pngconf.h create mode 100755 polymer/eduke32/Windows/include/pnglibconf.h create mode 100644 polymer/eduke32/Windows/lib/libpng_mini.a create mode 100644 polymer/eduke32/Windows/lib/libz_mini.a create mode 100755 polymer/eduke32/Windows/src/minipng.dfa diff --git a/polymer/eduke32/Makefile.common b/polymer/eduke32/Makefile.common index e5372345b..7df6236ae 100644 --- a/polymer/eduke32/Makefile.common +++ b/polymer/eduke32/Makefile.common @@ -32,7 +32,7 @@ LINKED_GTK = 0 BUILD32_ON_64 ?= 0 # DO NOT SET THIS TO 1 AND COMMIT IT. NEDMALLOC = 0 -USE_LIBPNG ?= 0 +USE_LIBPNG ?= 1 USE_LIBVPX ?= 1 ifeq (0,$(USE_OPENGL)) @@ -97,9 +97,6 @@ ifeq ($(PLATFORM),WII) endif LIBS=-lm -ifneq (0,$(USE_LIBPNG)) - LIBS+= -lpng -lz -endif ifneq (0,$(USE_LIBVPX)) # On Windows, we link statically to libvpx LIBS+= -lvpx diff --git a/polymer/eduke32/Windows/include/png.h b/polymer/eduke32/Windows/include/png.h new file mode 100755 index 000000000..4c37e58a4 --- /dev/null +++ b/polymer/eduke32/Windows/include/png.h @@ -0,0 +1,2671 @@ + +/* png.h - header file for PNG reference library + * + * libpng version 1.5.12 - July 11, 2012 + * Copyright (c) 1998-2012 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.) + * + * This code is released under the libpng license (See LICENSE, below) + * + * 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.5.12 - July 11, 2012: 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 + * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 + * 1.0.16 10 10016 10.so.0.1.0.16 + * 1.2.6 13 10206 12.so.0.1.2.6 + * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 + * 1.0.17rc1 10 10017 12.so.0.1.0.17rc1 + * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 + * 1.0.17 10 10017 12.so.0.1.0.17 + * 1.2.7 13 10207 12.so.0.1.2.7 + * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 + * 1.0.18rc1-5 10 10018 12.so.0.1.0.18rc1-5 + * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 + * 1.0.18 10 10018 12.so.0.1.0.18 + * 1.2.8 13 10208 12.so.0.1.2.8 + * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 + * 1.2.9beta4-11 13 10209 12.so.0.9[.0] + * 1.2.9rc1 13 10209 12.so.0.9[.0] + * 1.2.9 13 10209 12.so.0.9[.0] + * 1.2.10beta1-7 13 10210 12.so.0.10[.0] + * 1.2.10rc1-2 13 10210 12.so.0.10[.0] + * 1.2.10 13 10210 12.so.0.10[.0] + * 1.4.0beta1-5 14 10400 14.so.0.0[.0] + * 1.2.11beta1-4 13 10211 12.so.0.11[.0] + * 1.4.0beta7-8 14 10400 14.so.0.0[.0] + * 1.2.11 13 10211 12.so.0.11[.0] + * 1.2.12 13 10212 12.so.0.12[.0] + * 1.4.0beta9-14 14 10400 14.so.0.0[.0] + * 1.2.13 13 10213 12.so.0.13[.0] + * 1.4.0beta15-36 14 10400 14.so.0.0[.0] + * 1.4.0beta37-87 14 10400 14.so.14.0[.0] + * 1.4.0rc01 14 10400 14.so.14.0[.0] + * 1.4.0beta88-109 14 10400 14.so.14.0[.0] + * 1.4.0rc02-08 14 10400 14.so.14.0[.0] + * 1.4.0 14 10400 14.so.14.0[.0] + * 1.4.1beta01-03 14 10401 14.so.14.1[.0] + * 1.4.1rc01 14 10401 14.so.14.1[.0] + * 1.4.1beta04-12 14 10401 14.so.14.1[.0] + * 1.4.1 14 10401 14.so.14.1[.0] + * 1.4.2 14 10402 14.so.14.2[.0] + * 1.4.3 14 10403 14.so.14.3[.0] + * 1.4.4 14 10404 14.so.14.4[.0] + * 1.5.0beta01-58 15 10500 15.so.15.0[.0] + * 1.5.0rc01-07 15 10500 15.so.15.0[.0] + * 1.5.0 15 10500 15.so.15.0[.0] + * 1.5.1beta01-11 15 10501 15.so.15.1[.0] + * 1.5.1rc01-02 15 10501 15.so.15.1[.0] + * 1.5.1 15 10501 15.so.15.1[.0] + * 1.5.2beta01-03 15 10502 15.so.15.2[.0] + * 1.5.2rc01-03 15 10502 15.so.15.2[.0] + * 1.5.2 15 10502 15.so.15.2[.0] + * 1.5.3beta01-10 15 10503 15.so.15.3[.0] + * 1.5.3rc01-02 15 10503 15.so.15.3[.0] + * 1.5.3beta11 15 10503 15.so.15.3[.0] + * 1.5.3 [omitted] + * 1.5.4beta01-08 15 10504 15.so.15.4[.0] + * 1.5.4rc01 15 10504 15.so.15.4[.0] + * 1.5.4 15 10504 15.so.15.4[.0] + * 1.5.5beta01-08 15 10505 15.so.15.5[.0] + * 1.5.5rc01 15 10505 15.so.15.5[.0] + * 1.5.5 15 10505 15.so.15.5[.0] + * 1.5.6beta01-07 15 10506 15.so.15.6[.0] + * 1.5.6rc01-03 15 10506 15.so.15.6[.0] + * 1.5.6 15 10506 15.so.15.6[.0] + * 1.5.7beta01-05 15 10507 15.so.15.7[.0] + * 1.5.7rc01-03 15 10507 15.so.15.7[.0] + * 1.5.7 15 10507 15.so.15.7[.0] + * 1.5.8beta01 15 10508 15.so.15.8[.0] + * 1.5.8rc01 15 10508 15.so.15.8[.0] + * 1.5.8 15 10508 15.so.15.8[.0] + * 1.5.9beta01-02 15 10509 15.so.15.9[.0] + * 1.5.9rc01 15 10509 15.so.15.9[.0] + * 1.5.9 15 10509 15.so.15.9[.0] + * 1.5.10beta01-05 15 10510 15.so.15.10[.0] + * 1.5.10 15 10510 15.so.15.10[.0] + * 1.5.11beta01 15 10511 15.so.15.11[.0] + * 1.5.11rc01-05 15 10511 15.so.15.11[.0] + * 1.5.11 15 10511 15.so.15.11[.0] + * 1.5.12 15 10512 15.so.15.12[.0] + * + * 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 "rcNN". + * + * 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-manual.txt or libpng.3 for more information. The PNG + * specification is available as a W3C Recommendation and as an ISO + * Specification, +# endif + + /* Need the time information for converting tIME chunks, it + * defines struct tm: + */ +# ifdef PNG_CONVERT_tIME_SUPPORTED + /* "time.h" functions are not supported on all operating systems */ +# include +# endif +# endif + +/* Machine specific configuration. */ +# include "pngconf.h" +#endif + +/* + * Added at libpng-1.2.8 + * + * Ref MSDN: Private as priority over Special + * VS_FF_PRIVATEBUILD File *was not* built using standard release + * procedures. If this value is given, the StringFileInfo block must + * contain a PrivateBuild string. + * + * VS_FF_SPECIALBUILD File *was* built by the original company using + * standard release procedures but is a variation of the standard + * file of the same version number. If this value is given, the + * StringFileInfo block must contain a SpecialBuild string. + */ + +#ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */ +# define PNG_LIBPNG_BUILD_TYPE \ + (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) +#else +# ifdef PNG_LIBPNG_SPECIALBUILD +# define PNG_LIBPNG_BUILD_TYPE \ + (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) +# else +# define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE) +# endif +#endif + +#ifndef PNG_VERSION_INFO_ONLY + +/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* Version information for C files, stored in png.c. This had better match + * the version above. + */ +#define png_libpng_ver png_get_header_ver(NULL) + +/* This file is arranged in several sections: + * + * 1. Any configuration options that can be specified by for the application + * code when it is built. (Build time configuration is in pnglibconf.h) + * 2. Type definitions (base types are defined in pngconf.h), structure + * definitions. + * 3. Exported library functions. + * + * The library source code has additional files (principally pngpriv.h) that + * allow configuration of the library. + */ +/* Section 1: run time configuration + * See pnglibconf.h for build time configuration + * + * Run time configuration allows the application to choose between + * implementations of certain arithmetic APIs. The default is set + * at build time and recorded in pnglibconf.h, but it is safe to + * override these (and only these) settings. Note that this won't + * change what the library does, only application code, and the + * settings can (and probably should) be made on a per-file basis + * by setting the #defines before including png.h + * + * Use macros to read integers from PNG data or use the exported + * functions? + * PNG_USE_READ_MACROS: use the macros (see below) Note that + * the macros evaluate their argument multiple times. + * PNG_NO_USE_READ_MACROS: call the relevant library function. + * + * Use the alternative algorithm for compositing alpha samples that + * does not use division? + * PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division' + * algorithm. + * PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm. + * + * How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is + * false? + * PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error + * APIs to png_warning. + * Otherwise the calls are mapped to png_error. + */ + +/* Section 2: type definitions, including structures and compile time + * constants. + * See pngconf.h for base types that vary by machine/system + */ + +/* This triggers a compiler error in png.c, if png.c and png.h + * do not agree upon the version number. + */ +typedef char* png_libpng_version_1_5_12; + +/* 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_CONST png_color FAR * png_const_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_CONST png_color_16 FAR * png_const_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_CONST png_color_8 FAR * png_const_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_CONST png_sPLT_entry FAR * png_const_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_CONST png_sPLT_t FAR * png_const_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" fields can be a + * regular C string, an empty string, or a NULL pointer. + * However, the structure returned by png_get_text() will always contain + * the "text" field as a regular zero-terminated C string (possibly + * empty), never a NULL pointer, so it can be safely used in printf() and + * other string-handling functions. Note that the "itxt_length", "lang", and + * "lang_key" members of the structure only exist when the library is built + * with iTXt chunk support. Prior to libpng-1.4.0 the library was built by + * default without iTXt support. Also note that when iTXt *is* supported, + * the "lang" and "lang_key" fields contain NULL pointers when the + * "compression" field contains * PNG_TEXT_COMPRESSION_NONE or + * PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the + * same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag" + * which is always 0 or 1, or its "compression method" which is always 0. + */ +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 */ + 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 */ +} png_text; +typedef png_text FAR * png_textp; +typedef PNG_CONST png_text FAR * png_const_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_CONST png_time FAR * png_const_timep; +typedef png_time FAR * FAR * png_timepp; + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ + defined(PNG_HANDLE_AS_UNKNOWN_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_CONST png_unknown_chunk FAR * png_const_unknown_chunkp; +typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; +#endif + +/* Values for the unknown chunk location byte */ + +#define PNG_HAVE_IHDR 0x01 +#define PNG_HAVE_PLTE 0x02 +#define PNG_AFTER_IDAT 0x08 + +/* The complete definition of png_info has, as of libpng-1.5.0, + * been moved into a separate header file that is not accessible to + * applications. Read libpng-manual.txt or libpng.3 for more info. + */ +typedef struct png_info_def png_info; +typedef png_info FAR * png_infop; +typedef PNG_CONST png_info FAR * png_const_infop; +typedef png_info FAR * FAR * png_infopp; + +/* Maximum positive integer used in PNG is (2^31)-1 */ +#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL) +#define PNG_UINT_32_MAX ((png_uint_32)(-1)) +#define PNG_SIZE_MAX ((png_size_t)(-1)) + +/* These are constants for fixed point values encoded in the + * PNG specification manner (x100000) + */ +#define PNG_FP_1 100000 +#define PNG_FP_HALF 50000 +#define PNG_FP_MAX ((png_fixed_point)0x7fffffffL) +#define PNG_FP_MIN (-PNG_FP_MAX) + +/* 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 0x8000 /* 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_size_t 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; + +/* The complete definition of png_struct has, as of libpng-1.5.0, + * been moved into a separate header file that is not accessible to + * applications. Read libpng-manual.txt or libpng.3 for more info. + */ +typedef struct png_struct_def png_struct; +typedef PNG_CONST png_struct FAR * png_const_structp; +typedef png_struct FAR * png_structp; + +/* 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. Note that the 'write' function must not + * modify the buffer it is passed. The 'read' function, on the other hand, is + * expected to return the read data in the buffer. + */ +typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp)); +typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t)); +typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp)); +typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32, + int)); +typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32, + int)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop)); +typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop)); + +/* The following callback receives png_uint_32 row_number, int pass for the + * png_bytep data of the row. When transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep, + png_uint_32, int)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop, + png_bytep)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp, + png_unknown_chunkp)); +#endif +#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); +#endif + +#ifdef PNG_SETJMP_SUPPORTED +/* This must match the function definition in , and the application + * must include this before png.h to obtain the definition of jmp_buf. The + * function is required to be PNG_NORETURN, but this is not checked. If the + * function does return the application will crash via an abort() or similar + * system level call. + * + * If you get a warning here while building the library you may need to make + * changes to ensure that pnglibconf.h records the calling convention used by + * your compiler. This may be very difficult - try using a different compiler + * to build the library! + */ +PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef); +#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 */ +/* Added to libpng-1.2.34 */ +#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER +#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ +/* Added to libpng-1.4.0 */ +#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ +/* Added to libpng-1.5.4 */ +#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */ +#define PNG_TRANSFORM_SCALE_16 0x8000 /* read 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 + +/* NOTE: prior to 1.5 these functions had no 'API' style declaration, + * this allowed the zlib default functions to be used on Windows + * platforms. In 1.5 the zlib default malloc (which just calls malloc and + * ignores the first argument) should be completely compatible with the + * following. + */ +typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp, + png_alloc_size_t)); +typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp)); + +typedef png_struct FAR * FAR * png_structpp; + +/* Section 3: exported functions + * Here are the function definitions most commonly used. This is not + * the place to find out how to use libpng. See libpng-manual.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. + * + * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in + * pngconf.h and in the *.dfn files in the scripts directory. + * + * PNG_EXPORT(ordinal, type, name, (args)); + * + * ordinal: ordinal that is used while building + * *.def files. The ordinal value is only + * relevant when preprocessing png.h with + * the *.dfn files for building symbol table + * entries, and are removed by pngconf.h. + * type: return type of the function + * name: function name + * args: function arguments, with types + * + * When we wish to append attributes to a function prototype we use + * the PNG_EXPORTA() macro instead. + * + * PNG_EXPORTA(ordinal, type, name, (args), attributes); + * + * ordinal, type, name, and args: same as in PNG_EXPORT(). + * attributes: function attributes + */ + +/* Returns the version number of the library */ +PNG_EXPORT(1, png_uint_32, png_access_version_number, (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. + */ +PNG_EXPORT(2, void, png_set_sig_bytes, (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). + */ +PNG_EXPORT(3, int, png_sig_cmp, (png_const_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). + */ +#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n)) + +/* Allocate and initialize png_ptr struct for reading, and any other memory. */ +PNG_EXPORTA(4, png_structp, png_create_read_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn), + PNG_ALLOCATED); + +/* Allocate and initialize png_ptr struct for writing, and any other memory */ +PNG_EXPORTA(5, png_structp, png_create_write_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn), + PNG_ALLOCATED); + +PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size, + (png_const_structp png_ptr)); + +PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structp png_ptr, + png_size_t size)); + +/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp + * match up. + */ +#ifdef PNG_SETJMP_SUPPORTED +/* This function returns the jmp_buf built in to *png_ptr. It must be + * supplied with an appropriate 'longjmp' function to use on that jmp_buf + * unless the default error function is overridden in which case NULL is + * acceptable. The size of the jmp_buf is checked against the actual size + * allocated by the library - the call will return NULL on a mismatch + * indicating an ABI mismatch. + */ +PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structp png_ptr, + png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)); +# define png_jmpbuf(png_ptr) \ + (*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf))) +#else +# define png_jmpbuf(png_ptr) \ + (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) +#endif +/* This function should be used by libpng applications in place of + * longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it + * will use it; otherwise it will call PNG_ABORT(). This function was + * added in libpng-1.5.0. + */ +PNG_EXPORTA(9, void, png_longjmp, (png_structp png_ptr, int val), + PNG_NORETURN); + +#ifdef PNG_READ_SUPPORTED +/* Reset the compression stream */ +PNG_EXPORT(10, int, png_reset_zstream, (png_structp png_ptr)); +#endif + +/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ +#ifdef PNG_USER_MEM_SUPPORTED +PNG_EXPORTA(11, png_structp, png_create_read_struct_2, + (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), + PNG_ALLOCATED); +PNG_EXPORTA(12, png_structp, png_create_write_struct_2, + (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), + PNG_ALLOCATED); +#endif + +/* Write the PNG file signature. */ +PNG_EXPORT(13, void, png_write_sig, (png_structp png_ptr)); + +/* Write a PNG chunk - size, type, (optional) data, CRC. */ +PNG_EXPORT(14, void, png_write_chunk, (png_structp png_ptr, png_const_bytep + chunk_name, png_const_bytep data, png_size_t length)); + +/* Write the start of a PNG chunk - length and chunk name. */ +PNG_EXPORT(15, void, png_write_chunk_start, (png_structp png_ptr, + png_const_bytep chunk_name, png_uint_32 length)); + +/* Write the data of a PNG chunk started with png_write_chunk_start(). */ +PNG_EXPORT(16, void, png_write_chunk_data, (png_structp png_ptr, + png_const_bytep data, png_size_t length)); + +/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +PNG_EXPORT(17, void, png_write_chunk_end, (png_structp png_ptr)); + +/* Allocate and initialize the info structure */ +PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_structp png_ptr), + PNG_ALLOCATED); + +PNG_EXPORT(19, void, png_info_init_3, (png_infopp info_ptr, + png_size_t png_info_struct_size)); + +/* Writes all the PNG information before the image. */ +PNG_EXPORT(20, void, png_write_info_before_PLTE, + (png_structp png_ptr, png_infop info_ptr)); +PNG_EXPORT(21, void, png_write_info, + (png_structp png_ptr, png_infop info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the information before the actual image data. */ +PNG_EXPORT(22, void, png_read_info, + (png_structp png_ptr, png_infop info_ptr)); +#endif + +#ifdef PNG_TIME_RFC1123_SUPPORTED +PNG_EXPORT(23, png_const_charp, png_convert_to_rfc1123, + (png_structp png_ptr, + png_const_timep ptime)); +#endif + +#ifdef PNG_CONVERT_tIME_SUPPORTED +/* Convert from a struct tm to png_time */ +PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime, + PNG_CONST struct tm FAR * ttime)); + +/* Convert from time_t to png_time. Uses gmtime() */ +PNG_EXPORT(25, void, png_convert_from_time_t, + (png_timep ptime, time_t ttime)); +#endif /* PNG_CONVERT_tIME_SUPPORTED */ + +#ifdef PNG_READ_EXPAND_SUPPORTED +/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ +PNG_EXPORT(26, void, png_set_expand, (png_structp png_ptr)); +PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structp png_ptr)); +PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structp png_ptr)); +PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structp png_ptr)); +#endif + +#ifdef PNG_READ_EXPAND_16_SUPPORTED +/* Expand to 16-bit channels, forces conversion of palette to RGB and expansion + * of a tRNS chunk if present. + */ +PNG_EXPORT(221, void, png_set_expand_16, (png_structp png_ptr)); +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +/* Use blue, green, red order for pixels. */ +PNG_EXPORT(30, void, png_set_bgr, (png_structp png_ptr)); +#endif + +#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED +/* Expand the grayscale to 24-bit RGB if necessary. */ +PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structp png_ptr)); +#endif + +#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED +/* Reduce RGB to grayscale. */ +#define PNG_ERROR_ACTION_NONE 1 +#define PNG_ERROR_ACTION_WARN 2 +#define PNG_ERROR_ACTION_ERROR 3 +#define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/ + +PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structp png_ptr, + int error_action, double red, double green)); +PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structp png_ptr, + int error_action, png_fixed_point red, png_fixed_point green)); + +PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structp + png_ptr)); +#endif + +#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED +PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth, + png_colorp palette)); +#endif + +#ifdef PNG_READ_ALPHA_MODE_SUPPORTED +/* How the alpha channel is interpreted - this affects how the color channels of + * a PNG file are returned when an alpha channel, or tRNS chunk in a palette + * file, is present. + * + * This has no effect on the way pixels are written into a PNG output + * datastream. The color samples in a PNG datastream are never premultiplied + * with the alpha samples. + * + * The default is to return data according to the PNG specification: the alpha + * channel is a linear measure of the contribution of the pixel to the + * corresponding composited pixel. The gamma encoded color channels must be + * scaled according to the contribution and to do this it is necessary to undo + * the encoding, scale the color values, perform the composition and reencode + * the values. This is the 'PNG' mode. + * + * The alternative is to 'associate' the alpha with the color information by + * storing color channel values that have been scaled by the alpha. The + * advantage is that the color channels can be resampled (the image can be + * scaled) in this form. The disadvantage is that normal practice is to store + * linear, not (gamma) encoded, values and this requires 16-bit channels for + * still images rather than the 8-bit channels that are just about sufficient if + * gamma encoding is used. In addition all non-transparent pixel values, + * including completely opaque ones, must be gamma encoded to produce the final + * image. This is the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' mode (the + * latter being the two common names for associated alpha color channels.) + * + * Since it is not necessary to perform arithmetic on opaque color values so + * long as they are not to be resampled and are in the final color space it is + * possible to optimize the handling of alpha by storing the opaque pixels in + * the PNG format (adjusted for the output color space) while storing partially + * opaque pixels in the standard, linear, format. The accuracy required for + * standard alpha composition is relatively low, because the pixels are + * isolated, therefore typically the accuracy loss in storing 8-bit linear + * values is acceptable. (This is not true if the alpha channel is used to + * simulate transparency over large areas - use 16 bits or the PNG mode in + * this case!) This is the 'OPTIMIZED' mode. For this mode a pixel is + * treated as opaque only if the alpha value is equal to the maximum value. + * + * The final choice is to gamma encode the alpha channel as well. This is + * broken because, in practice, no implementation that uses this choice + * correctly undoes the encoding before handling alpha composition. Use this + * choice only if other serious errors in the software or hardware you use + * mandate it; the typical serious error is for dark halos to appear around + * opaque areas of the composited PNG image because of arithmetic overflow. + * + * The API function png_set_alpha_mode specifies which of these choices to use + * with an enumerated 'mode' value and the gamma of the required output: + */ +#define PNG_ALPHA_PNG 0 /* according to the PNG standard */ +#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */ +#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */ +#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */ +#define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */ +#define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */ + +PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structp png_ptr, int mode, + double output_gamma)); +PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structp png_ptr, + int mode, png_fixed_point output_gamma)); +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED) +/* The output_gamma value is a screen gamma in libpng terminology: it expresses + * how to decode the output values, not how they are encoded. The values used + * correspond to the normal numbers used to describe the overall gamma of a + * computer display system; for example 2.2 for an sRGB conformant system. The + * values are scaled by 100000 in the _fixed version of the API (so 220000 for + * sRGB.) + * + * The inverse of the value is always used to provide a default for the PNG file + * encoding if it has no gAMA chunk and if png_set_gamma() has not been called + * to override the PNG gamma information. + * + * When the ALPHA_OPTIMIZED mode is selected the output gamma is used to encode + * opaque pixels however pixels with lower alpha values are not encoded, + * regardless of the output gamma setting. + * + * When the standard Porter Duff handling is requested with mode 1 the output + * encoding is set to be linear and the output_gamma value is only relevant + * as a default for input data that has no gamma information. The linear output + * encoding will be overridden if png_set_gamma() is called - the results may be + * highly unexpected! + * + * The following numbers are derived from the sRGB standard and the research + * behind it. sRGB is defined to be approximated by a PNG gAMA chunk value of + * 0.45455 (1/2.2) for PNG. The value implicitly includes any viewing + * correction required to take account of any differences in the color + * environment of the original scene and the intended display environment; the + * value expresses how to *decode* the image for display, not how the original + * data was *encoded*. + * + * sRGB provides a peg for the PNG standard by defining a viewing environment. + * sRGB itself, and earlier TV standards, actually use a more complex transform + * (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is + * limited to simple power laws.) By saying that an image for direct display on + * an sRGB conformant system should be stored with a gAMA chunk value of 45455 + * (11.3.3.2 and 11.3.3.5 of the ISO PNG specification) the PNG specification + * makes it possible to derive values for other display systems and + * environments. + * + * The Mac value is deduced from the sRGB based on an assumption that the actual + * extra viewing correction used in early Mac display systems was implemented as + * a power 1.45 lookup table. + * + * Any system where a programmable lookup table is used or where the behavior of + * the final display device characteristics can be changed requires system + * specific code to obtain the current characteristic. However this can be + * difficult and most PNG gamma correction only requires an approximate value. + * + * By default, if png_set_alpha_mode() is not called, libpng assumes that all + * values are unencoded, linear, values and that the output device also has a + * linear characteristic. This is only very rarely correct - it is invariably + * better to call png_set_alpha_mode() with PNG_DEFAULT_sRGB than rely on the + * default if you don't know what the right answer is! + * + * The special value PNG_GAMMA_MAC_18 indicates an older Mac system (pre Mac OS + * 10.6) which used a correction table to implement a somewhat lower gamma on an + * otherwise sRGB system. + * + * Both these values are reserved (not simple gamma values) in order to allow + * more precise correction internally in the future. + * + * NOTE: the following values can be passed to either the fixed or floating + * point APIs, but the floating point API will also accept floating point + * values. + */ +#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */ +#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */ +#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */ +#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */ +#endif + +/* The following are examples of calls to png_set_alpha_mode to achieve the + * required overall gamma correction and, where necessary, alpha + * premultiplication. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * This is the default libpng handling of the alpha channel - it is not + * pre-multiplied into the color components. In addition the call states + * that the output is for a sRGB system and causes all PNG files without gAMA + * chunks to be assumed to be encoded using sRGB. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * In this case the output is assumed to be something like an sRGB conformant + * display preceeded by a power-law lookup table of power 1.45. This is how + * early Mac systems behaved. + * + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR); + * This is the classic Jim Blinn approach and will work in academic + * environments where everything is done by the book. It has the shortcoming + * of assuming that input PNG data with no gamma information is linear - this + * is unlikely to be correct unless the PNG files where generated locally. + * Most of the time the output precision will be so low as to show + * significant banding in dark areas of the image. + * + * png_set_expand_16(pp); + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB); + * This is a somewhat more realistic Jim Blinn inspired approach. PNG files + * are assumed to have the sRGB encoding if not marked with a gamma value and + * the output is always 16 bits per component. This permits accurate scaling + * and processing of the data. If you know that your input PNG files were + * generated locally you might need to replace PNG_DEFAULT_sRGB with the + * correct value for your system. + * + * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB); + * If you just need to composite the PNG image onto an existing background + * and if you control the code that does this you can use the optimization + * setting. In this case you just copy completely opaque pixels to the + * output. For pixels that are not completely transparent (you just skip + * those) you do the composition math using png_composite or png_composite_16 + * below then encode the resultant 8-bit or 16-bit values to match the output + * encoding. + * + * Other cases + * If neither the PNG nor the standard linear encoding work for you because + * of the software or hardware you use then you have a big problem. The PNG + * case will probably result in halos around the image. The linear encoding + * will probably result in a washed out, too bright, image (it's actually too + * contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably + * substantially reduce the halos. Alternatively try: + * + * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB); + * This option will also reduce the halos, but there will be slight dark + * halos round the opaque parts of the image where the background is light. + * In the OPTIMIZED mode the halos will be light halos where the background + * is dark. Take your pick - the halos are unavoidable unless you can get + * your hardware/software fixed! (The OPTIMIZED approach is slightly + * faster.) + * + * When the default gamma of PNG files doesn't match the output gamma. + * If you have PNG files with no gamma information png_set_alpha_mode allows + * you to provide a default gamma, but it also sets the ouput gamma to the + * matching value. If you know your PNG files have a gamma that doesn't + * match the output you can take advantage of the fact that + * png_set_alpha_mode always sets the output gamma but only sets the PNG + * default if it is not already set: + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * The first call sets both the default and the output gamma values, the + * second call overrides the output gamma without changing the default. This + * is easier than achieving the same effect with png_set_gamma. You must use + * PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will + * fire if more than one call to png_set_alpha_mode and png_set_background is + * made in the same read operation, however multiple calls with PNG_ALPHA_PNG + * are ignored. + */ + +#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED +PNG_EXPORT(36, void, png_set_strip_alpha, (png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +PNG_EXPORT(37, void, png_set_swap_alpha, (png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +PNG_EXPORT(38, void, png_set_invert_alpha, (png_structp png_ptr)); +#endif + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ +PNG_EXPORT(39, void, png_set_filler, (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 +/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ +PNG_EXPORT(40, void, png_set_add_alpha, + (png_structp png_ptr, png_uint_32 filler, + int flags)); +#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. */ +PNG_EXPORT(41, void, png_set_swap, (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. */ +PNG_EXPORT(42, void, png_set_packing, (png_structp png_ptr)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ + defined(PNG_WRITE_PACKSWAP_SUPPORTED) +/* Swap packing order of pixels in bytes. */ +PNG_EXPORT(43, void, png_set_packswap, (png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +/* Converts files to legal bit depths. */ +PNG_EXPORT(44, void, png_set_shift, (png_structp png_ptr, png_const_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. + * MUST be called before png_read_update_info or png_start_read_image, + * otherwise it will not have the desired effect. Note that it is still + * necessary to call png_read_row or png_read_rows png_get_image_height + * times for each pass. +*/ +PNG_EXPORT(45, int, png_set_interlace_handling, (png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +/* Invert monochrome files */ +PNG_EXPORT(46, void, png_set_invert_mono, (png_structp png_ptr)); +#endif + +#ifdef PNG_READ_BACKGROUND_SUPPORTED +/* Handle alpha and tRNS by replacing with a background color. Prior to + * libpng-1.5.4 this API must not be called before the PNG file header has been + * read. Doing so will result in unexpected behavior and possible warnings or + * errors if the PNG file contains a bKGD chunk. + */ +PNG_FP_EXPORT(47, void, png_set_background, (png_structp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, double background_gamma)); +PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, png_fixed_point background_gamma)); +#endif +#ifdef PNG_READ_BACKGROUND_SUPPORTED +# 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 + +#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED +/* Scale a 16-bit depth file down to 8-bit, accurately. */ +PNG_EXPORT(229, void, png_set_scale_16, (png_structp png_ptr)); +#endif + +#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED +#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */ +/* Strip the second byte of information from a 16-bit depth file. */ +PNG_EXPORT(48, void, png_set_strip_16, (png_structp png_ptr)); +#endif + +#ifdef PNG_READ_QUANTIZE_SUPPORTED +/* Turn on quantizing, and reduce the palette to the number of colors + * available. + */ +PNG_EXPORT(49, void, png_set_quantize, + (png_structp png_ptr, png_colorp palette, + int num_palette, int maximum_colors, png_const_uint_16p histogram, + int full_quantize)); +#endif + +#ifdef PNG_READ_GAMMA_SUPPORTED +/* The threshold on gamma processing is configurable but hard-wired into the + * library. The following is the floating point variant. + */ +#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001) + +/* Handle gamma correction. Screen_gamma=(display_exponent). + * NOTE: this API simply sets the screen and file gamma values. It will + * therefore override the value for gamma in a PNG file if it is called after + * the file header has been read - use with care - call before reading the PNG + * file for best results! + * + * These routines accept the same gamma values as png_set_alpha_mode (described + * above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either + * API (floating point or fixed.) Notice, however, that the 'file_gamma' value + * is the inverse of a 'screen gamma' value. + */ +PNG_FP_EXPORT(50, void, png_set_gamma, + (png_structp png_ptr, double screen_gamma, + double override_file_gamma)); +PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structp png_ptr, + png_fixed_point screen_gamma, png_fixed_point override_file_gamma)); +#endif + +#ifdef PNG_WRITE_FLUSH_SUPPORTED +/* Set how many lines between output flushes - 0 for no flushing */ +PNG_EXPORT(51, void, png_set_flush, (png_structp png_ptr, int nrows)); +/* Flush the current PNG output buffer */ +PNG_EXPORT(52, void, png_write_flush, (png_structp png_ptr)); +#endif + +/* Optional update palette with requested transformations */ +PNG_EXPORT(53, void, png_start_read_image, (png_structp png_ptr)); + +/* Optional call to update the users info structure */ +PNG_EXPORT(54, void, png_read_update_info, + (png_structp png_ptr, png_infop info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read one or more rows of image data. */ +PNG_EXPORT(55, void, png_read_rows, (png_structp png_ptr, png_bytepp row, + png_bytepp display_row, png_uint_32 num_rows)); +#endif + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read a row of data. */ +PNG_EXPORT(56, void, png_read_row, (png_structp png_ptr, png_bytep row, + png_bytep display_row)); +#endif + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the whole image into memory at once. */ +PNG_EXPORT(57, void, png_read_image, (png_structp png_ptr, png_bytepp image)); +#endif + +/* Write a row of image data */ +PNG_EXPORT(58, void, png_write_row, + (png_structp png_ptr, png_const_bytep row)); + +/* Write a few rows of image data: (*row) is not written; however, the type + * is declared as writeable to maintain compatibility with previous versions + * of libpng and to allow the 'display_row' array from read_rows to be passed + * unchanged to write_rows. + */ +PNG_EXPORT(59, void, png_write_rows, (png_structp png_ptr, png_bytepp row, + png_uint_32 num_rows)); + +/* Write the image data */ +PNG_EXPORT(60, void, png_write_image, + (png_structp png_ptr, png_bytepp image)); + +/* Write the end of the PNG file. */ +PNG_EXPORT(61, void, png_write_end, + (png_structp png_ptr, png_infop info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the end of the PNG file. */ +PNG_EXPORT(62, void, png_read_end, (png_structp png_ptr, png_infop info_ptr)); +#endif + +/* Free any memory associated with the png_info_struct */ +PNG_EXPORT(63, void, png_destroy_info_struct, (png_structp png_ptr, + png_infopp info_ptr_ptr)); + +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); + +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr)); + +/* Set the libpng method of handling chunk CRC errors */ +PNG_EXPORT(66, void, png_set_crc_action, + (png_structp png_ptr, int crit_action, int ancil_action)); + +/* Values for png_set_crc_action() 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. + */ +PNG_EXPORT(67, void, png_set_filter, + (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 + +#ifdef 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. + */ +PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structp png_ptr, + int heuristic_method, int num_weights, png_const_doublep filter_weights, + png_const_doublep filter_costs)); +PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed, + (png_structp png_ptr, + int heuristic_method, int num_weights, png_const_fixed_point_p + filter_weights, png_const_fixed_point_p filter_costs)); +#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 */ + +#ifdef PNG_WRITE_SUPPORTED +/* 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. + */ +PNG_EXPORT(69, void, png_set_compression_level, + (png_structp png_ptr, int level)); + +PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structp png_ptr, + int mem_level)); + +PNG_EXPORT(71, void, png_set_compression_strategy, (png_structp png_ptr, + int strategy)); + +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structp png_ptr, + int window_bits)); + +PNG_EXPORT(73, void, png_set_compression_method, (png_structp png_ptr, + int method)); +#endif + +#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED +/* Also set zlib parameters for compressing non-IDAT chunks */ +PNG_EXPORT(222, void, png_set_text_compression_level, + (png_structp png_ptr, int level)); + +PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structp png_ptr, + int mem_level)); + +PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structp png_ptr, + int strategy)); + +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(225, void, png_set_text_compression_window_bits, (png_structp + png_ptr, int window_bits)); + +PNG_EXPORT(226, void, png_set_text_compression_method, (png_structp png_ptr, + int method)); +#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ + +/* 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-manual.txt for + * more information. + */ + +#ifdef PNG_STDIO_SUPPORTED +/* Initialize the input/output for the PNG file to the default functions. */ +PNG_EXPORT(74, void, png_init_io, (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. + */ + +PNG_EXPORT(75, void, png_set_error_fn, + (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 */ +PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_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). + * It is probably a mistake to use NULL for output_flush_fn if + * write_data_fn is not also NULL unless you have built libpng with + * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's + * default flush function, which uses the standard *FILE structure, will + * be used. + */ +PNG_EXPORT(77, void, png_set_write_fn, (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. */ +PNG_EXPORT(78, void, png_set_read_fn, (png_structp png_ptr, png_voidp io_ptr, + png_rw_ptr read_data_fn)); + +/* Return the user pointer associated with the I/O functions */ +PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_structp png_ptr)); + +PNG_EXPORT(80, void, png_set_read_status_fn, (png_structp png_ptr, + png_read_status_ptr read_row_fn)); + +PNG_EXPORT(81, void, png_set_write_status_fn, (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). */ +PNG_EXPORT(82, void, png_set_mem_fn, (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 */ +PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structp png_ptr)); +#endif + +#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structp png_ptr, + png_user_transform_ptr read_user_transform_fn)); +#endif + +#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structp png_ptr, + png_user_transform_ptr write_user_transform_fn)); +#endif + +#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED +PNG_EXPORT(86, void, png_set_user_transform_info, (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 */ +PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr, + (png_const_structp png_ptr)); +#endif + +#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED +/* Return information about the row currently being processed. Note that these + * APIs do not fail but will return unexpected results if called outside a user + * transform callback. Also note that when transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structp)); +PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structp)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structp png_ptr, + png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_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. + */ +PNG_EXPORT(90, void, png_set_progressive_read_fn, (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 */ +PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, (png_const_structp png_ptr)); + +/* Function to be called when data becomes available */ +PNG_EXPORT(92, void, png_process_data, + (png_structp png_ptr, png_infop info_ptr, + png_bytep buffer, png_size_t buffer_size)); + +/* A function which may be called *only* within png_process_data to stop the + * processing of any more data. The function returns the number of bytes + * remaining, excluding any that libpng has cached internally. A subsequent + * call to png_process_data must supply these bytes again. If the argument + * 'save' is set to true the routine will first save all the pending data and + * will always return 0. + */ +PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structp, int save)); + +/* A function which may be called *only* outside (after) a call to + * png_process_data. It returns the number of bytes of data to skip in the + * input. Normally it will return 0, but if it returns a non-zero value the + * application must skip than number of bytes of input data and pass the + * following data to the next call to png_process_data. + */ +PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structp)); + +#ifdef PNG_READ_INTERLACING_SUPPORTED +/* Function that combines rows. 'new_row' is a flag that should come from + * the callback and be non-NULL if anything needs to be done; the library + * stores its own version of the new data internally and ignores the passed + * in value. + */ +PNG_EXPORT(93, void, png_progressive_combine_row, (png_structp png_ptr, + png_bytep old_row, png_const_bytep new_row)); +#endif /* PNG_READ_INTERLACING_SUPPORTED */ +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +PNG_EXPORTA(94, png_voidp, png_malloc, + (png_structp png_ptr, png_alloc_size_t size), + PNG_ALLOCATED); +/* Added at libpng version 1.4.0 */ +PNG_EXPORTA(95, png_voidp, png_calloc, + (png_structp png_ptr, png_alloc_size_t size), + PNG_ALLOCATED); + +/* Added at libpng version 1.2.4 */ +PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_structp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); + +/* Frees a pointer allocated by png_malloc() */ +PNG_EXPORT(97, void, png_free, (png_structp png_ptr, png_voidp ptr)); + +/* Free data that was allocated internally */ +PNG_EXPORT(98, void, png_free_data, + (png_structp png_ptr, png_infop info_ptr, png_uint_32 free_me, int num)); + +/* Reassign responsibility for freeing existing data, whether allocated + * by libpng or by the application */ +PNG_EXPORT(99, void, png_data_freer, + (png_structp png_ptr, png_infop info_ptr, int freer, png_uint_32 mask)); + +/* 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 +PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_structp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); +PNG_EXPORT(101, void, png_free_default, (png_structp png_ptr, png_voidp ptr)); +#endif + +#ifdef PNG_ERROR_TEXT_SUPPORTED +/* Fatal error in PNG image of libpng - can't continue */ +PNG_EXPORTA(102, void, png_error, + (png_structp png_ptr, png_const_charp error_message), + PNG_NORETURN); + +/* The same, but the chunk name is prepended to the error string. */ +PNG_EXPORTA(103, void, png_chunk_error, (png_structp png_ptr, + png_const_charp error_message), PNG_NORETURN); + +#else +/* Fatal error in PNG image of libpng - can't continue */ +PNG_EXPORTA(104, void, png_err, (png_structp png_ptr), PNG_NORETURN); +#endif + +#ifdef PNG_WARNINGS_SUPPORTED +/* Non-fatal error in libpng. Can continue, but may have a problem. */ +PNG_EXPORT(105, void, png_warning, (png_structp png_ptr, + png_const_charp warning_message)); + +/* Non-fatal error in libpng, chunk name is prepended to message. */ +PNG_EXPORT(106, void, png_chunk_warning, (png_structp png_ptr, + png_const_charp warning_message)); +#endif + +#ifdef PNG_BENIGN_ERRORS_SUPPORTED +/* Benign error in libpng. Can continue, but may have a problem. + * User can choose whether to handle as a fatal error or as a warning. */ +# undef png_benign_error +PNG_EXPORT(107, void, png_benign_error, (png_structp png_ptr, + png_const_charp warning_message)); + +/* Same, chunk name is prepended to message. */ +# undef png_chunk_benign_error +PNG_EXPORT(108, void, png_chunk_benign_error, (png_structp png_ptr, + png_const_charp warning_message)); + +PNG_EXPORT(109, void, png_set_benign_errors, + (png_structp png_ptr, int allowed)); +#else +# ifdef PNG_ALLOW_BENIGN_ERRORS +# define png_benign_error png_warning +# define png_chunk_benign_error png_chunk_warning +# else +# define png_benign_error png_error +# define png_chunk_benign_error png_chunk_error +# endif +#endif + +/* 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. */ +PNG_EXPORT(110, png_uint_32, png_get_valid, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_uint_32 flag)); + +/* Returns number of bytes needed to hold a transformed row. */ +PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structp png_ptr, + png_const_infop info_ptr)); + +#ifdef PNG_INFO_IMAGE_SUPPORTED +/* Returns row_pointers, which is an array of pointers to scanlines that was + * returned from png_read_png(). + */ +PNG_EXPORT(112, png_bytepp, png_get_rows, + (png_const_structp png_ptr, png_const_infop info_ptr)); +/* Set row_pointers, which is an array of pointers to scanlines for use + * by png_write_png(). + */ +PNG_EXPORT(113, void, png_set_rows, (png_structp png_ptr, + png_infop info_ptr, png_bytepp row_pointers)); +#endif + +/* Returns number of color channels in image. */ +PNG_EXPORT(114, png_byte, png_get_channels, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +#ifdef PNG_EASY_ACCESS_SUPPORTED +/* Returns image width in pixels. */ +PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structp png_ptr, + png_const_infop info_ptr)); + +/* Returns image height in pixels. */ +PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structp png_ptr, + png_const_infop info_ptr)); + +/* Returns image bit_depth. */ +PNG_EXPORT(117, png_byte, png_get_bit_depth, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +/* Returns image color_type. */ +PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structp png_ptr, + png_const_infop info_ptr)); + +/* Returns image filter_type. */ +PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structp png_ptr, + png_const_infop info_ptr)); + +/* Returns image interlace_type. */ +PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structp png_ptr, + png_const_infop info_ptr)); + +/* Returns image compression_type. */ +PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structp png_ptr, + png_const_infop info_ptr)); + +/* Returns image resolution in pixels per meter, from pHYs chunk data. */ +PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +/* Returns pixel aspect ratio, computed from pHYs chunk data. */ +PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(128, png_int_32, png_get_x_offset_microns, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +#endif /* PNG_EASY_ACCESS_SUPPORTED */ + +/* Returns pointer to signature string read from PNG header */ +PNG_EXPORT(130, png_const_bytep, png_get_signature, + (png_const_structp png_ptr, png_infop info_ptr)); + +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(131, png_uint_32, png_get_bKGD, + (png_const_structp png_ptr, png_infop info_ptr, + png_color_16p *background)); +#endif + +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(132, void, png_set_bKGD, (png_structp png_ptr, png_infop info_ptr, + png_const_color_16p background)); +#endif + +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structp png_ptr, + png_const_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)); +PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_structp png_ptr, + png_const_infop info_ptr, double *red_X, double *red_Y, double *red_Z, + double *green_X, double *green_Y, double *green_Z, double *blue_X, + double *blue_Y, double *blue_Z)); +#ifdef PNG_FIXED_POINT_SUPPORTED /* Otherwise not implemented */ +PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed, + (png_const_structp png_ptr, + png_const_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 +PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed, + (png_structp png_ptr, png_const_infop info_ptr, + png_fixed_point *int_red_X, png_fixed_point *int_red_Y, + png_fixed_point *int_red_Z, png_fixed_point *int_green_X, + png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, + png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, + png_fixed_point *int_blue_Z)); +#endif + +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(135, void, png_set_cHRM, + (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)); +PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_structp png_ptr, + png_infop info_ptr, double red_X, double red_Y, double red_Z, + double green_X, double green_Y, double green_Z, double blue_X, + double blue_Y, double blue_Z)); +PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (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)); +PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, + png_fixed_point int_red_Z, png_fixed_point int_green_X, + png_fixed_point int_green_Y, png_fixed_point int_green_Z, + png_fixed_point int_blue_X, png_fixed_point int_blue_Y, + png_fixed_point int_blue_Z)); +#endif + +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, + (png_const_structp png_ptr, png_const_infop info_ptr, + double *file_gamma)); +PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_fixed_point *int_file_gamma)); +#endif + +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(139, void, png_set_gAMA, (png_structp png_ptr, + png_infop info_ptr, double file_gamma)); +PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_file_gamma)); +#endif + +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(141, png_uint_32, png_get_hIST, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_uint_16p *hist)); +#endif + +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(142, void, png_set_hIST, (png_structp png_ptr, + png_infop info_ptr, png_const_uint_16p hist)); +#endif + +PNG_EXPORT(143, png_uint_32, png_get_IHDR, + (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)); + +PNG_EXPORT(144, void, png_set_IHDR, + (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)); + +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(145, png_uint_32, png_get_oFFs, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)); +#endif + +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(146, void, png_set_oFFs, + (png_structp png_ptr, png_infop info_ptr, + png_int_32 offset_x, png_int_32 offset_y, int unit_type)); +#endif + +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(147, png_uint_32, png_get_pCAL, + (png_const_structp png_ptr, png_const_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 + +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(148, void, png_set_pCAL, (png_structp png_ptr, + png_infop info_ptr, + png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, + int nparams, png_const_charp units, png_charpp params)); +#endif + +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(149, png_uint_32, png_get_pHYs, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +#endif + +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(150, void, png_set_pHYs, + (png_structp png_ptr, png_infop info_ptr, + png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +#endif + +PNG_EXPORT(151, png_uint_32, png_get_PLTE, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_colorp *palette, int *num_palette)); + +PNG_EXPORT(152, void, png_set_PLTE, + (png_structp png_ptr, png_infop info_ptr, + png_const_colorp palette, int num_palette)); + +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(153, png_uint_32, png_get_sBIT, + (png_const_structp png_ptr, png_infop info_ptr, + png_color_8p *sig_bit)); +#endif + +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(154, void, png_set_sBIT, + (png_structp png_ptr, png_infop info_ptr, png_const_color_8p sig_bit)); +#endif + +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structp png_ptr, + png_const_infop info_ptr, int *file_srgb_intent)); +#endif + +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(156, void, png_set_sRGB, + (png_structp png_ptr, png_infop info_ptr, int srgb_intent)); +PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_structp png_ptr, + png_infop info_ptr, int srgb_intent)); +#endif + +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(158, png_uint_32, png_get_iCCP, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_charpp name, int *compression_type, png_bytepp profile, + png_uint_32 *proflen)); +#endif + +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(159, void, png_set_iCCP, + (png_structp png_ptr, png_infop info_ptr, + png_const_charp name, int compression_type, png_const_bytep profile, + png_uint_32 proflen)); +#endif + +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(160, png_uint_32, png_get_sPLT, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_sPLT_tpp entries)); +#endif + +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(161, void, png_set_sPLT, + (png_structp png_ptr, png_infop info_ptr, + png_const_sPLT_tp entries, int nentries)); +#endif + +#ifdef PNG_TEXT_SUPPORTED +/* png_get_text also returns the number of text chunks in *num_text */ +PNG_EXPORT(162, png_uint_32, png_get_text, + (png_const_structp png_ptr, png_const_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. + */ + +#ifdef PNG_TEXT_SUPPORTED +PNG_EXPORT(163, void, png_set_text, + (png_structp png_ptr, png_infop info_ptr, + png_const_textp text_ptr, int num_text)); +#endif + +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(164, png_uint_32, png_get_tIME, + (png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time)); +#endif + +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(165, void, png_set_tIME, + (png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time)); +#endif + +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(166, png_uint_32, png_get_tRNS, + (png_const_structp png_ptr, png_infop info_ptr, + png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)); +#endif + +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(167, void, png_set_tRNS, + (png_structp png_ptr, png_infop info_ptr, + png_const_bytep trans_alpha, int num_trans, + png_const_color_16p trans_color)); +#endif + +#ifdef PNG_sCAL_SUPPORTED +PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, + (png_const_structp png_ptr, png_const_infop info_ptr, + int *unit, double *width, double *height)); +#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED +/* NOTE: this API is currently implemented using floating point arithmetic, + * consequently it can only be used on systems with floating point support. + * In any case the range of values supported by png_fixed_point is small and it + * is highly recommended that png_get_sCAL_s be used instead. + */ +PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed, + (png_structp png_ptr, png_const_infop info_ptr, int *unit, + png_fixed_point *width, + png_fixed_point *height)); +#endif +PNG_EXPORT(169, png_uint_32, png_get_sCAL_s, + (png_const_structp png_ptr, png_const_infop info_ptr, + int *unit, png_charpp swidth, png_charpp sheight)); + +PNG_FP_EXPORT(170, void, png_set_sCAL, + (png_structp png_ptr, png_infop info_ptr, + int unit, double width, double height)); +PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_structp png_ptr, + png_infop info_ptr, int unit, png_fixed_point width, + png_fixed_point height)); +PNG_EXPORT(171, void, png_set_sCAL_s, + (png_structp png_ptr, png_infop info_ptr, + int unit, png_const_charp swidth, png_const_charp sheight)); +#endif /* PNG_sCAL_SUPPORTED */ + +#ifdef PNG_HANDLE_AS_UNKNOWN_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. Because this turns off the default handling for chunks + that would otherwise be recognized the behavior of libpng transformations may + well become incorrect! + keep = 0: PNG_HANDLE_CHUNK_AS_DEFAULT: follow default behavior + = 1: PNG_HANDLE_CHUNK_NEVER: do not keep + = 2: PNG_HANDLE_CHUNK_IF_SAFE: keep only if safe-to-copy + = 3: PNG_HANDLE_CHUNK_ALWAYS: keep even if unsafe-to-copy +*/ +PNG_EXPORT(172, void, png_set_keep_unknown_chunks, + (png_structp png_ptr, int keep, + png_const_bytep chunk_list, int num_chunks)); + +/* The handling code is returned; the result is therefore true (non-zero) if + * special handling is required, false for the default handling. + */ +PNG_EXPORT(173, int, png_handle_as_unknown, (png_structp png_ptr, + png_const_bytep chunk_name)); +#endif +#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +PNG_EXPORT(174, void, png_set_unknown_chunks, (png_structp png_ptr, + png_infop info_ptr, png_const_unknown_chunkp unknowns, + int num_unknowns)); +PNG_EXPORT(175, void, png_set_unknown_chunk_location, + (png_structp png_ptr, png_infop info_ptr, int chunk, int location)); +PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structp png_ptr, + png_const_infop info_ptr, png_unknown_chunkpp entries)); +#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); + */ +PNG_EXPORT(177, void, png_set_invalid, + (png_structp png_ptr, png_infop info_ptr, int mask)); + +#ifdef PNG_INFO_IMAGE_SUPPORTED +/* The "params" pointer is currently not used and is for future expansion. */ +PNG_EXPORT(178, void, png_read_png, (png_structp png_ptr, png_infop info_ptr, + int transforms, png_voidp params)); +PNG_EXPORT(179, void, png_write_png, (png_structp png_ptr, png_infop info_ptr, + int transforms, png_voidp params)); +#endif + +PNG_EXPORT(180, png_const_charp, png_get_copyright, + (png_const_structp png_ptr)); +PNG_EXPORT(181, png_const_charp, png_get_header_ver, + (png_const_structp png_ptr)); +PNG_EXPORT(182, png_const_charp, png_get_header_version, + (png_const_structp png_ptr)); +PNG_EXPORT(183, png_const_charp, png_get_libpng_ver, + (png_const_structp png_ptr)); + +#ifdef PNG_MNG_FEATURES_SUPPORTED +PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structp png_ptr, + png_uint_32 mng_features_permitted)); +#endif + +/* For use in png_set_keep_unknown, added to version 1.2.6 */ +#define PNG_HANDLE_CHUNK_AS_DEFAULT 0 +#define PNG_HANDLE_CHUNK_NEVER 1 +#define PNG_HANDLE_CHUNK_IF_SAFE 2 +#define PNG_HANDLE_CHUNK_ALWAYS 3 + +/* 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 +PNG_EXPORT(185, void, png_set_strip_error_numbers, + (png_structp png_ptr, + png_uint_32 strip_mode)); +#endif + +/* Added in libpng-1.2.6 */ +#ifdef PNG_SET_USER_LIMITS_SUPPORTED +PNG_EXPORT(186, void, png_set_user_limits, (png_structp png_ptr, + png_uint_32 user_width_max, png_uint_32 user_height_max)); +PNG_EXPORT(187, png_uint_32, png_get_user_width_max, + (png_const_structp png_ptr)); +PNG_EXPORT(188, png_uint_32, png_get_user_height_max, + (png_const_structp png_ptr)); +/* Added in libpng-1.4.0 */ +PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structp png_ptr, + png_uint_32 user_chunk_cache_max)); +PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max, + (png_const_structp png_ptr)); +/* Added in libpng-1.4.1 */ +PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structp png_ptr, + png_alloc_size_t user_chunk_cache_max)); +PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max, + (png_const_structp png_ptr)); +#endif + +#if defined(PNG_INCH_CONVERSIONS_SUPPORTED) +PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +PNG_FP_EXPORT(196, float, png_get_x_offset_inches, + (png_const_structp png_ptr, png_const_infop info_ptr)); +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed, + (png_structp png_ptr, png_const_infop info_ptr)); +#endif + +PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structp png_ptr, + png_const_infop info_ptr)); +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed, + (png_structp png_ptr, png_const_infop info_ptr)); +#endif + +# ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structp png_ptr, + png_const_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, + int *unit_type)); +# endif /* PNG_pHYs_SUPPORTED */ +#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ + +/* Added in libpng-1.4.0 */ +#ifdef PNG_IO_STATE_SUPPORTED +PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_structp png_ptr)); + +PNG_EXPORTA(200, png_const_bytep, png_get_io_chunk_name, + (png_structp png_ptr), PNG_DEPRECATED); +PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type, + (png_const_structp png_ptr)); + +/* The flags returned by png_get_io_state() are the following: */ +# define PNG_IO_NONE 0x0000 /* no I/O at this moment */ +# define PNG_IO_READING 0x0001 /* currently reading */ +# define PNG_IO_WRITING 0x0002 /* currently writing */ +# define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */ +# define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */ +# define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */ +# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ +# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ +# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ +#endif /* ?PNG_IO_STATE_SUPPORTED */ + +/* Interlace support. The following macros are always defined so that if + * libpng interlace handling is turned off the macros may be used to handle + * interlaced images within the application. + */ +#define PNG_INTERLACE_ADAM7_PASSES 7 + +/* Two macros to return the first row and first column of the original, + * full, image which appears in a given pass. 'pass' is in the range 0 + * to 6 and the result is in the range 0 to 7. + */ +#define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7) +#define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7) + +/* A macro to return the offset between pixels in the output row for a pair of + * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that + * follows. Note that ROW_OFFSET is the offset from one row to the next whereas + * COL_OFFSET is from one column to the next, within a row. + */ +#define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8) +#define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1)) + +/* Two macros to help evaluate the number of rows or columns in each + * pass. This is expressed as a shift - effectively log2 of the number or + * rows or columns in each 8x8 tile of the original image. + */ +#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3) +#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3) + +/* Hence two macros to determine the number of rows or columns in a given + * pass of an image given its height or width. In fact these macros may + * return non-zero even though the sub-image is empty, because the other + * dimension may be empty for a small image. + */ +#define PNG_PASS_ROWS(height, pass) (((height)+(((1<>PNG_PASS_ROW_SHIFT(pass)) +#define PNG_PASS_COLS(width, pass) (((width)+(((1<>PNG_PASS_COL_SHIFT(pass)) + +/* For the reader row callbacks (both progressive and sequential) it is + * necessary to find the row in the output image given a row in an interlaced + * image, so two more macros: + */ +#define PNG_ROW_FROM_PASS_ROW(yIn, pass) \ + (((yIn)<>(((7-(off))-(pass))<<2)) & 0xF) | \ + ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0)) + +#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \ + ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1) +#define PNG_COL_IN_INTERLACE_PASS(x, pass) \ + ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1) + +#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)) + 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)*(65535 \ + - (png_uint_32)(alpha)) + 32768); \ + (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)) + \ + 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)(65535 - (png_uint_32)(alpha)) + \ + 32767) / 65535) +#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ + +#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf)); +PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf)); +PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf)); +#endif + +PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_structp png_ptr, + png_const_bytep buf)); +/* No png_get_int_16 -- may be added if there's a real need for it. */ + +/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */ +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i)); +#endif +#ifdef PNG_SAVE_INT_32_SUPPORTED +PNG_EXPORT(206, void, png_save_int_32, (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. + */ +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i)); +/* No png_save_int_16 -- may be added if there's a real need for it. */ +#endif + +#ifdef PNG_USE_READ_MACROS +/* Inline macros to do direct reads of bytes from the input buffer. + * The png_get_int_32() routine assumes we are using two's complement + * format for negative values, which is almost certainly true. + */ +# define png_get_uint_32(buf) \ + (((png_uint_32)(*(buf)) << 24) + \ + ((png_uint_32)(*((buf) + 1)) << 16) + \ + ((png_uint_32)(*((buf) + 2)) << 8) + \ + ((png_uint_32)(*((buf) + 3)))) + + /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the + * function) incorrectly returned a value of type png_uint_32. + */ +# define png_get_uint_16(buf) \ + ((png_uint_16) \ + (((unsigned int)(*(buf)) << 8) + \ + ((unsigned int)(*((buf) + 1))))) + +# define png_get_int_32(buf) \ + ((png_int_32)((*(buf) & 0x80) \ + ? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \ + : (png_int_32)png_get_uint_32(buf))) +#endif + +#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \ + defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED) +PNG_EXPORT(234, void, png_set_check_for_invalid_index, (png_structp png_ptr, + int allowed)); +#endif + +/* Maintainer: Put new public prototypes here ^, in libpng.3, and project + * defs + */ + +/* The last ordinal number (this is the *last* one already used; the next + * one to use is one more than this.) Maintainer, remember to add an entry to + * scripts/symbols.def as well. + */ +#ifdef PNG_EXPORT_LAST_ORDINAL + PNG_EXPORT_LAST_ORDINAL(234); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* PNG_VERSION_INFO_ONLY */ +/* Do not put anything past this line */ +#endif /* PNG_H */ diff --git a/polymer/eduke32/Windows/include/pngconf.h b/polymer/eduke32/Windows/include/pngconf.h new file mode 100755 index 000000000..5c3eb1454 --- /dev/null +++ b/polymer/eduke32/Windows/include/pngconf.h @@ -0,0 +1,596 @@ + +/* pngconf.h - machine configurable file for libpng + * + * libpng version 1.5.12 - July 11, 2012 + * + * Copyright (c) 1998-2012 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.) + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h + * + */ + +/* 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 + +#ifndef PNG_BUILDING_SYMBOL_TABLE +/* PNG_NO_LIMITS_H may be used to turn off the use of the standard C + * definition file for machine specific limits, this may impact the + * correctness of the definitions below (see uses of INT_MAX). + */ +# ifndef PNG_NO_LIMITS_H +# include +# endif + +/* For the memory copy APIs (i.e. the standard definitions of these), + * because this file defines png_memcpy and so on the base APIs must + * be defined here. + */ +# ifdef BSD +# include +# else +# include +# endif + +/* For png_FILE_p - this provides the standard definition of a + * FILE + */ +# ifdef PNG_STDIO_SUPPORTED +# include +# endif +#endif + +/* This controls optimization of the reading of 16 and 32 bit values + * from PNG files. It can be set on a per-app-file basis - it + * just changes whether a macro is used when the function is called. + * The library builder sets the default; if read functions are not + * built into the library the macro implementation is forced on. + */ +#ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED +# define PNG_USE_READ_MACROS +#endif +#if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS) +# if PNG_DEFAULT_READ_MACROS +# define PNG_USE_READ_MACROS +# endif +#endif + +/* COMPILER SPECIFIC OPTIONS. + * + * These options are provided so that a variety of difficult compilers + * can be used. Some are fixed at build time (e.g. PNG_API_RULE + * below) but still have compiler specific implementations, others + * may be changed on a per-file basis when compiling against libpng. + */ + +/* The PNGARG 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) () +# else +# define PNGARG(arglist) arglist +# endif /* _NO_PROTO */ + +# endif /* OF */ + +#endif /* PNGARG */ + +/* Function calling conventions. + * ============================= + * Normally it is not necessary to specify to the compiler how to call + * a function - it just does it - however on x86 systems derived from + * Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems + * and some others) there are multiple ways to call a function and the + * default can be changed on the compiler command line. For this reason + * libpng specifies the calling convention of every exported function and + * every function called via a user supplied function pointer. This is + * done in this file by defining the following macros: + * + * PNGAPI Calling convention for exported functions. + * PNGCBAPI Calling convention for user provided (callback) functions. + * PNGCAPI Calling convention used by the ANSI-C library (required + * for longjmp callbacks and sometimes used internally to + * specify the calling convention for zlib). + * + * These macros should never be overridden. If it is necessary to + * change calling convention in a private build this can be done + * by setting PNG_API_RULE (which defaults to 0) to one of the values + * below to select the correct 'API' variants. + * + * PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout. + * This is correct in every known environment. + * PNG_API_RULE=1 Use the operating system convention for PNGAPI and + * the 'C' calling convention (from PNGCAPI) for + * callbacks (PNGCBAPI). This is no longer required + * in any known environment - if it has to be used + * please post an explanation of the problem to the + * libpng mailing list. + * + * These cases only differ if the operating system does not use the C + * calling convention, at present this just means the above cases + * (x86 DOS/Windows sytems) and, even then, this does not apply to + * Cygwin running on those systems. + * + * Note that the value must be defined in pnglibconf.h so that what + * the application uses to call the library matches the conventions + * set when building the library. + */ + +/* Symbol export + * ============= + * When building a shared library it is almost always necessary to tell + * the compiler which symbols to export. The png.h macro 'PNG_EXPORT' + * is used to mark the symbols. On some systems these symbols can be + * extracted at link time and need no special processing by the compiler, + * on other systems the symbols are flagged by the compiler and just + * the declaration requires a special tag applied (unfortunately) in a + * compiler dependent way. Some systems can do either. + * + * A small number of older systems also require a symbol from a DLL to + * be flagged to the program that calls it. This is a problem because + * we do not know in the header file included by application code that + * the symbol will come from a shared library, as opposed to a statically + * linked one. For this reason the application must tell us by setting + * the magic flag PNG_USE_DLL to turn on the special processing before + * it includes png.h. + * + * Four additional macros are used to make this happen: + * + * PNG_IMPEXP The magic (if any) to cause a symbol to be exported from + * the build or imported if PNG_USE_DLL is set - compiler + * and system specific. + * + * PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to + * 'type', compiler specific. + * + * PNG_DLL_EXPORT Set to the magic to use during a libpng build to + * make a symbol exported from the DLL. Not used in the + * public header files; see pngpriv.h for how it is used + * in the libpng build. + * + * PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come + * from a DLL - used to define PNG_IMPEXP when + * PNG_USE_DLL is set. + */ + +/* System specific discovery. + * ========================== + * This code is used at build time to find PNG_IMPEXP, the API settings + * and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL + * import processing is possible. On Windows/x86 systems it also sets + * compiler-specific macros to the values required to change the calling + * conventions of the various functions. + */ +#if ( defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\ + defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) ) &&\ + ( defined(_X86_) || defined(_X64_) || defined(_M_IX86) ||\ + defined(_M_X64) || defined(_M_IA64) ) + /* Windows system (DOS doesn't support DLLs) running on x86/x64. Includes + * builds under Cygwin or MinGW. Also includes Watcom builds but these need + * special treatment because they are not compatible with GCC or Visual C + * because of different calling conventions. + */ +# if PNG_API_RULE == 2 + /* If this line results in an error, either because __watcall is not + * understood or because of a redefine just below you cannot use *this* + * build of the library with the compiler you are using. *This* build was + * build using Watcom and applications must also be built using Watcom! + */ +# define PNGCAPI __watcall +# endif + +# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) +# define PNGCAPI __cdecl +# if PNG_API_RULE == 1 +# define PNGAPI __stdcall +# endif +# else + /* An older compiler, or one not detected (erroneously) above, + * if necessary override on the command line to get the correct + * variants for the compiler. + */ +# ifndef PNGCAPI +# define PNGCAPI _cdecl +# endif +# if PNG_API_RULE == 1 && !defined(PNGAPI) +# define PNGAPI _stdcall +# endif +# endif /* compiler/api */ + /* NOTE: PNGCBAPI always defaults to PNGCAPI. */ + +# if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD) + ERROR: PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed +# endif + +# if (defined(_MSC_VER) && _MSC_VER < 800) ||\ + (defined(__BORLANDC__) && __BORLANDC__ < 0x500) + /* older Borland and MSC + * compilers used '__export' and required this to be after + * the type. + */ +# ifndef PNG_EXPORT_TYPE +# define PNG_EXPORT_TYPE(type) type PNG_IMPEXP +# endif +# define PNG_DLL_EXPORT __export +# else /* newer compiler */ +# define PNG_DLL_EXPORT __declspec(dllexport) +# ifndef PNG_DLL_IMPORT +# define PNG_DLL_IMPORT __declspec(dllimport) +# endif +# endif /* compiler */ + +#else /* !Windows/x86 */ +# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) +# define PNGAPI _System +# else /* !Windows/x86 && !OS/2 */ + /* Use the defaults, or define PNG*API on the command line (but + * this will have to be done for every compile!) + */ +# endif /* other system, !OS/2 */ +#endif /* !Windows/x86 */ + +/* Now do all the defaulting . */ +#ifndef PNGCAPI +# define PNGCAPI +#endif +#ifndef PNGCBAPI +# define PNGCBAPI PNGCAPI +#endif +#ifndef PNGAPI +# define PNGAPI PNGCAPI +#endif + +/* PNG_IMPEXP may be set on the compilation system command line or (if not set) + * then in an internal header file when building the library, otherwise (when + * using the library) it is set here. + */ +#ifndef PNG_IMPEXP +# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT) + /* This forces use of a DLL, disallowing static linking */ +# define PNG_IMPEXP PNG_DLL_IMPORT +# endif + +# ifndef PNG_IMPEXP +# define PNG_IMPEXP +# endif +#endif + +/* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat + * 'attributes' as a storage class - the attributes go at the start of the + * function definition, and attributes are always appended regardless of the + * compiler. This considerably simplifies these macros but may cause problems + * if any compilers both need function attributes and fail to handle them as + * a storage class (this is unlikely.) + */ +#ifndef PNG_FUNCTION +# define PNG_FUNCTION(type, name, args, attributes) attributes type name args +#endif + +#ifndef PNG_EXPORT_TYPE +# define PNG_EXPORT_TYPE(type) PNG_IMPEXP type +#endif + + /* The ordinal value is only relevant when preprocessing png.h for symbol + * table entries, so we discard it here. See the .dfn files in the + * scripts directory. + */ +#ifndef PNG_EXPORTA + +# define PNG_EXPORTA(ordinal, type, name, args, attributes)\ + PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args), \ + extern attributes) +#endif + +/* ANSI-C (C90) does not permit a macro to be invoked with an empty argument, + * so make something non-empty to satisfy the requirement: + */ +#define PNG_EMPTY /*empty list*/ + +#define PNG_EXPORT(ordinal, type, name, args)\ + PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY) + +/* Use PNG_REMOVED to comment out a removed interface. */ +#ifndef PNG_REMOVED +# define PNG_REMOVED(ordinal, type, name, args, attributes) +#endif + +#ifndef PNG_CALLBACK +# define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args) +#endif + +/* Support for compiler specific function attributes. These are used + * so that where compiler support is available incorrect use of API + * functions in png.h will generate compiler warnings. + * + * Added at libpng-1.2.41. + */ + +#ifndef PNG_NO_PEDANTIC_WARNINGS +# ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED +# define PNG_PEDANTIC_WARNINGS_SUPPORTED +# endif +#endif + +#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED + /* Support for compiler specific function attributes. These are used + * so that where compiler support is available incorrect use of API + * functions in png.h will generate compiler warnings. Added at libpng + * version 1.2.41. + */ +# if defined(__GNUC__) +# ifndef PNG_USE_RESULT +# define PNG_USE_RESULT __attribute__((__warn_unused_result__)) +# endif +# ifndef PNG_NORETURN +# define PNG_NORETURN __attribute__((__noreturn__)) +# endif +# ifndef PNG_ALLOCATED +# define PNG_ALLOCATED __attribute__((__malloc__)) +# endif +# ifndef PNG_DEPRECATED +# define PNG_DEPRECATED __attribute__((__deprecated__)) +# endif +# ifndef PNG_PRIVATE +# if 0 /* Doesn't work so we use deprecated instead*/ +# define PNG_PRIVATE \ + __attribute__((warning("This function is not exported by libpng."))) +# else +# define PNG_PRIVATE \ + __attribute__((__deprecated__)) +# endif +# endif +# endif /* __GNUC__ */ + +# if defined(_MSC_VER) && (_MSC_VER >= 1300) +# ifndef PNG_USE_RESULT +# define PNG_USE_RESULT /* not supported */ +# endif +# ifndef PNG_NORETURN +# define PNG_NORETURN __declspec(noreturn) +# endif +# ifndef PNG_ALLOCATED +# if (_MSC_VER >= 1400) +# define PNG_ALLOCATED __declspec(restrict) +# endif +# endif +# ifndef PNG_DEPRECATED +# define PNG_DEPRECATED __declspec(deprecated) +# endif +# ifndef PNG_PRIVATE +# define PNG_PRIVATE __declspec(deprecated) +# endif +# endif /* _MSC_VER */ +#endif /* PNG_PEDANTIC_WARNINGS */ + +#ifndef PNG_DEPRECATED +# define PNG_DEPRECATED /* Use of this function is deprecated */ +#endif +#ifndef PNG_USE_RESULT +# define PNG_USE_RESULT /* The result of this function must be checked */ +#endif +#ifndef PNG_NORETURN +# define PNG_NORETURN /* This function does not return */ +#endif +#ifndef PNG_ALLOCATED +# define PNG_ALLOCATED /* The result of the function is new memory */ +#endif +#ifndef PNG_PRIVATE +# define PNG_PRIVATE /* This is a private libpng function */ +#endif +#ifndef PNG_FP_EXPORT /* A floating point API. */ +# ifdef PNG_FLOATING_POINT_SUPPORTED +# define PNG_FP_EXPORT(ordinal, type, name, args)\ + PNG_EXPORT(ordinal, type, name, args) +# else /* No floating point APIs */ +# define PNG_FP_EXPORT(ordinal, type, name, args) +# endif +#endif +#ifndef PNG_FIXED_EXPORT /* A fixed point API. */ +# ifdef PNG_FIXED_POINT_SUPPORTED +# define PNG_FIXED_EXPORT(ordinal, type, name, args)\ + PNG_EXPORT(ordinal, type, name, args) +# else /* No fixed point APIs */ +# define PNG_FIXED_EXPORT(ordinal, type, name, args) +# endif +#endif + +/* 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. + * + * This should not change how the APIs are called, so it can be done + * on a per-file basis in the application. + */ +#ifndef PNG_CONST +# ifndef PNG_NO_CONST +# define PNG_CONST const +# else +# define PNG_CONST +# 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. + */ + +#if defined(INT_MAX) && (INT_MAX > 0x7ffffffeL) +typedef unsigned int png_uint_32; +typedef int png_int_32; +#else +typedef unsigned long png_uint_32; +typedef long png_int_32; +#endif +typedef unsigned short png_uint_16; +typedef short png_int_16; +typedef unsigned char png_byte; + +#ifdef PNG_NO_SIZE_T +typedef unsigned int png_size_t; +#else +typedef size_t png_size_t; +#endif +#define png_sizeof(x) (sizeof (x)) + +/* The following is needed for medium model support. It cannot be in the + * pngpriv.h header. 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 /* only used in build */ +# 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 */ +#ifdef FAR +# ifdef 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., gamma + */ +typedef png_int_32 png_fixed_point; + +/* Add typedefs for pointers */ +typedef void FAR * png_voidp; +typedef PNG_CONST void FAR * png_const_voidp; +typedef png_byte FAR * png_bytep; +typedef PNG_CONST png_byte FAR * png_const_bytep; +typedef png_uint_32 FAR * png_uint_32p; +typedef PNG_CONST png_uint_32 FAR * png_const_uint_32p; +typedef png_int_32 FAR * png_int_32p; +typedef PNG_CONST png_int_32 FAR * png_const_int_32p; +typedef png_uint_16 FAR * png_uint_16p; +typedef PNG_CONST png_uint_16 FAR * png_const_uint_16p; +typedef png_int_16 FAR * png_int_16p; +typedef PNG_CONST png_int_16 FAR * png_const_int_16p; +typedef char FAR * png_charp; +typedef PNG_CONST char FAR * png_const_charp; +typedef png_fixed_point FAR * png_fixed_point_p; +typedef PNG_CONST png_fixed_point FAR * png_const_fixed_point_p; +typedef png_size_t FAR * png_size_tp; +typedef PNG_CONST png_size_t FAR * png_const_size_tp; + +#ifdef PNG_STDIO_SUPPORTED +typedef FILE * png_FILE_p; +#endif + +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double FAR * png_doublep; +typedef PNG_CONST double FAR * png_const_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; + +/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, + * and no smaller than png_uint_32. Casts from png_size_t or png_uint_32 + * to png_alloc_size_t are not necessary; in fact, it is recommended + * not to use them at all so that the compiler can complain when something + * turns out to be problematic. + * Casts in the other direction (from png_alloc_size_t to png_size_t or + * png_uint_32) should be explicitly applied; however, we do not expect + * to encounter practical situations that require such conversions. + */ +#if defined(__TURBOC__) && !defined(__FLAT__) + typedef unsigned long png_alloc_size_t; +#else +# if defined(_MSC_VER) && defined(MAXSEG_64K) + typedef unsigned long png_alloc_size_t; +# else + /* This is an attempt to detect an old Windows system where (int) is + * actually 16 bits, in that case png_malloc must have an argument with a + * bigger size to accomodate the requirements of the library. + */ +# if (defined(_Windows) || defined(_WINDOWS) || defined(_WINDOWS_)) && \ + (!defined(INT_MAX) || INT_MAX <= 0x7ffffffeL) + typedef DWORD png_alloc_size_t; +# else + typedef png_size_t png_alloc_size_t; +# endif +# endif +#endif + +#endif /* PNGCONF_H */ diff --git a/polymer/eduke32/Windows/include/pnglibconf.h b/polymer/eduke32/Windows/include/pnglibconf.h new file mode 100755 index 000000000..5e764ff81 --- /dev/null +++ b/polymer/eduke32/Windows/include/pnglibconf.h @@ -0,0 +1,180 @@ +/* pnglibconf.h - library build configuration */ + +/* libpng version 1.5.12 - July 11, 2012 */ + +/* Copyright (c) 1998-2011 Glenn Randers-Pehrson */ + +/* This code is released under the libpng license. */ +/* For conditions of distribution and use, see the disclaimer */ +/* and license in png.h */ + +/* pnglibconf.h */ +/* Machine generated file: DO NOT EDIT */ +/* Derived from: scripts/pnglibconf.dfa */ +#ifndef PNGLCONF_H +#define PNGLCONF_H +/* settings */ +#define PNG_MAX_GAMMA_8 11 +#define PNG_CALLOC_SUPPORTED +#define PNG_QUANTIZE_RED_BITS 5 +#define PNG_QUANTIZE_GREEN_BITS 5 +#define PNG_API_RULE 0 +#define PNG_QUANTIZE_BLUE_BITS 5 +#define PNG_sCAL_PRECISION 5 +#define PNG_COST_SHIFT 3 +#define PNG_WEIGHT_SHIFT 8 +#define PNG_DEFAULT_READ_MACROS 1 +#define PNG_ZBUF_SIZE 8192 +#define PNG_GAMMA_THRESHOLD_FIXED 5000 +/* end of settings */ +/* options */ +#define PNG_INFO_IMAGE_SUPPORTED 1 +/*#undef PNG_HANDLE_AS_UNKNOWN_SUPPORTED*/ +/*#undef PNG_POINTER_INDEXING_SUPPORTED*/ +/*#undef PNG_WARNINGS_SUPPORTED*/ +/*#undef PNG_FLOATING_ARITHMETIC_SUPPORTED*/ +#define PNG_WRITE_SUPPORTED 1 +/*#undef PNG_WRITE_INTERLACING_SUPPORTED*/ +/*#undef PNG_WRITE_16BIT_SUPPORTED*/ +/*#undef PNG_EASY_ACCESS_SUPPORTED*/ +/*#undef PNG_ALIGN_MEMORY_SUPPORTED*/ +/*#undef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED*/ +/*#undef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED*/ +/*#undef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED*/ +/*#undef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED*/ +#define PNG_FIXED_POINT_SUPPORTED 1 +/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/ +/*#undef PNG_ERROR_TEXT_SUPPORTED*/ +/*#undef PNG_READ_SUPPORTED*/ +/*#undef PNG_BENIGN_ERRORS_SUPPORTED*/ +#define PNG_SETJMP_SUPPORTED 1 +/*#undef PNG_TIME_RFC1123_SUPPORTED*/ +/*#undef PNG_WRITE_FLUSH_SUPPORTED*/ +/*#undef PNG_MNG_FEATURES_SUPPORTED*/ +/*#undef PNG_SAFE_LIMITS_SUPPORTED*/ +/*#undef PNG_FLOATING_POINT_SUPPORTED*/ +/*#undef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED*/ +/*#undef PNG_INCH_CONVERSIONS_SUPPORTED*/ +#define PNG_STDIO_SUPPORTED 1 +/*#undef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED*/ +#define PNG_USER_MEM_SUPPORTED 1 +/*#undef PNG_IO_STATE_SUPPORTED*/ +/*#undef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED*/ +#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED 1 +#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED 1 +/*#undef PNG_WRITE_FILTER_SUPPORTED*/ +/*#undef PNG_WRITE_zTXt_SUPPORTED*/ +/*#undef PNG_WRITE_iCCP_SUPPORTED*/ +/*#undef PNG_READ_TRANSFORMS_SUPPORTED*/ +/*#undef PNG_READ_bKGD_SUPPORTED*/ +/*#undef PNG_UNKNOWN_CHUNKS_SUPPORTED*/ +/*#undef PNG_READ_sCAL_SUPPORTED*/ +/*#undef PNG_WRITE_hIST_SUPPORTED*/ +/*#undef PNG_READ_OPT_PLTE_SUPPORTED*/ +/*#undef PNG_WRITE_gAMA_SUPPORTED*/ +/*#undef PNG_READ_GRAY_TO_RGB_SUPPORTED*/ +/*#undef PNG_WRITE_pCAL_SUPPORTED*/ +/*#undef PNG_READ_INVERT_ALPHA_SUPPORTED*/ +/*#undef PNG_WRITE_TRANSFORMS_SUPPORTED*/ +/*#undef PNG_READ_ALPHA_MODE_SUPPORTED*/ +/*#undef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED*/ +/*#undef PNG_READ_sBIT_SUPPORTED*/ +/*#undef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED*/ +/*#undef PNG_READ_PACK_SUPPORTED*/ +/*#undef PNG_WRITE_iTXt_SUPPORTED*/ +/*#undef PNG_WRITE_SWAP_SUPPORTED*/ +/*#undef PNG_READ_cHRM_SUPPORTED*/ +/*#undef PNG_READ_STRIP_16_TO_8_SUPPORTED*/ +/*#undef PNG_WRITE_tIME_SUPPORTED*/ +/*#undef PNG_READ_INTERLACING_SUPPORTED*/ +/*#undef PNG_READ_tRNS_SUPPORTED*/ +/*#undef PNG_WRITE_pHYs_SUPPORTED*/ +/*#undef PNG_WRITE_INVERT_SUPPORTED*/ +/*#undef PNG_READ_RGB_TO_GRAY_SUPPORTED*/ +/*#undef PNG_WRITE_sRGB_SUPPORTED*/ +/*#undef PNG_READ_oFFs_SUPPORTED*/ +/*#undef PNG_WRITE_FILLER_SUPPORTED*/ +/*#undef PNG_WRITE_SHIFT_SUPPORTED*/ +/*#undef PNG_PROGRESSIVE_READ_SUPPORTED*/ +/*#undef PNG_READ_SHIFT_SUPPORTED*/ +/*#undef PNG_CONVERT_tIME_SUPPORTED*/ +/*#undef PNG_READ_USER_TRANSFORM_SUPPORTED*/ +/*#undef PNG_READ_INT_FUNCTIONS_SUPPORTED*/ +/*#undef PNG_READ_USER_CHUNKS_SUPPORTED*/ +/*#undef PNG_READ_hIST_SUPPORTED*/ +/*#undef PNG_READ_16BIT_SUPPORTED*/ +/*#undef PNG_READ_SWAP_ALPHA_SUPPORTED*/ +/*#undef PNG_READ_COMPOSITE_NODIV_SUPPORTED*/ +/*#undef PNG_SEQUENTIAL_READ_SUPPORTED*/ +/*#undef PNG_READ_BACKGROUND_SUPPORTED*/ +/*#undef PNG_READ_QUANTIZE_SUPPORTED*/ +/*#undef PNG_READ_zTXt_SUPPORTED*/ +/*#undef PNG_USER_LIMITS_SUPPORTED*/ +/*#undef PNG_READ_iCCP_SUPPORTED*/ +/*#undef PNG_READ_STRIP_ALPHA_SUPPORTED*/ +/*#undef PNG_READ_PACKSWAP_SUPPORTED*/ +/*#undef PNG_READ_sRGB_SUPPORTED*/ +/*#undef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED*/ +/*#undef PNG_READ_pCAL_SUPPORTED*/ +/*#undef PNG_WRITE_sPLT_SUPPORTED*/ +/*#undef PNG_READ_iTXt_SUPPORTED*/ +/*#undef PNG_READ_SWAP_SUPPORTED*/ +/*#undef PNG_READ_tIME_SUPPORTED*/ +/*#undef PNG_READ_pHYs_SUPPORTED*/ +/*#undef PNG_WRITE_SWAP_ALPHA_SUPPORTED*/ +/*#undef PNG_READ_SCALE_16_TO_8_SUPPORTED*/ +/*#undef PNG_WRITE_BGR_SUPPORTED*/ +/*#undef PNG_USER_CHUNKS_SUPPORTED*/ +/*#undef PNG_CONSOLE_IO_SUPPORTED*/ +/*#undef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED*/ +/*#undef PNG_WRITE_PACK_SUPPORTED*/ +/*#undef PNG_READ_FILLER_SUPPORTED*/ +/*#undef PNG_WRITE_bKGD_SUPPORTED*/ +/*#undef PNG_WRITE_tRNS_SUPPORTED*/ +/*#undef PNG_READ_sPLT_SUPPORTED*/ +/*#undef PNG_WRITE_sCAL_SUPPORTED*/ +/*#undef PNG_WRITE_oFFs_SUPPORTED*/ +/*#undef PNG_SET_USER_LIMITS_SUPPORTED*/ +/*#undef PNG_WRITE_sBIT_SUPPORTED*/ +/*#undef PNG_READ_INVERT_SUPPORTED*/ +/*#undef PNG_WRITE_cHRM_SUPPORTED*/ +/*#undef PNG_16BIT_SUPPORTED*/ +/*#undef PNG_WRITE_USER_TRANSFORM_SUPPORTED*/ +/*#undef PNG_READ_BGR_SUPPORTED*/ +/*#undef PNG_WRITE_PACKSWAP_SUPPORTED*/ +/*#undef PNG_WRITE_INVERT_ALPHA_SUPPORTED*/ +/*#undef PNG_sCAL_SUPPORTED*/ +/*#undef PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED*/ +/*#undef PNG_READ_GAMMA_SUPPORTED*/ +/*#undef PNG_USER_TRANSFORM_INFO_SUPPORTED*/ +/*#undef PNG_sBIT_SUPPORTED*/ +/*#undef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED*/ +/*#undef PNG_cHRM_SUPPORTED*/ +/*#undef PNG_bKGD_SUPPORTED*/ +/*#undef PNG_tRNS_SUPPORTED*/ +/*#undef PNG_oFFs_SUPPORTED*/ +/*#undef PNG_READ_EXPAND_16_SUPPORTED*/ +/*#undef PNG_USER_TRANSFORM_PTR_SUPPORTED*/ +#define PNG_WRITE_TEXT_SUPPORTED 1 +/*#undef PNG_READ_COMPRESSED_TEXT_SUPPORTED*/ +/*#undef PNG_hIST_SUPPORTED*/ +/*#undef PNG_zTXt_SUPPORTED*/ +/*#undef PNG_iCCP_SUPPORTED*/ +/*#undef PNG_sRGB_SUPPORTED*/ +/*#undef PNG_pCAL_SUPPORTED*/ +/*#undef PNG_WRITE_tEXt_SUPPORTED*/ +/*#undef PNG_CHECK_cHRM_SUPPORTED*/ +/*#undef PNG_READ_gAMA_SUPPORTED*/ +/*#undef PNG_iTXt_SUPPORTED*/ +/*#undef PNG_tIME_SUPPORTED*/ +/*#undef PNG_READ_EXPAND_SUPPORTED*/ +/*#undef PNG_pHYs_SUPPORTED*/ +/*#undef PNG_READ_TEXT_SUPPORTED*/ +/*#undef PNG_SAVE_INT_32_SUPPORTED*/ +/*#undef PNG_sPLT_SUPPORTED*/ +/*#undef PNG_READ_tEXt_SUPPORTED*/ +/*#undef PNG_gAMA_SUPPORTED*/ +#define PNG_TEXT_SUPPORTED 1 +/*#undef PNG_tEXt_SUPPORTED*/ +/* end of options */ +#endif /* PNGLCONF_H */ diff --git a/polymer/eduke32/Windows/lib/libpng_mini.a b/polymer/eduke32/Windows/lib/libpng_mini.a new file mode 100644 index 0000000000000000000000000000000000000000..18ae1434c2d5e36bfb02c13ac7feb31f79ba9972 GIT binary patch literal 28750 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

{{fe+p%5i1zgPBuU&#BP^o6{%RW#{4c=j2B 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 JXY@qv`&R*|w&(x= literal 0 HcmV?d00001 diff --git a/polymer/eduke32/Windows/src/minipng.dfa b/polymer/eduke32/Windows/src/minipng.dfa new file mode 100755 index 000000000..a400a05f6 --- /dev/null +++ b/polymer/eduke32/Windows/src/minipng.dfa @@ -0,0 +1,55 @@ +# Minimal LibPNG for EDuke32 +# based on contrib/pngminim/encoder/pngusr.dfa of libpng +# +# Usage: from libpng source root and assuming zlib source in ../zlib, +# make -f scripts/pnglibconf.mak DFA_XTRA=./minipng.dfa CPP="gcc -E" +# make -f scripts/makefile.gcc libpng.a +# +# To clean up: +# make -f scripts/pnglibconf.mak clean +# make -f scripts/makefile.gcc clean +# +# For zlib, the following files are included in the 'mini' archive: +# crc32.o deflate.o adler32.o zutil.o trees.o + +# ========== MODIFIED ORIGINAL FILE FOLLOWS ========== + + +# pngminim/encoder/pngusr.dfa +# +# Copyright (c) 2010-2011 Glenn Randers-Pehrson +# +# This code is released under the libpng license. +# For conditions of distribution and use, see the disclaimer +# and license in png.h + +# First all the build options off: + +everything = off + +# Switch on the write code - this makes a minimalist encoder + +option WRITE on + +# You must choose fixed or floating point arithmetic: + +#option FLOATING_POINT on +option FIXED_POINT on + +# You must chose the internal fixed point implementation or to +# use the system floating point. The latter is considerably +# smaller (by about 1kbyte on an x86 system): + +#option FLOATING_ARITHMETIC on +option FLOATING_ARITHMETIC off + +# Your program will probably need other options. The example +# program here, pnm2pngm, requires the following. Take a look +# at pnglibconf.h to find out the full set of what has to be +# enabled to make the following work. + +option SETJMP on +option USER_MEM on +option WRITE_TEXT on +option STDIO on +option INFO_IMAGE on diff --git a/polymer/eduke32/build/Makefile.shared b/polymer/eduke32/build/Makefile.shared index a4fba3873..9e441fb2f 100644 --- a/polymer/eduke32/build/Makefile.shared +++ b/polymer/eduke32/build/Makefile.shared @@ -303,14 +303,18 @@ endif ifeq ($(PLATFORM),WINDOWS) ifneq ($(USE_LIBPNG),0) - LIBS+= -LWindows/lib -lpng -lz - BUILDCFLAGS+= -IWindows/include + # XXX: these assume that the compiler runs from build/. Ugh. + LIBS+= -L../Windows/lib -lpng_mini -lz_mini + BUILDCFLAGS+= -I../Windows/include endif -endif -ifeq ($(PLATFORM),DARWIN) - ifneq ($(USE_LIBPNG),0) - BUILDCFLAGS+= -I/opt/local/include -I/usr/local/include - LIBS+= -L/opt/local/lib -L/usr/local/lib -lpng -lz +else + ifeq ($(PLATFORM),DARWIN) + ifneq ($(USE_LIBPNG),0) + BUILDCFLAGS+= -I/opt/local/include -I/usr/local/include + LIBS+= -L/opt/local/lib -L/usr/local/lib -lpng -lz + endif + else + LIBS+= -lpng -lz endif endif