From ae566f0380fd70536cd81156c219ab74bf5fbe80 Mon Sep 17 00:00:00 2001 From: Jonathan Westhues Date: Wed, 18 Jun 2008 00:35:14 -0800 Subject: [PATCH] Link against libpng and zlib, and use that to export graphics; basically just a screenshot, get the image from the framebuffer. [git-p4: depot-paths = "//depot/solvespace/": change = 1797] --- Makefile | 5 +- extlib/libpng.lib | Bin 0 -> 316462 bytes extlib/png.h | 3569 +++++++++++++++++++++++++++++++++++++++++++++ extlib/pngconf.h | 1481 +++++++++++++++++++ extlib/zconf.h | 332 +++++ extlib/zlib.h | 1357 +++++++++++++++++ extlib/zlib.lib | Bin 0 -> 100642 bytes graphicswin.cpp | 2 + solvespace.cpp | 56 + solvespace.h | 4 + ui.h | 1 + wishlist.txt | 1 - 12 files changed, 6805 insertions(+), 3 deletions(-) create mode 100644 extlib/libpng.lib create mode 100644 extlib/png.h create mode 100644 extlib/pngconf.h create mode 100644 extlib/zconf.h create mode 100644 extlib/zlib.h create mode 100644 extlib/zlib.lib diff --git a/Makefile b/Makefile index c38ead23..313df303 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ DEFINES = /D_WIN32_WINNT=0x500 /DISOLATION_AWARE_ENABLED /D_WIN32_IE=0x500 /DWIN32_LEAN_AND_MEAN /DWIN32 -CFLAGS = /W3 /nologo -I..\common\win32 /D_DEBUG /D_CRT_SECURE_NO_WARNINGS /Zi /I. /EHs +CFLAGS = /W3 /nologo -Iextlib -I..\common\win32 /D_DEBUG /D_CRT_SECURE_NO_WARNINGS /I. /Zi /EHs HEADERS = ..\common\win32\freeze.h ui.h solvespace.h dsc.h sketch.h expr.h polygon.h @@ -30,7 +30,8 @@ SSOBJS = $(OBJDIR)\solvespace.obj \ $(OBJDIR)\mesh.obj \ -LIBS = user32.lib gdi32.lib comctl32.lib advapi32.lib opengl32.lib glu32.lib +LIBS = user32.lib gdi32.lib comctl32.lib advapi32.lib opengl32.lib glu32.lib \ + extlib\libpng.lib extlib\zlib.lib all: $(OBJDIR)/solvespace.exe @cp $(OBJDIR)/solvespace.exe . diff --git a/extlib/libpng.lib b/extlib/libpng.lib new file mode 100644 index 0000000000000000000000000000000000000000..c1827917fd2059de79ea78ccc9d937b806ec2b02 GIT binary patch literal 316462 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%0Dpi4g->u5xMf}&^vxU6{T^$e7+ly&sXL9 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 literal 0 HcmV?d00001 diff --git a/extlib/png.h b/extlib/png.h new file mode 100644 index 00000000..2e194b7a --- /dev/null +++ b/extlib/png.h @@ -0,0 +1,3569 @@ +/* png.h - header file for PNG reference library + * + * libpng version 1.2.29 - May 8, 2008 + * Copyright (c) 1998-2008 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * Authors and maintainers: + * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat + * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger + * libpng versions 0.97, January 1998, through 1.2.29 - May 8, 2008: 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 10.so.0.1.0.17rc1 + * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 + * 1.0.17 10 10017 10.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 10.so.0.1.0.18rc1-5 + * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 + * 1.0.18 10 10018 10.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-8 13 10210 12.so.0.10[.0] + * 1.2.10rc1-3 13 10210 12.so.0.10[.0] + * 1.2.10 13 10210 12.so.0.10[.0] + * 1.2.11beta1-4 13 10211 12.so.0.11[.0] + * 1.0.19rc1-5 10 10019 10.so.0.19[.0] + * 1.2.11rc1-5 13 10211 12.so.0.11[.0] + * 1.0.19 10 10019 10.so.0.19[.0] + * 1.2.11 13 10211 12.so.0.11[.0] + * 1.0.20 10 10020 10.so.0.20[.0] + * 1.2.12 13 10212 12.so.0.12[.0] + * 1.2.13beta1 13 10213 12.so.0.13[.0] + * 1.0.21 10 10021 10.so.0.21[.0] + * 1.2.13 13 10213 12.so.0.13[.0] + * 1.2.14beta1-2 13 10214 12.so.0.14[.0] + * 1.0.22rc1 10 10022 10.so.0.22[.0] + * 1.2.14rc1 13 10214 12.so.0.14[.0] + * 1.0.22 10 10022 10.so.0.22[.0] + * 1.2.14 13 10214 12.so.0.14[.0] + * 1.2.15beta1-6 13 10215 12.so.0.15[.0] + * 1.0.23rc1-5 10 10023 10.so.0.23[.0] + * 1.2.15rc1-5 13 10215 12.so.0.15[.0] + * 1.0.23 10 10023 10.so.0.23[.0] + * 1.2.15 13 10215 12.so.0.15[.0] + * 1.2.16beta1-2 13 10216 12.so.0.16[.0] + * 1.2.16rc1 13 10216 12.so.0.16[.0] + * 1.0.24 10 10024 10.so.0.24[.0] + * 1.2.16 13 10216 12.so.0.16[.0] + * 1.2.17beta1-2 13 10217 12.so.0.17[.0] + * 1.0.25rc1 10 10025 10.so.0.25[.0] + * 1.2.17rc1-3 13 10217 12.so.0.17[.0] + * 1.0.25 10 10025 10.so.0.25[.0] + * 1.2.17 13 10217 12.so.0.17[.0] + * 1.0.26 10 10026 10.so.0.26[.0] + * 1.2.18 13 10218 12.so.0.18[.0] + * 1.2.19beta1-31 13 10219 12.so.0.19[.0] + * 1.0.27rc1-6 10 10027 10.so.0.27[.0] + * 1.2.19rc1-6 13 10219 12.so.0.19[.0] + * 1.0.27 10 10027 10.so.0.27[.0] + * 1.2.19 13 10219 12.so.0.19[.0] + * 1.2.20beta01-04 13 10220 12.so.0.20[.0] + * 1.0.28rc1-6 10 10028 10.so.0.28[.0] + * 1.2.20rc1-6 13 10220 12.so.0.20[.0] + * 1.0.28 10 10028 10.so.0.28[.0] + * 1.2.20 13 10220 12.so.0.20[.0] + * 1.2.21beta1-2 13 10221 12.so.0.21[.0] + * 1.2.21rc1-3 13 10221 12.so.0.21[.0] + * 1.0.29 10 10029 10.so.0.29[.0] + * 1.2.21 13 10221 12.so.0.21[.0] + * 1.2.22beta1-4 13 10222 12.so.0.22[.0] + * 1.0.30rc1 10 10030 10.so.0.30[.0] + * 1.2.22rc1 13 10222 12.so.0.22[.0] + * 1.0.30 10 10030 10.so.0.30[.0] + * 1.2.22 13 10222 12.so.0.22[.0] + * 1.2.23beta01-05 13 10223 12.so.0.23[.0] + * 1.2.23rc01 13 10223 12.so.0.23[.0] + * 1.2.23 13 10223 12.so.0.23[.0] + * 1.2.24beta01-02 13 10224 12.so.0.24[.0] + * 1.2.24rc01 13 10224 12.so.0.24[.0] + * 1.2.24 13 10224 12.so.0.24[.0] + * 1.2.25beta01-06 13 10225 12.so.0.25[.0] + * 1.2.25rc01-02 13 10225 12.so.0.25[.0] + * 1.0.31 10 10031 10.so.0.31[.0] + * 1.2.25 13 10225 12.so.0.25[.0] + * 1.2.26beta01-06 13 10226 12.so.0.26[.0] + * 1.2.26rc01 13 10226 12.so.0.26[.0] + * 1.2.26 13 10226 12.so.0.26[.0] + * 1.0.32 10 10032 10.so.0.32[.0] + * 1.2.27beta01-06 13 10227 12.so.0.27[.0] + * 1.2.27rc01 13 10227 12.so.0.27[.0] + * 1.0.33 10 10033 10.so.0.33[.0] + * 1.2.27 13 10227 12.so.0.27[.0] + * 1.0.34 10 10034 10.so.0.34[.0] + * 1.2.28 13 10228 12.so.0.28[.0] + * 1.2.29beta01-03 13 10229 12.so.0.29[.0] + * 1.2.29rc01 13 10229 12.so.0.29[.0] + * 1.0.35 10 10035 10.so.0.35[.0] + * 1.2.29 13 10229 12.so.0.29[.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.txt or libpng.3 for more information. The PNG specification + * is available as a W3C Recommendation and as an ISO Specification, + * defines should NOT be changed. + */ +#define PNG_INFO_gAMA 0x0001 +#define PNG_INFO_sBIT 0x0002 +#define PNG_INFO_cHRM 0x0004 +#define PNG_INFO_PLTE 0x0008 +#define PNG_INFO_tRNS 0x0010 +#define PNG_INFO_bKGD 0x0020 +#define PNG_INFO_hIST 0x0040 +#define PNG_INFO_pHYs 0x0080 +#define PNG_INFO_oFFs 0x0100 +#define PNG_INFO_tIME 0x0200 +#define PNG_INFO_pCAL 0x0400 +#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ +#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ +#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ +#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ +#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ + +/* This is used for the transformation routines, as some of them + * change these values for the row. It also should enable using + * the routines for other purposes. + */ +typedef struct png_row_info_struct +{ + png_uint_32 width; /* width of row */ + png_uint_32 rowbytes; /* number of bytes in row */ + png_byte color_type; /* color type of row */ + png_byte bit_depth; /* bit depth of row */ + png_byte channels; /* number of channels (1, 2, 3, or 4) */ + png_byte pixel_depth; /* bits per pixel (depth * channels) */ +} png_row_info; + +typedef png_row_info FAR * png_row_infop; +typedef png_row_info FAR * FAR * png_row_infopp; + +/* These are the function types for the I/O functions and for the functions + * that allow the user to override the default I/O functions with his or her + * own. The png_error_ptr type should match that of user-supplied warning + * and error functions, while the png_rw_ptr type should match that of the + * user read/write data functions. + */ +typedef struct png_struct_def png_struct; +typedef png_struct FAR * png_structp; + +typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); +typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); +typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); +typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, + int)); +typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, + int)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); +typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); +typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, + png_uint_32, int)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, + png_row_infop, png_bytep)); +#endif + +#if defined(PNG_USER_CHUNKS_SUPPORTED) +typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); +#endif +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); +#endif + +/* Transform masks for the high-level interface */ +#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ +#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ +#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ +#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ +#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ +#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ +#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ +#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ +#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ +#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ +#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ +#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ +#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */ + +/* Flags for MNG supported features */ +#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 +#define PNG_FLAG_MNG_FILTER_64 0x04 +#define PNG_ALL_MNG_FEATURES 0x05 + +typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); +typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); + +/* The structure that holds the information to read and write PNG files. + * The only people who need to care about what is inside of this are the + * people who will be modifying the library for their own special needs. + * It should NOT be accessed directly by an application, except to store + * the jmp_buf. + */ + +struct png_struct_def +{ +#ifdef PNG_SETJMP_SUPPORTED + jmp_buf jmpbuf; /* used in png_error */ +#endif + png_error_ptr error_fn; /* function for printing errors and aborting */ + png_error_ptr warning_fn; /* function for printing warnings */ + png_voidp error_ptr; /* user supplied struct for error functions */ + png_rw_ptr write_data_fn; /* function for writing output data */ + png_rw_ptr read_data_fn; /* function for reading input data */ + png_voidp io_ptr; /* ptr to application struct for I/O functions */ + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) + png_user_transform_ptr read_user_transform_fn; /* user read transform */ +#endif + +#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) + png_user_transform_ptr write_user_transform_fn; /* user write transform */ +#endif + +/* These were added in libpng-1.0.2 */ +#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) + png_voidp user_transform_ptr; /* user supplied struct for user transform */ + png_byte user_transform_depth; /* bit depth of user transformed pixels */ + png_byte user_transform_channels; /* channels in user transformed pixels */ +#endif +#endif + + png_uint_32 mode; /* tells us where we are in the PNG file */ + png_uint_32 flags; /* flags indicating various things to libpng */ + png_uint_32 transformations; /* which transformations to perform */ + + z_stream zstream; /* pointer to decompression structure (below) */ + png_bytep zbuf; /* buffer for zlib */ + png_size_t zbuf_size; /* size of zbuf */ + int zlib_level; /* holds zlib compression level */ + int zlib_method; /* holds zlib compression method */ + int zlib_window_bits; /* holds zlib compression window bits */ + int zlib_mem_level; /* holds zlib compression memory level */ + int zlib_strategy; /* holds zlib compression strategy */ + + png_uint_32 width; /* width of image in pixels */ + png_uint_32 height; /* height of image in pixels */ + png_uint_32 num_rows; /* number of rows in current pass */ + png_uint_32 usr_width; /* width of row at start of write */ + png_uint_32 rowbytes; /* size of row in bytes */ + png_uint_32 irowbytes; /* size of current interlaced row in bytes */ + png_uint_32 iwidth; /* width of current interlaced row in pixels */ + png_uint_32 row_number; /* current row in interlace pass */ + png_bytep prev_row; /* buffer to save previous (unfiltered) row */ + png_bytep row_buf; /* buffer to save current (unfiltered) row */ +#ifndef PNG_NO_WRITE_FILTERING + png_bytep sub_row; /* buffer to save "sub" row when filtering */ + png_bytep up_row; /* buffer to save "up" row when filtering */ + png_bytep avg_row; /* buffer to save "avg" row when filtering */ + png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ +#endif + png_row_info row_info; /* used for transformation routines */ + + png_uint_32 idat_size; /* current IDAT size for read */ + png_uint_32 crc; /* current chunk CRC value */ + png_colorp palette; /* palette from the input file */ + png_uint_16 num_palette; /* number of color entries in palette */ + png_uint_16 num_trans; /* number of transparency values */ + png_byte chunk_name[5]; /* null-terminated name of current chunk */ + png_byte compression; /* file compression type (always 0) */ + png_byte filter; /* file filter type (always 0) */ + png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ + png_byte pass; /* current interlace pass (0 - 6) */ + png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ + png_byte color_type; /* color type of file */ + png_byte bit_depth; /* bit depth of file */ + png_byte usr_bit_depth; /* bit depth of users row */ + png_byte pixel_depth; /* number of bits per pixel */ + png_byte channels; /* number of channels in file */ + png_byte usr_channels; /* channels at start of write */ + png_byte sig_bytes; /* magic bytes read/written from start of file */ + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +#ifdef PNG_LEGACY_SUPPORTED + png_byte filler; /* filler byte for pixel expansion */ +#else + png_uint_16 filler; /* filler bytes for pixel expansion */ +#endif +#endif + +#if defined(PNG_bKGD_SUPPORTED) + png_byte background_gamma_type; +# ifdef PNG_FLOATING_POINT_SUPPORTED + float background_gamma; +# endif + png_color_16 background; /* background color in screen gamma space */ +#if defined(PNG_READ_GAMMA_SUPPORTED) + png_color_16 background_1; /* background normalized to gamma 1.0 */ +#endif +#endif /* PNG_bKGD_SUPPORTED */ + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) + png_flush_ptr output_flush_fn;/* Function for flushing output */ + png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ + png_uint_32 flush_rows; /* number of rows written since last flush */ +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + int gamma_shift; /* number of "insignificant" bits 16-bit gamma */ +#ifdef PNG_FLOATING_POINT_SUPPORTED + float gamma; /* file gamma value */ + float screen_gamma; /* screen gamma value (display_exponent) */ +#endif +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_bytep gamma_table; /* gamma table for 8-bit depth files */ + png_bytep gamma_from_1; /* converts from 1.0 to screen */ + png_bytep gamma_to_1; /* converts from file to 1.0 */ + png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ + png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ + png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) + png_color_8 sig_bit; /* significant bits in each available channel */ +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) + png_color_8 shift; /* shift for significant bit tranformation */ +#endif + +#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ + || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_bytep trans; /* transparency values for paletted files */ + png_color_16 trans_values; /* transparency values for non-paletted files */ +#endif + + png_read_status_ptr read_row_fn; /* called after each row is decoded */ + png_write_status_ptr write_row_fn; /* called after each row is encoded */ +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED + png_progressive_info_ptr info_fn; /* called after header data fully read */ + png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */ + png_progressive_end_ptr end_fn; /* called after image is complete */ + png_bytep save_buffer_ptr; /* current location in save_buffer */ + png_bytep save_buffer; /* buffer for previously read data */ + png_bytep current_buffer_ptr; /* current location in current_buffer */ + png_bytep current_buffer; /* buffer for recently used data */ + png_uint_32 push_length; /* size of current input chunk */ + png_uint_32 skip_length; /* bytes to skip in input data */ + png_size_t save_buffer_size; /* amount of data now in save_buffer */ + png_size_t save_buffer_max; /* total size of save_buffer */ + png_size_t buffer_size; /* total amount of available input data */ + png_size_t current_buffer_size; /* amount of data now in current_buffer */ + int process_mode; /* what push library is currently doing */ + int cur_palette; /* current push library palette index */ + +# if defined(PNG_TEXT_SUPPORTED) + png_size_t current_text_size; /* current size of text input data */ + png_size_t current_text_left; /* how much text left to read in input */ + png_charp current_text; /* current text chunk buffer */ + png_charp current_text_ptr; /* current location in current_text */ +# endif /* PNG_TEXT_SUPPORTED */ +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) +/* for the Borland special 64K segment handler */ + png_bytepp offset_table_ptr; + png_bytep offset_table; + png_uint_16 offset_table_number; + png_uint_16 offset_table_count; + png_uint_16 offset_table_count_free; +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) + png_bytep palette_lookup; /* lookup table for dithering */ + png_bytep dither_index; /* index translation for palette files */ +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) + png_uint_16p hist; /* histogram */ +#endif + +#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) + png_byte heuristic_method; /* heuristic for row filter selection */ + png_byte num_prev_filters; /* number of weights for previous rows */ + png_bytep prev_filters; /* filter type(s) of previous row(s) */ + png_uint_16p filter_weights; /* weight(s) for previous line(s) */ + png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ + png_uint_16p filter_costs; /* relative filter calculation cost */ + png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ +#endif + +#if defined(PNG_TIME_RFC1123_SUPPORTED) + png_charp time_buffer; /* String to hold RFC 1123 time text */ +#endif + +/* New members added in libpng-1.0.6 */ + +#ifdef PNG_FREE_ME_SUPPORTED + png_uint_32 free_me; /* flags items libpng is responsible for freeing */ +#endif + +#if defined(PNG_USER_CHUNKS_SUPPORTED) + png_voidp user_chunk_ptr; + png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ +#endif + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) + int num_chunk_list; + png_bytep chunk_list; +#endif + +/* New members added in libpng-1.0.3 */ +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) + png_byte rgb_to_gray_status; + /* These were changed from png_byte in libpng-1.0.6 */ + png_uint_16 rgb_to_gray_red_coeff; + png_uint_16 rgb_to_gray_green_coeff; + png_uint_16 rgb_to_gray_blue_coeff; +#endif + +/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ +#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ + defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ + defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +/* changed from png_byte to png_uint_32 at version 1.2.0 */ +#ifdef PNG_1_0_X + png_byte mng_features_permitted; +#else + png_uint_32 mng_features_permitted; +#endif /* PNG_1_0_X */ +#endif + +/* New member added in libpng-1.0.7 */ +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_fixed_point int_gamma; +#endif + +/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ +#if defined(PNG_MNG_FEATURES_SUPPORTED) + png_byte filter_type; +#endif + +#if defined(PNG_1_0_X) +/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ + png_uint_32 row_buf_size; +#endif + +/* New members added in libpng-1.2.0 */ +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +# if !defined(PNG_1_0_X) +# if defined(PNG_MMX_CODE_SUPPORTED) + png_byte mmx_bitdepth_threshold; + png_uint_32 mmx_rowbytes_threshold; +# endif + png_uint_32 asm_flags; +# endif +#endif + +/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ +#ifdef PNG_USER_MEM_SUPPORTED + png_voidp mem_ptr; /* user supplied struct for mem functions */ + png_malloc_ptr malloc_fn; /* function for allocating memory */ + png_free_ptr free_fn; /* function for freeing memory */ +#endif + +/* New member added in libpng-1.0.13 and 1.2.0 */ + png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ + +#if defined(PNG_READ_DITHER_SUPPORTED) +/* The following three members were added at version 1.0.14 and 1.2.4 */ + png_bytep dither_sort; /* working sort array */ + png_bytep index_to_palette; /* where the original index currently is */ + /* in the palette */ + png_bytep palette_to_index; /* which original index points to this */ + /* palette color */ +#endif + +/* New members added in libpng-1.0.16 and 1.2.6 */ + png_byte compression_type; + +#ifdef PNG_SET_USER_LIMITS_SUPPORTED + png_uint_32 user_width_max; + png_uint_32 user_height_max; +#endif + +/* New member added in libpng-1.0.25 and 1.2.17 */ +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) + /* storage for unknown chunk that the library doesn't recognize. */ + png_unknown_chunk unknown_chunk; +#endif + +/* New members added in libpng-1.2.26 */ + png_uint_32 old_big_row_buf_size, old_prev_row_size; +}; + + +/* This triggers a compiler error in png.c, if png.c and png.h + * do not agree upon the version number. + */ +typedef png_structp version_1_2_29; + +typedef png_struct FAR * FAR * png_structpp; + +/* Here are the function definitions most commonly used. This is not + * the place to find out how to use libpng. See libpng.txt for the + * full explanation, see example.c for the summary. This just provides + * a simple one line description of the use of each function. + */ + +/* Returns the version number of the library */ +extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); + +/* Tell lib we have already handled the first magic bytes. + * Handling more than 8 bytes from the beginning of the file is an error. + */ +extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, + int num_bytes)); + +/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a + * PNG file. Returns zero if the supplied bytes match the 8-byte PNG + * signature, and non-zero otherwise. Having num_to_check == 0 or + * start > 7 will always fail (ie return non-zero). + */ +extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, + png_size_t num_to_check)); + +/* Simple signature checking function. This is the same as calling + * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). + */ +extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); + +/* Allocate and initialize png_ptr struct for reading, and any other memory. */ +extern PNG_EXPORT(png_structp,png_create_read_struct) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn)); + +/* Allocate and initialize png_ptr struct for writing, and any other memory */ +extern PNG_EXPORT(png_structp,png_create_write_struct) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn)); + +#ifdef PNG_WRITE_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) + PNGARG((png_structp png_ptr)); +#endif + +#ifdef PNG_WRITE_SUPPORTED +extern PNG_EXPORT(void,png_set_compression_buffer_size) + PNGARG((png_structp png_ptr, png_uint_32 size)); +#endif + +/* Reset the compression stream */ +extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); + +/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ +#ifdef PNG_USER_MEM_SUPPORTED +extern PNG_EXPORT(png_structp,png_create_read_struct_2) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +extern PNG_EXPORT(png_structp,png_create_write_struct_2) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +#endif + +/* Write a PNG chunk - size, type, (optional) data, CRC. */ +extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, + png_bytep chunk_name, png_bytep data, png_size_t length)); + +/* Write the start of a PNG chunk - length and chunk name. */ +extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, + png_bytep chunk_name, png_uint_32 length)); + +/* Write the data of a PNG chunk started with png_write_chunk_start(). */ +extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); + +/* Allocate and initialize the info structure */ +extern PNG_EXPORT(png_infop,png_create_info_struct) + PNGARG((png_structp png_ptr)); + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Initialize the info structure (old interface - DEPRECATED) */ +extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)); +#undef png_info_init +#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\ + png_sizeof(png_info)); +#endif + +extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, + png_size_t png_info_struct_size)); + +/* Writes all the PNG information before the image. */ +extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr)); +extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read the information before the actual image data. */ +extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif + +#if defined(PNG_TIME_RFC1123_SUPPORTED) +extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) + PNGARG((png_structp png_ptr, png_timep ptime)); +#endif + +#if !defined(_WIN32_WCE) +/* "time.h" functions are not supported on WindowsCE */ +#if defined(PNG_WRITE_tIME_SUPPORTED) +/* convert from a struct tm to png_time */ +extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, + struct tm FAR * ttime)); + +/* convert from time_t to png_time. Uses gmtime() */ +extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, + time_t ttime)); +#endif /* PNG_WRITE_tIME_SUPPORTED */ +#endif /* _WIN32_WCE */ + +#if defined(PNG_READ_EXPAND_SUPPORTED) +/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ +extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); +#if !defined(PNG_1_0_X) +extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp + png_ptr)); +#endif +extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Deprecated */ +extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr)); +#endif +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +/* Use blue, green, red order for pixels. */ +extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +/* Expand the grayscale to 24-bit RGB if necessary. */ +extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +/* Reduce RGB to grayscale. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, + int error_action, double red, double green )); +#endif +extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, + int error_action, png_fixed_point red, png_fixed_point green )); +extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp + png_ptr)); +#endif + +extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, + png_colorp palette)); + +#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ +extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, + png_uint_32 filler, int flags)); +/* The values of the PNG_FILLER_ defines should NOT be changed */ +#define PNG_FILLER_BEFORE 0 +#define PNG_FILLER_AFTER 1 +/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ +#if !defined(PNG_1_0_X) +extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr, + png_uint_32 filler, int flags)); +#endif +#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +/* Swap bytes in 16-bit depth files. */ +extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) +/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ +extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +/* Swap packing order of pixels in bytes. */ +extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +/* Converts files to legal bit depths. */ +extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, + png_color_8p true_bits)); +#endif + +#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ + defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* Have the code handle the interlacing. Returns the number of passes. */ +extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +/* Invert monochrome files */ +extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_BACKGROUND_SUPPORTED) +/* Handle alpha and tRNS by replacing with a background color. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, + png_color_16p background_color, int background_gamma_code, + int need_expand, double background_gamma)); +#endif +#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +#define PNG_BACKGROUND_GAMMA_SCREEN 1 +#define PNG_BACKGROUND_GAMMA_FILE 2 +#define PNG_BACKGROUND_GAMMA_UNIQUE 3 +#endif + +#if defined(PNG_READ_16_TO_8_SUPPORTED) +/* strip the second byte of information from a 16-bit depth file. */ +extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) +/* Turn on dithering, and reduce the palette to the number of colors available. */ +extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, + png_colorp palette, int num_palette, int maximum_colors, + png_uint_16p histogram, int full_dither)); +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) +/* Handle gamma correction. Screen_gamma=(display_exponent) */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, + double screen_gamma, double default_file_gamma)); +#endif +#endif + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ + defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ +/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ +extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, + int empty_plte_permitted)); +#endif +#endif + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +/* Set how many lines between output flushes - 0 for no flushing */ +extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); +/* Flush the current PNG output buffer */ +extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); +#endif + +/* optional update palette with requested transformations */ +extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); + +/* optional call to update the users info structure */ +extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read one or more rows of image data. */ +extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, + png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); +#endif + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read a row of data. */ +extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, + png_bytep row, + png_bytep display_row)); +#endif + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read the whole image into memory at once. */ +extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, + png_bytepp image)); +#endif + +/* write a row of image data */ +extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, + png_bytep row)); + +/* write a few rows of image data */ +extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, + png_bytepp row, png_uint_32 num_rows)); + +/* write the image data */ +extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, + png_bytepp image)); + +/* writes the end of the PNG file. */ +extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read the end of the PNG file. */ +extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif + +/* free any memory associated with the png_info_struct */ +extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, + png_infopp info_ptr_ptr)); + +/* free any memory associated with the png_struct and the png_info_structs */ +extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp + png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); + +/* free all memory used by the read (old method - NOT DLL EXPORTED) */ +extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, + png_infop end_info_ptr)); + +/* free any memory associated with the png_struct and the png_info_structs */ +extern PNG_EXPORT(void,png_destroy_write_struct) + PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); + +/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ +extern void png_write_destroy PNGARG((png_structp png_ptr)); + +/* set the libpng method of handling chunk CRC errors */ +extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, + int crit_action, int ancil_action)); + +/* Values for png_set_crc_action() to say how to handle CRC errors in + * ancillary and critical chunks, and whether to use the data contained + * therein. Note that it is impossible to "discard" data in a critical + * chunk. For versions prior to 0.90, the action was always error/quit, + * whereas in version 0.90 and later, the action for CRC errors in ancillary + * chunks is warn/discard. These values should NOT be changed. + * + * value action:critical action:ancillary + */ +#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ +#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ +#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ +#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ +#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ +#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ + +/* These functions give the user control over the scan-line filtering in + * libpng and the compression methods used by zlib. These functions are + * mainly useful for testing, as the defaults should work with most users. + * Those users who are tight on memory or want faster performance at the + * expense of compression can modify them. See the compression library + * header file (zlib.h) for an explination of the compression functions. + */ + +/* set the filtering method(s) used by libpng. Currently, the only valid + * value for "method" is 0. + */ +extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, + int filters)); + +/* Flags for png_set_filter() to say which filters to use. The flags + * are chosen so that they don't conflict with real filter types + * below, in case they are supplied instead of the #defined constants. + * These values should NOT be changed. + */ +#define PNG_NO_FILTERS 0x00 +#define PNG_FILTER_NONE 0x08 +#define PNG_FILTER_SUB 0x10 +#define PNG_FILTER_UP 0x20 +#define PNG_FILTER_AVG 0x40 +#define PNG_FILTER_PAETH 0x80 +#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ + PNG_FILTER_AVG | PNG_FILTER_PAETH) + +/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. + * These defines should NOT be changed. + */ +#define PNG_FILTER_VALUE_NONE 0 +#define PNG_FILTER_VALUE_SUB 1 +#define PNG_FILTER_VALUE_UP 2 +#define PNG_FILTER_VALUE_AVG 3 +#define PNG_FILTER_VALUE_PAETH 4 +#define PNG_FILTER_VALUE_LAST 5 + +#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ +/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ + * defines, either the default (minimum-sum-of-absolute-differences), or + * the experimental method (weighted-minimum-sum-of-absolute-differences). + * + * Weights are factors >= 1.0, indicating how important it is to keep the + * filter type consistent between rows. Larger numbers mean the current + * filter is that many times as likely to be the same as the "num_weights" + * previous filters. This is cumulative for each previous row with a weight. + * There needs to be "num_weights" values in "filter_weights", or it can be + * NULL if the weights aren't being specified. Weights have no influence on + * the selection of the first row filter. Well chosen weights can (in theory) + * improve the compression for a given image. + * + * Costs are factors >= 1.0 indicating the relative decoding costs of a + * filter type. Higher costs indicate more decoding expense, and are + * therefore less likely to be selected over a filter with lower computational + * costs. There needs to be a value in "filter_costs" for each valid filter + * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't + * setting the costs. Costs try to improve the speed of decompression without + * unduly increasing the compressed image size. + * + * A negative weight or cost indicates the default value is to be used, and + * values in the range [0.0, 1.0) indicate the value is to remain unchanged. + * The default values for both weights and costs are currently 1.0, but may + * change if good general weighting/cost heuristics can be found. If both + * the weights and costs are set to 1.0, this degenerates the WEIGHTED method + * to the UNWEIGHTED method, but with added encoding time/computation. + */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, + int heuristic_method, int num_weights, png_doublep filter_weights, + png_doublep filter_costs)); +#endif +#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ + +/* Heuristic used for row filter selection. These defines should NOT be + * changed. + */ +#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ +#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ +#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ +#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ + +/* Set the library compression level. Currently, valid values range from + * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 + * (0 - no compression, 9 - "maximal" compression). Note that tests have + * shown that zlib compression levels 3-6 usually perform as well as level 9 + * for PNG images, and do considerably fewer caclulations. In the future, + * these values may not correspond directly to the zlib compression levels. + */ +extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, + int level)); + +extern PNG_EXPORT(void,png_set_compression_mem_level) + PNGARG((png_structp png_ptr, int mem_level)); + +extern PNG_EXPORT(void,png_set_compression_strategy) + PNGARG((png_structp png_ptr, int strategy)); + +extern PNG_EXPORT(void,png_set_compression_window_bits) + PNGARG((png_structp png_ptr, int window_bits)); + +extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, + int method)); + +/* These next functions are called for input/output, memory, and error + * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, + * and call standard C I/O routines such as fread(), fwrite(), and + * fprintf(). These functions can be made to use other I/O routines + * at run time for those applications that need to handle I/O in a + * different manner by calling png_set_???_fn(). See libpng.txt for + * more information. + */ + +#if !defined(PNG_NO_STDIO) +/* Initialize the input/output for the PNG file to the default functions. */ +extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); +#endif + +/* Replace the (error and abort), and warning functions with user + * supplied functions. If no messages are to be printed you must still + * write and use replacement functions. The replacement error_fn should + * still do a longjmp to the last setjmp location if you are using this + * method of error handling. If error_fn or warning_fn is NULL, the + * default function will be used. + */ + +extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, + png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); + +/* Return the user pointer associated with the error functions */ +extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); + +/* Replace the default data output functions with a user supplied one(s). + * If buffered output is not used, then output_flush_fn can be set to NULL. + * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time + * output_flush_fn will be ignored (and thus can be NULL). + */ +extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, + png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); + +/* Replace the default data input function with a user supplied one. */ +extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, + png_voidp io_ptr, png_rw_ptr read_data_fn)); + +/* Return the user pointer associated with the I/O functions */ +extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); + +extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, + png_read_status_ptr read_row_fn)); + +extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, + png_write_status_ptr write_row_fn)); + +#ifdef PNG_USER_MEM_SUPPORTED +/* Replace the default memory allocation functions with user supplied one(s). */ +extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +/* Return the user pointer associated with the memory functions */ +extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp + png_ptr, png_user_transform_ptr read_user_transform_fn)); +#endif + +#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp + png_ptr, png_user_transform_ptr write_user_transform_fn)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp + png_ptr, png_voidp user_transform_ptr, int user_transform_depth, + int user_transform_channels)); +/* Return the user pointer associated with the user transform functions */ +extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) + PNGARG((png_structp png_ptr)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, + png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp + png_ptr)); +#endif + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +/* Sets the function callbacks for the push reader, and a pointer to a + * user-defined structure available to the callback functions. + */ +extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, + png_voidp progressive_ptr, + png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, + png_progressive_end_ptr end_fn)); + +/* returns the user pointer associated with the push read functions */ +extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) + PNGARG((png_structp png_ptr)); + +/* function to be called when data becomes available */ +extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); + +/* function that combines rows. Not very much different than the + * png_combine_row() call. Is this even used????? + */ +extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, + png_bytep old_row, png_bytep new_row)); +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, + png_uint_32 size)); + +#if defined(PNG_1_0_X) +# define png_malloc_warn png_malloc +#else +/* Added at libpng version 1.2.4 */ +extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, + png_uint_32 size)); +#endif + +/* frees a pointer allocated by png_malloc() */ +extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); + +#if defined(PNG_1_0_X) +/* Function to allocate memory for zlib. */ +extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, + uInt size)); + +/* Function to free memory for zlib */ +extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); +#endif + +/* Free data that was allocated internally */ +extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 free_me, int num)); +#ifdef PNG_FREE_ME_SUPPORTED +/* Reassign responsibility for freeing existing data, whether allocated + * by libpng or by the application */ +extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, + png_infop info_ptr, int freer, png_uint_32 mask)); +#endif +/* assignments for png_data_freer */ +#define PNG_DESTROY_WILL_FREE_DATA 1 +#define PNG_SET_WILL_FREE_DATA 1 +#define PNG_USER_WILL_FREE_DATA 2 +/* Flags for png_ptr->free_me and info_ptr->free_me */ +#define PNG_FREE_HIST 0x0008 +#define PNG_FREE_ICCP 0x0010 +#define PNG_FREE_SPLT 0x0020 +#define PNG_FREE_ROWS 0x0040 +#define PNG_FREE_PCAL 0x0080 +#define PNG_FREE_SCAL 0x0100 +#define PNG_FREE_UNKN 0x0200 +#define PNG_FREE_LIST 0x0400 +#define PNG_FREE_PLTE 0x1000 +#define PNG_FREE_TRNS 0x2000 +#define PNG_FREE_TEXT 0x4000 +#define PNG_FREE_ALL 0x7fff +#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ + +#ifdef PNG_USER_MEM_SUPPORTED +extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, + png_uint_32 size)); +extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, + png_voidp ptr)); +#endif + +extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, + png_voidp s1, png_voidp s2, png_uint_32 size)); + +extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, + png_voidp s1, int value, png_uint_32 size)); + +#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ +extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, + int check)); +#endif /* USE_FAR_KEYWORD */ + +#ifndef PNG_NO_ERROR_TEXT +/* Fatal error in PNG image of libpng - can't continue */ +extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, + png_const_charp error_message)); + +/* The same, but the chunk name is prepended to the error string. */ +extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, + png_const_charp error_message)); +#else +/* Fatal error in PNG image of libpng - can't continue */ +extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr)); +#endif + +#ifndef PNG_NO_WARNINGS +/* Non-fatal error in libpng. Can continue, but may have a problem. */ +extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, + png_const_charp warning_message)); + +#ifdef PNG_READ_SUPPORTED +/* Non-fatal error in libpng, chunk name is prepended to message. */ +extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, + png_const_charp warning_message)); +#endif /* PNG_READ_SUPPORTED */ +#endif /* PNG_NO_WARNINGS */ + +/* The png_set_ functions are for storing values in the png_info_struct. + * Similarly, the png_get_ calls are used to read values from the + * png_info_struct, either storing the parameters in the passed variables, or + * setting pointers into the png_info_struct where the data is stored. The + * png_get_ functions return a non-zero value if the data was available + * in info_ptr, or return zero and do not change any of the parameters if the + * data was not available. + * + * These functions should be used instead of directly accessing png_info + * to avoid problems with future changes in the size and internal layout of + * png_info_struct. + */ +/* Returns "flag" if chunk data is valid in info_ptr. */ +extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, +png_infop info_ptr, png_uint_32 flag)); + +/* Returns number of bytes needed to hold a transformed row. */ +extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_INFO_IMAGE_SUPPORTED) +/* Returns row_pointers, which is an array of pointers to scanlines that was +returned from png_read_png(). */ +extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, +png_infop info_ptr)); +/* Set row_pointers, which is an array of pointers to scanlines for use +by png_write_png(). */ +extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytepp row_pointers)); +#endif + +/* Returns number of color channels in image. */ +extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#ifdef PNG_EASY_ACCESS_SUPPORTED +/* Returns image width in pixels. */ +extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image height in pixels. */ +extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image bit_depth. */ +extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image color_type. */ +extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image filter_type. */ +extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image interlace_type. */ +extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image compression_type. */ +extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image resolution in pixels per meter, from pHYs chunk data. */ +extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns pixel aspect ratio, computed from pHYs chunk data. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +#endif + +/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +#endif /* PNG_EASY_ACCESS_SUPPORTED */ + +/* Returns pointer to signature string read from PNG header */ +extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_bKGD_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_16p *background)); +#endif + +#if defined(PNG_bKGD_SUPPORTED) +extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_16p background)); +#endif + +#if defined(PNG_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, double *white_x, double *white_y, double *red_x, + double *red_y, double *green_x, double *green_y, double *blue_x, + double *blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point + *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, + png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point + *int_blue_x, png_fixed_point *int_blue_y)); +#endif +#endif + +#if defined(PNG_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, double white_x, double white_y, double red_x, + double red_y, double green_x, double green_y, double blue_x, double blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, + png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point + int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +#endif +#endif + +#if defined(PNG_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, + png_infop info_ptr, double *file_gamma)); +#endif +extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point *int_file_gamma)); +#endif + +#if defined(PNG_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, + png_infop info_ptr, double file_gamma)); +#endif +extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_file_gamma)); +#endif + +#if defined(PNG_hIST_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_16p *hist)); +#endif + +#if defined(PNG_hIST_SUPPORTED) +extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_16p hist)); +#endif + +extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, + int *bit_depth, int *color_type, int *interlace_method, + int *compression_method, int *filter_method)); + +extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, + int color_type, int interlace_method, int compression_method, + int filter_method)); + +#if defined(PNG_oFFs_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, + int *unit_type)); +#endif + +#if defined(PNG_oFFs_SUPPORTED) +extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, + int unit_type)); +#endif + +#if defined(PNG_pCAL_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, + int *type, int *nparams, png_charp *units, png_charpp *params)); +#endif + +#if defined(PNG_pCAL_SUPPORTED) +extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, + int type, int nparams, png_charp units, png_charpp params)); +#endif + +#if defined(PNG_pHYs_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +#endif + +#if defined(PNG_pHYs_SUPPORTED) +extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +#endif + +extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_colorp *palette, int *num_palette)); + +extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_colorp palette, int num_palette)); + +#if defined(PNG_sBIT_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_8p *sig_bit)); +#endif + +#if defined(PNG_sBIT_SUPPORTED) +extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_8p sig_bit)); +#endif + +#if defined(PNG_sRGB_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *intent)); +#endif + +#if defined(PNG_sRGB_SUPPORTED) +extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, + png_infop info_ptr, int intent)); +extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, int intent)); +#endif + +#if defined(PNG_iCCP_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charpp name, int *compression_type, + png_charpp profile, png_uint_32 *proflen)); + /* Note to maintainer: profile should be png_bytepp */ +#endif + +#if defined(PNG_iCCP_SUPPORTED) +extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp name, int compression_type, + png_charp profile, png_uint_32 proflen)); + /* Note to maintainer: profile should be png_bytep */ +#endif + +#if defined(PNG_sPLT_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_sPLT_tpp entries)); +#endif + +#if defined(PNG_sPLT_SUPPORTED) +extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_sPLT_tp entries, int nentries)); +#endif + +#if defined(PNG_TEXT_SUPPORTED) +/* png_get_text also returns the number of text chunks in *num_text */ +extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp *text_ptr, int *num_text)); +#endif + +/* + * Note while png_set_text() will accept a structure whose text, + * language, and translated keywords are NULL pointers, the structure + * returned by png_get_text will always contain regular + * zero-terminated C strings. They might be empty strings but + * they will never be NULL pointers. + */ + +#if defined(PNG_TEXT_SUPPORTED) +extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp text_ptr, int num_text)); +#endif + +#if defined(PNG_tIME_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_timep *mod_time)); +#endif + +#if defined(PNG_tIME_SUPPORTED) +extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_timep mod_time)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep *trans, int *num_trans, + png_color_16p *trans_values)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep trans, int num_trans, + png_color_16p trans_values)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +#endif + +#if defined(PNG_sCAL_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *unit, double *width, double *height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); +#endif +#endif +#endif /* PNG_sCAL_SUPPORTED */ + +#if defined(PNG_sCAL_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, int unit, double width, double height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, + png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); +#endif +#endif +#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +/* provide a list of chunks and how they are to be handled, if the built-in + handling or default unknown chunk handling is not desired. Any chunks not + listed will be handled in the default manner. The IHDR and IEND chunks + must not be listed. + keep = 0: follow default behaviour + = 1: do not keep + = 2: keep only if safe-to-copy + = 3: keep even if unsafe-to-copy +*/ +extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp + png_ptr, int keep, png_bytep chunk_list, int num_chunks)); +extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); +extern PNG_EXPORT(void, png_set_unknown_chunk_location) + PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); +extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp + png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); +#endif +#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep + chunk_name)); +#endif + +/* Png_free_data() will turn off the "valid" flag for anything it frees. + If you need to turn it off for a chunk that your application has freed, + you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */ +extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, + png_infop info_ptr, int mask)); + +#if defined(PNG_INFO_IMAGE_SUPPORTED) +/* The "params" pointer is currently not used and is for future expansion. */ +extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, + png_infop info_ptr, + int transforms, + png_voidp params)); +extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, + png_infop info_ptr, + int transforms, + png_voidp params)); +#endif + +/* Define PNG_DEBUG at compile time for debugging information. Higher + * numbers for PNG_DEBUG mean more debugging information. This has + * only been added since version 0.95 so it is not implemented throughout + * libpng yet, but more support will be added as needed. + */ +#ifdef PNG_DEBUG +#if (PNG_DEBUG > 0) +#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) +#include +#if (PNG_DEBUG > 1) +#define png_debug(l,m) _RPT0(_CRT_WARN,m) +#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1) +#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2) +#endif +#else /* PNG_DEBUG_FILE || !_MSC_VER */ +#ifndef PNG_DEBUG_FILE +#define PNG_DEBUG_FILE stderr +#endif /* PNG_DEBUG_FILE */ +#if (PNG_DEBUG > 1) +#define png_debug(l,m) \ +{ \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ +} +#define png_debug1(l,m,p1) \ +{ \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ +} +#define png_debug2(l,m,p1,p2) \ +{ \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ +} +#endif /* (PNG_DEBUG > 1) */ +#endif /* _MSC_VER */ +#endif /* (PNG_DEBUG > 0) */ +#endif /* PNG_DEBUG */ +#ifndef png_debug +#define png_debug(l, m) +#endif +#ifndef png_debug1 +#define png_debug1(l, m, p1) +#endif +#ifndef png_debug2 +#define png_debug2(l, m, p1, p2) +#endif + +extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); + +#ifdef PNG_MNG_FEATURES_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp + png_ptr, png_uint_32 mng_features_permitted)); +#endif + +/* 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 + +/* Added to version 1.2.0 */ +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +#if defined(PNG_MMX_CODE_SUPPORTED) +#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ +#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ +#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 +#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 +#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 +#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 +#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 +#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 +#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ + +#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ + | PNG_ASM_FLAG_MMX_READ_INTERLACE \ + | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ + | PNG_ASM_FLAG_MMX_READ_FILTER_UP \ + | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ + | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) +#define PNG_MMX_WRITE_FLAGS ( 0 ) + +#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ + | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ + | PNG_MMX_READ_FLAGS \ + | PNG_MMX_WRITE_FLAGS ) + +#define PNG_SELECT_READ 1 +#define PNG_SELECT_WRITE 2 +#endif /* PNG_MMX_CODE_SUPPORTED */ + +#if !defined(PNG_1_0_X) +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) + PNGARG((int flag_select, int *compilerID)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) + PNGARG((int flag_select)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_asm_flags) + PNGARG((png_structp png_ptr)); + +/* pngget.c */ +extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) + PNGARG((png_structp png_ptr)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) + PNGARG((png_structp png_ptr)); + +/* pngset.c */ +extern PNG_EXPORT(void,png_set_asm_flags) + PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); + +/* pngset.c */ +extern PNG_EXPORT(void,png_set_mmx_thresholds) + PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, + png_uint_32 mmx_rowbytes_threshold)); + +#endif /* PNG_1_0_X */ + +#if !defined(PNG_1_0_X) +/* png.c, pnggccrd.c, or pngvcrd.c */ +extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); +#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ + +/* Strip the prepended error numbers ("#nnn ") from error and warning + * messages before passing them to the error or warning handler. */ +#ifdef PNG_ERROR_NUMBERS_SUPPORTED +extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp + png_ptr, png_uint_32 strip_mode)); +#endif + +#endif /* PNG_1_0_X */ + +/* Added at libpng-1.2.6 */ +#ifdef PNG_SET_USER_LIMITS_SUPPORTED +extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp + png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max)); +extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp + png_ptr)); +extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp + png_ptr)); +#endif + +/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */ + +#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED +/* With these routines we avoid an integer divide, which will be slower on + * most machines. However, it does take more operations than the corresponding + * divide method, so it may be slower on a few RISC systems. There are two + * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. + * + * Note that the rounding factors are NOT supposed to be the same! 128 and + * 32768 are correct for the NODIV code; 127 and 32767 are correct for the + * standard method. + * + * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] + */ + + /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ + +# define png_composite(composite, fg, alpha, bg) \ + { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ + + (png_uint_16)(bg)*(png_uint_16)(255 - \ + (png_uint_16)(alpha)) + (png_uint_16)128); \ + (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } + +# define png_composite_16(composite, fg, alpha, bg) \ + { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ + + (png_uint_32)(bg)*(png_uint_32)(65535L - \ + (png_uint_32)(alpha)) + (png_uint_32)32768L); \ + (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } + +#else /* standard method using integer division */ + +# define png_composite(composite, fg, alpha, bg) \ + (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ + (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ + (png_uint_16)127) / 255) + +# define png_composite_16(composite, fg, alpha, bg) \ + (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ + (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ + (png_uint_32)32767) / (png_uint_32)65535L) + +#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ + +/* Inline macros to do direct reads of bytes from the input buffer. These + * require that you are using an architecture that uses PNG byte ordering + * (MSB first) and supports unaligned data storage. I think that PowerPC + * in big-endian mode and 680x0 are the only ones that will support this. + * The x86 line of processors definitely do not. The png_get_int_32() + * routine also assumes we are using two's complement format for negative + * values, which is almost certainly true. + */ +#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED) +# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) +# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) +# define png_get_int_32(buf) ( *((png_int_32p) (buf))) +#else +extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf)); +extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf)); +extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf)); +#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ +extern PNG_EXPORT(png_uint_32,png_get_uint_31) + PNGARG((png_structp png_ptr, png_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). + */ +extern PNG_EXPORT(void,png_save_uint_32) + PNGARG((png_bytep buf, png_uint_32 i)); +extern PNG_EXPORT(void,png_save_int_32) + PNGARG((png_bytep buf, png_int_32 i)); + +/* 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. + */ +extern PNG_EXPORT(void,png_save_uint_16) + PNGARG((png_bytep buf, unsigned int i)); +/* No png_save_int_16 -- may be added if there's a real need for it. */ + +/* ************************************************************************* */ + +/* These next functions are used internally in the code. They generally + * shouldn't be used unless you are writing code to add or replace some + * functionality in libpng. More information about most functions can + * be found in the files where the functions are located. + */ + + +/* Various modes of operation, that are visible to applications because + * they are used for unknown chunk location. + */ +#define PNG_HAVE_IHDR 0x01 +#define PNG_HAVE_PLTE 0x02 +#define PNG_HAVE_IDAT 0x04 +#define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */ +#define PNG_HAVE_IEND 0x10 + +#if defined(PNG_INTERNAL) + +/* More modes of operation. Note that after an init, mode is set to + * zero automatically when the structure is created. + */ +#define PNG_HAVE_gAMA 0x20 +#define PNG_HAVE_cHRM 0x40 +#define PNG_HAVE_sRGB 0x80 +#define PNG_HAVE_CHUNK_HEADER 0x100 +#define PNG_WROTE_tIME 0x200 +#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 +#define PNG_BACKGROUND_IS_GRAY 0x800 +#define PNG_HAVE_PNG_SIGNATURE 0x1000 +#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */ + +/* flags for the transformations the PNG library does on the image data */ +#define PNG_BGR 0x0001 +#define PNG_INTERLACE 0x0002 +#define PNG_PACK 0x0004 +#define PNG_SHIFT 0x0008 +#define PNG_SWAP_BYTES 0x0010 +#define PNG_INVERT_MONO 0x0020 +#define PNG_DITHER 0x0040 +#define PNG_BACKGROUND 0x0080 +#define PNG_BACKGROUND_EXPAND 0x0100 + /* 0x0200 unused */ +#define PNG_16_TO_8 0x0400 +#define PNG_RGBA 0x0800 +#define PNG_EXPAND 0x1000 +#define PNG_GAMMA 0x2000 +#define PNG_GRAY_TO_RGB 0x4000 +#define PNG_FILLER 0x8000L +#define PNG_PACKSWAP 0x10000L +#define PNG_SWAP_ALPHA 0x20000L +#define PNG_STRIP_ALPHA 0x40000L +#define PNG_INVERT_ALPHA 0x80000L +#define PNG_USER_TRANSFORM 0x100000L +#define PNG_RGB_TO_GRAY_ERR 0x200000L +#define PNG_RGB_TO_GRAY_WARN 0x400000L +#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ + /* 0x800000L Unused */ +#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */ +#define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */ + /* 0x4000000L unused */ + /* 0x8000000L unused */ + /* 0x10000000L unused */ + /* 0x20000000L unused */ + /* 0x40000000L unused */ + +/* flags for png_create_struct */ +#define PNG_STRUCT_PNG 0x0001 +#define PNG_STRUCT_INFO 0x0002 + +/* Scaling factor for filter heuristic weighting calculations */ +#define PNG_WEIGHT_SHIFT 8 +#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) +#define PNG_COST_SHIFT 3 +#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) + +/* flags for the png_ptr->flags rather than declaring a byte for each one */ +#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 +#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 +#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 +#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 +#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 +#define PNG_FLAG_ZLIB_FINISHED 0x0020 +#define PNG_FLAG_ROW_INIT 0x0040 +#define PNG_FLAG_FILLER_AFTER 0x0080 +#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 +#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 +#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 +#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 +#define PNG_FLAG_FREE_PLTE 0x1000 +#define PNG_FLAG_FREE_TRNS 0x2000 +#define PNG_FLAG_FREE_HIST 0x4000 +#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L +#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L +#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L +#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L +#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L +#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L +#define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */ +#define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */ + /* 0x800000L unused */ + /* 0x1000000L unused */ + /* 0x2000000L unused */ + /* 0x4000000L unused */ + /* 0x8000000L unused */ + /* 0x10000000L unused */ + /* 0x20000000L unused */ + /* 0x40000000L unused */ + +#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ + PNG_FLAG_CRC_ANCILLARY_NOWARN) + +#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ + PNG_FLAG_CRC_CRITICAL_IGNORE) + +#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ + PNG_FLAG_CRC_CRITICAL_MASK) + +/* save typing and make code easier to understand */ + +#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ + abs((int)((c1).green) - (int)((c2).green)) + \ + abs((int)((c1).blue) - (int)((c2).blue))) + +/* Added to libpng-1.2.6 JB */ +#define PNG_ROWBYTES(pixel_bits, width) \ + ((pixel_bits) >= 8 ? \ + ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \ + (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) ) + +/* PNG_OUT_OF_RANGE returns true if value is outside the range + ideal-delta..ideal+delta. Each argument is evaluated twice. + "ideal" and "delta" should be constants, normally simple + integers, "value" a variable. Added to libpng-1.2.6 JB */ +#define PNG_OUT_OF_RANGE(value, ideal, delta) \ + ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) + +/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ +#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) +/* place to hold the signature string for a PNG file. */ +#ifdef PNG_USE_GLOBAL_ARRAYS + PNG_EXPORT_VAR (PNG_CONST png_byte FARDATA) png_sig[8]; +#else +#endif +#endif /* PNG_NO_EXTERN */ + +/* Constant strings for known chunk types. If you need to add a chunk, + * define the name here, and add an invocation of the macro in png.c and + * wherever it's needed. + */ +#define PNG_IHDR png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} +#define PNG_IDAT png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} +#define PNG_IEND png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} +#define PNG_PLTE png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} +#define PNG_bKGD png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} +#define PNG_cHRM png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} +#define PNG_gAMA png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} +#define PNG_hIST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} +#define PNG_iCCP png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} +#define PNG_iTXt png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} +#define PNG_oFFs png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} +#define PNG_pCAL png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} +#define PNG_sCAL png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} +#define PNG_pHYs png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} +#define PNG_sBIT png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} +#define PNG_sPLT png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} +#define PNG_sRGB png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} +#define PNG_tEXt png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} +#define PNG_tIME png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} +#define PNG_tRNS png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} +#define PNG_zTXt png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} + +#ifdef PNG_USE_GLOBAL_ARRAYS +PNG_EXPORT_VAR (png_byte FARDATA) png_IHDR[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_IDAT[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_IEND[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_PLTE[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_bKGD[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_cHRM[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_gAMA[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_hIST[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_iCCP[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_iTXt[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_oFFs[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_pCAL[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_sCAL[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_pHYs[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_sBIT[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_sPLT[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_sRGB[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_tEXt[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_tIME[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_tRNS[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_zTXt[5]; +#endif /* PNG_USE_GLOBAL_ARRAYS */ + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Initialize png_ptr struct for reading, and allocate any other memory. + * (old interface - DEPRECATED - use png_create_read_struct instead). + */ +extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)); +#undef png_read_init +#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ + PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); +#endif + +extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size)); +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t + png_info_size)); +#endif + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Initialize png_ptr struct for writing, and allocate any other memory. + * (old interface - DEPRECATED - use png_create_write_struct instead). + */ +extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)); +#undef png_write_init +#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ + PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); +#endif + +extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size)); +extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t + png_info_size)); + +/* Allocate memory for an internal libpng struct */ +PNG_EXTERN png_voidp png_create_struct PNGARG((int type)); + +/* Free memory from internal libpng struct */ +PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); + +PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr + malloc_fn, png_voidp mem_ptr)); +PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, + png_free_ptr free_fn, png_voidp mem_ptr)); + +/* Free any memory that info_ptr points to and reset struct. */ +PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_1_0_X +/* Function to allocate memory for zlib. */ +PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size)); + +/* Function to free memory for zlib */ +PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); + +#ifdef PNG_SIZE_T +/* Function to convert a sizeof an item to png_sizeof item */ + PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); +#endif + +/* Next four functions are used internally as callbacks. PNGAPI is required + * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */ + +PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t length)); +#endif + +PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +#if !defined(PNG_NO_STDIO) +PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)); +#endif +#endif +#else /* PNG_1_0_X */ +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t length)); +#endif +#endif /* PNG_1_0_X */ + +/* Reset the CRC variable */ +PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); + +/* Write the "data" buffer to whatever output you are using. */ +PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +/* Read data from whatever input you are using into the "data" buffer */ +PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +/* Read bytes into buf, and update png_ptr->crc */ +PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, + png_size_t length)); + +/* Decompress data in a chunk that uses compression */ +#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ + defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) +PNG_EXTERN png_charp png_decompress_chunk PNGARG((png_structp png_ptr, + int comp_type, png_charp chunkdata, png_size_t chunklength, + png_size_t prefix_length, png_size_t *data_length)); +#endif + +/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ +PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); + +/* Read the CRC from the file and compare it to the libpng calculated CRC */ +PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); + +/* Calculate the CRC over a section of data. Note that we are only + * passing a maximum of 64K on systems that have this as a memory limit, + * since this is the maximum buffer size we can specify. + */ +PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, + png_size_t length)); + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); +#endif + +/* simple function to write the signature */ +PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)); + +/* write various chunks */ + +/* Write the IHDR chunk, and update the png_struct with the necessary + * information. + */ +PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, + png_uint_32 height, + int bit_depth, int color_type, int compression_method, int filter_method, + int interlace_method)); + +PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, + png_uint_32 num_pal)); + +PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); + +#if defined(PNG_WRITE_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point + file_gamma)); +#endif +#endif + +#if defined(PNG_WRITE_sBIT_SUPPORTED) +PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, + int color_type)); +#endif + +#if defined(PNG_WRITE_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, + double white_x, double white_y, + double red_x, double red_y, double green_x, double green_y, + double blue_x, double blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, + png_fixed_point int_white_x, png_fixed_point int_white_y, + png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point + int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +#endif +#endif + +#if defined(PNG_WRITE_sRGB_SUPPORTED) +PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, + int intent)); +#endif + +#if defined(PNG_WRITE_iCCP_SUPPORTED) +PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, + png_charp name, int compression_type, + png_charp profile, int proflen)); + /* Note to maintainer: profile should be png_bytep */ +#endif + +#if defined(PNG_WRITE_sPLT_SUPPORTED) +PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, + png_sPLT_tp palette)); +#endif + +#if defined(PNG_WRITE_tRNS_SUPPORTED) +PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, + png_color_16p values, int number, int color_type)); +#endif + +#if defined(PNG_WRITE_bKGD_SUPPORTED) +PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, + png_color_16p values, int color_type)); +#endif + +#if defined(PNG_WRITE_hIST_SUPPORTED) +PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, + int num_hist)); +#endif + +#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ + defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) +PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, + png_charp key, png_charpp new_key)); +#endif + +#if defined(PNG_WRITE_tEXt_SUPPORTED) +PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, + png_charp text, png_size_t text_len)); +#endif + +#if defined(PNG_WRITE_zTXt_SUPPORTED) +PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, + png_charp text, png_size_t text_len, int compression)); +#endif + +#if defined(PNG_WRITE_iTXt_SUPPORTED) +PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, + int compression, png_charp key, png_charp lang, png_charp lang_key, + png_charp text)); +#endif + +#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */ +PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp text_ptr, int num_text)); +#endif + +#if defined(PNG_WRITE_oFFs_SUPPORTED) +PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, + png_int_32 x_offset, png_int_32 y_offset, int unit_type)); +#endif + +#if defined(PNG_WRITE_pCAL_SUPPORTED) +PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, + png_int_32 X0, png_int_32 X1, int type, int nparams, + png_charp units, png_charpp params)); +#endif + +#if defined(PNG_WRITE_pHYs_SUPPORTED) +PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, + png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, + int unit_type)); +#endif + +#if defined(PNG_WRITE_tIME_SUPPORTED) +PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, + png_timep mod_time)); +#endif + +#if defined(PNG_WRITE_sCAL_SUPPORTED) +#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) +PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, + int unit, double width, double height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, + int unit, png_charp width, png_charp height)); +#endif +#endif +#endif + +/* Called when finished processing a row of data */ +PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); + +/* Internal use only. Called before first row of data */ +PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); + +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)); +#endif + +/* combine a row of data, dealing with alpha, etc. if requested */ +PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, + int mask)); + +#if defined(PNG_READ_INTERLACING_SUPPORTED) +/* expand an interlaced row */ +/* OLD pre-1.0.9 interface: +PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, + png_bytep row, int pass, png_uint_32 transformations)); + */ +PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); +#endif + +/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ + +#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* grab pixels out of a row for an interlaced pass */ +PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, + png_bytep row, int pass)); +#endif + +/* unfilter a row */ +PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, + png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter)); + +/* Choose the best filter to use and filter the row data */ +PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, + png_row_infop row_info)); + +/* Write out the filtered row. */ +PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, + png_bytep filtered_row)); +/* finish a row while reading, dealing with interlacing passes, etc. */ +PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); + +/* initialize the row buffers, etc. */ +PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); +/* optional call to update the users info structure */ +PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* these are the functions that do the transformations */ +#if defined(PNG_READ_FILLER_SUPPORTED) +PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 filler, png_uint_32 flags)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ + defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 flags)); +#endif + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop + row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) +PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) +PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, + png_color_8p sig_bits)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_16_TO_8_SUPPORTED) +PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) +PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, + png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); + +# if defined(PNG_CORRECT_PALETTE_SUPPORTED) +PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, + png_colorp palette, int num_palette)); +# endif +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_WRITE_PACK_SUPPORTED) +PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 bit_depth)); +#endif + +#if defined(PNG_WRITE_SHIFT_SUPPORTED) +PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, + png_color_8p bit_depth)); +#endif + +#if defined(PNG_READ_BACKGROUND_SUPPORTED) +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, + png_color_16p trans_values, png_color_16p background, + png_color_16p background_1, + png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, + png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, + png_uint_16pp gamma_16_to_1, int gamma_shift)); +#else +PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, + png_color_16p trans_values, png_color_16p background)); +#endif +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, + png_bytep gamma_table, png_uint_16pp gamma_16_table, + int gamma_shift)); +#endif + +#if defined(PNG_READ_EXPAND_SUPPORTED) +PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, + png_bytep row, png_colorp palette, png_bytep trans, int num_trans)); +PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, + png_bytep row, png_color_16p trans_value)); +#endif + +/* The following decodes the appropriate chunks, and does error correction, + * then calls the appropriate callback for the chunk if it is valid. + */ + +/* decode the IHDR chunk */ +PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); + +#if defined(PNG_READ_bKGD_SUPPORTED) +PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_cHRM_SUPPORTED) +PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_gAMA_SUPPORTED) +PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_hIST_SUPPORTED) +PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_iCCP_SUPPORTED) +extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif /* PNG_READ_iCCP_SUPPORTED */ + +#if defined(PNG_READ_iTXt_SUPPORTED) +PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_oFFs_SUPPORTED) +PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_pCAL_SUPPORTED) +PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_pHYs_SUPPORTED) +PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sBIT_SUPPORTED) +PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sCAL_SUPPORTED) +PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sPLT_SUPPORTED) +extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif /* PNG_READ_sPLT_SUPPORTED */ + +#if defined(PNG_READ_sRGB_SUPPORTED) +PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tEXt_SUPPORTED) +PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tIME_SUPPORTED) +PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tRNS_SUPPORTED) +PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_zTXt_SUPPORTED) +PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); + +PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, + png_bytep chunk_name)); + +/* handle the transformations for reading and writing */ +PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); + +PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, + png_uint_32 length)); +PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t buffer_length)); +PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t buffer_length)); +PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); +PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); +#if defined(PNG_READ_tEXt_SUPPORTED) +PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif +#if defined(PNG_READ_zTXt_SUPPORTED) +PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif +#if defined(PNG_READ_iTXt_SUPPORTED) +PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif + +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +#ifdef PNG_MNG_FEATURES_SUPPORTED +PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, + png_bytep row)); +PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +#if defined(PNG_MMX_CODE_SUPPORTED) +/* png.c */ /* PRIVATE */ +PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)); +#endif +#endif + +#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) +PNG_EXTERN png_uint_32 png_get_pixels_per_inch PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +PNG_EXTERN png_uint_32 png_get_x_pixels_per_inch PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +PNG_EXTERN png_uint_32 png_get_y_pixels_per_inch PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +PNG_EXTERN float png_get_x_offset_inches PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +PNG_EXTERN float png_get_y_offset_inches PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_pHYs_SUPPORTED) +PNG_EXTERN png_uint_32 png_get_pHYs_dpi PNGARG((png_structp png_ptr, +png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +#endif /* PNG_pHYs_SUPPORTED */ +#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ + +/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ + +#endif /* PNG_INTERNAL */ + +#ifdef __cplusplus +} +#endif + +#endif /* PNG_VERSION_INFO_ONLY */ +/* do not put anything past this line */ +#endif /* PNG_H */ diff --git a/extlib/pngconf.h b/extlib/pngconf.h new file mode 100644 index 00000000..d1e29957 --- /dev/null +++ b/extlib/pngconf.h @@ -0,0 +1,1481 @@ + +/* pngconf.h - machine configurable file for libpng + * + * libpng version 1.2.29 - May 8, 2008 + * For conditions of distribution and use, see copyright notice in png.h + * Copyright (c) 1998-2008 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + */ + +/* Any machine specific code is near the front of this file, so if you + * are configuring libpng for a machine, you may want to read the section + * starting here down to where it starts to typedef png_color, png_text, + * and png_info. + */ + +#ifndef PNGCONF_H +#define PNGCONF_H + +#define PNG_1_2_X + +/* + * PNG_USER_CONFIG has to be defined on the compiler command line. This + * includes the resource compiler for Windows DLL configurations. + */ +#ifdef PNG_USER_CONFIG +# ifndef PNG_USER_PRIVATEBUILD +# define PNG_USER_PRIVATEBUILD +# endif +#include "pngusr.h" +#endif + +/* PNG_CONFIGURE_LIBPNG is set by the "configure" script. */ +#ifdef PNG_CONFIGURE_LIBPNG +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#endif + +/* + * Added at libpng-1.2.8 + * + * If you create a private DLL you need to define in "pngusr.h" the followings: + * #define PNG_USER_PRIVATEBUILD + * e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons." + * #define PNG_USER_DLLFNAME_POSTFIX + * e.g. // private DLL "libpng13gx.dll" + * #define PNG_USER_DLLFNAME_POSTFIX "gx" + * + * The following macros are also at your disposal if you want to complete the + * DLL VERSIONINFO structure. + * - PNG_USER_VERSIONINFO_COMMENTS + * - PNG_USER_VERSIONINFO_COMPANYNAME + * - PNG_USER_VERSIONINFO_LEGALTRADEMARKS + */ + +#ifdef __STDC__ +#ifdef SPECIALBUILD +# pragma message("PNG_LIBPNG_SPECIALBUILD (and deprecated SPECIALBUILD)\ + are now LIBPNG reserved macros. Use PNG_USER_PRIVATEBUILD instead.") +#endif + +#ifdef PRIVATEBUILD +# pragma message("PRIVATEBUILD is deprecated.\ + Use PNG_USER_PRIVATEBUILD instead.") +# define PNG_USER_PRIVATEBUILD PRIVATEBUILD +#endif +#endif /* __STDC__ */ + +#ifndef PNG_VERSION_INFO_ONLY + +/* End of material added to libpng-1.2.8 */ + +/* Added at libpng-1.2.19, removed at libpng-1.2.20 because it caused trouble + Restored at libpng-1.2.21 */ +#if !defined(PNG_NO_WARN_UNINITIALIZED_ROW) && \ + !defined(PNG_WARN_UNINITIALIZED_ROW) +# define PNG_WARN_UNINITIALIZED_ROW 1 +#endif +/* End of material added at libpng-1.2.19/1.2.21 */ + +/* This is the size of the compression buffer, and thus the size of + * an IDAT chunk. Make this whatever size you feel is best for your + * machine. One of these will be allocated per png_struct. When this + * is full, it writes the data to the disk, and does some other + * calculations. Making this an extremely small size will slow + * the library down, but you may want to experiment to determine + * where it becomes significant, if you are concerned with memory + * usage. Note that zlib allocates at least 32Kb also. For readers, + * this describes the size of the buffer available to read the data in. + * Unless this gets smaller than the size of a row (compressed), + * it should not make much difference how big this is. + */ + +#ifndef PNG_ZBUF_SIZE +# define PNG_ZBUF_SIZE 8192 +#endif + +/* Enable if you want a write-only libpng */ + +#ifndef PNG_NO_READ_SUPPORTED +# define PNG_READ_SUPPORTED +#endif + +/* Enable if you want a read-only libpng */ + +#ifndef PNG_NO_WRITE_SUPPORTED +# define PNG_WRITE_SUPPORTED +#endif + +/* Enabled by default in 1.2.0. You can disable this if you don't need to + support PNGs that are embedded in MNG datastreams */ +#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) +# ifndef PNG_MNG_FEATURES_SUPPORTED +# define PNG_MNG_FEATURES_SUPPORTED +# endif +#endif + +#ifndef PNG_NO_FLOATING_POINT_SUPPORTED +# ifndef PNG_FLOATING_POINT_SUPPORTED +# define PNG_FLOATING_POINT_SUPPORTED +# endif +#endif + +/* If you are running on a machine where you cannot allocate more + * than 64K of memory at once, uncomment this. While libpng will not + * normally need that much memory in a chunk (unless you load up a very + * large file), zlib needs to know how big of a chunk it can use, and + * libpng thus makes sure to check any memory allocation to verify it + * will fit into memory. +#define PNG_MAX_MALLOC_64K + */ +#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) +# define PNG_MAX_MALLOC_64K +#endif + +/* Special munging to support doing things the 'cygwin' way: + * 'Normal' png-on-win32 defines/defaults: + * PNG_BUILD_DLL -- building dll + * PNG_USE_DLL -- building an application, linking to dll + * (no define) -- building static library, or building an + * application and linking to the static lib + * 'Cygwin' defines/defaults: + * PNG_BUILD_DLL -- (ignored) building the dll + * (no define) -- (ignored) building an application, linking to the dll + * PNG_STATIC -- (ignored) building the static lib, or building an + * application that links to the static lib. + * ALL_STATIC -- (ignored) building various static libs, or building an + * application that links to the static libs. + * Thus, + * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and + * this bit of #ifdefs will define the 'correct' config variables based on + * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but + * unnecessary. + * + * Also, the precedence order is: + * ALL_STATIC (since we can't #undef something outside our namespace) + * PNG_BUILD_DLL + * PNG_STATIC + * (nothing) == PNG_USE_DLL + * + * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent + * of auto-import in binutils, we no longer need to worry about + * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, + * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes + * to __declspec() stuff. However, we DO need to worry about + * PNG_BUILD_DLL and PNG_STATIC because those change some defaults + * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. + */ +#if defined(__CYGWIN__) +# if defined(ALL_STATIC) +# if defined(PNG_BUILD_DLL) +# undef PNG_BUILD_DLL +# endif +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if defined(PNG_DLL) +# undef PNG_DLL +# endif +# if !defined(PNG_STATIC) +# define PNG_STATIC +# endif +# else +# if defined (PNG_BUILD_DLL) +# if defined(PNG_STATIC) +# undef PNG_STATIC +# endif +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if !defined(PNG_DLL) +# define PNG_DLL +# endif +# else +# if defined(PNG_STATIC) +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if defined(PNG_DLL) +# undef PNG_DLL +# endif +# else +# if !defined(PNG_USE_DLL) +# define PNG_USE_DLL +# endif +# if !defined(PNG_DLL) +# define PNG_DLL +# endif +# endif +# endif +# endif +#endif + +/* This protects us against compilers that run on a windowing system + * and thus don't have or would rather us not use the stdio types: + * stdin, stdout, and stderr. The only one currently used is stderr + * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will + * prevent these from being compiled and used. #defining PNG_NO_STDIO + * will also prevent these, plus will prevent the entire set of stdio + * macros and functions (FILE *, printf, etc.) from being compiled and used, + * unless (PNG_DEBUG > 0) has been #defined. + * + * #define PNG_NO_CONSOLE_IO + * #define PNG_NO_STDIO + */ + +#if defined(_WIN32_WCE) +# include + /* Console I/O functions are not supported on WindowsCE */ +# define PNG_NO_CONSOLE_IO +# ifdef PNG_DEBUG +# undef PNG_DEBUG +# endif +#endif + +#ifdef PNG_BUILD_DLL +# ifndef PNG_CONSOLE_IO_SUPPORTED +# ifndef PNG_NO_CONSOLE_IO +# define PNG_NO_CONSOLE_IO +# endif +# endif +#endif + +# ifdef PNG_NO_STDIO +# ifndef PNG_NO_CONSOLE_IO +# define PNG_NO_CONSOLE_IO +# endif +# ifdef PNG_DEBUG +# if (PNG_DEBUG > 0) +# include +# endif +# endif +# else +# if !defined(_WIN32_WCE) +/* "stdio.h" functions are not supported on WindowsCE */ +# include +# endif +# endif + +/* This macro protects us against machines that don't have function + * prototypes (ie K&R style headers). If your compiler does not handle + * function prototypes, define this macro and use the included ansi2knr. + * I've always been able to use _NO_PROTO as the indicator, but you may + * need to drag the empty declaration out in front of here, or change the + * ifdef to suit your own needs. + */ +#ifndef PNGARG + +#ifdef OF /* zlib prototype munger */ +# define PNGARG(arglist) OF(arglist) +#else + +#ifdef _NO_PROTO +# define PNGARG(arglist) () +# ifndef PNG_TYPECAST_NULL +# define PNG_TYPECAST_NULL +# endif +#else +# define PNGARG(arglist) arglist +#endif /* _NO_PROTO */ + + +#endif /* OF */ + +#endif /* PNGARG */ + +/* Try to determine if we are compiling on a Mac. Note that testing for + * just __MWERKS__ is not good enough, because the Codewarrior is now used + * on non-Mac platforms. + */ +#ifndef MACOS +# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ + defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) +# define MACOS +# endif +#endif + +/* enough people need this for various reasons to include it here */ +#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) +# include +#endif + +#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) +# define PNG_SETJMP_SUPPORTED +#endif + +#ifdef PNG_SETJMP_SUPPORTED +/* This is an attempt to force a single setjmp behaviour on Linux. If + * the X config stuff didn't define _BSD_SOURCE we wouldn't need this. + */ + +# ifdef __linux__ +# ifdef _BSD_SOURCE +# define PNG_SAVE_BSD_SOURCE +# undef _BSD_SOURCE +# endif +# ifdef _SETJMP_H + /* If you encounter a compiler error here, see the explanation + * near the end of INSTALL. + */ + __pngconf.h__ already includes setjmp.h; + __dont__ include it again.; +# endif +# endif /* __linux__ */ + + /* include setjmp.h for error handling */ +# include + +# ifdef __linux__ +# ifdef PNG_SAVE_BSD_SOURCE +# ifndef _BSD_SOURCE +# define _BSD_SOURCE +# endif +# undef PNG_SAVE_BSD_SOURCE +# endif +# endif /* __linux__ */ +#endif /* PNG_SETJMP_SUPPORTED */ + +#ifdef BSD +# include +#else +# include +#endif + +/* Other defines for things like memory and the like can go here. */ +#ifdef PNG_INTERNAL + +#include + +/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which + * aren't usually used outside the library (as far as I know), so it is + * debatable if they should be exported at all. In the future, when it is + * possible to have run-time registry of chunk-handling functions, some of + * these will be made available again. +#define PNG_EXTERN extern + */ +#define PNG_EXTERN + +/* Other defines specific to compilers can go here. Try to keep + * them inside an appropriate ifdef/endif pair for portability. + */ + +#if defined(PNG_FLOATING_POINT_SUPPORTED) +# if defined(MACOS) + /* We need to check that hasn't already been included earlier + * as it seems it doesn't agree with , yet we should really use + * if possible. + */ +# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) +# include +# endif +# else +# include +# endif +# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) + /* Amiga SAS/C: We must include builtin FPU functions when compiling using + * MATH=68881 + */ +# include +# endif +#endif + +/* Codewarrior on NT has linking problems without this. */ +#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) +# define PNG_ALWAYS_EXTERN +#endif + +/* This provides the non-ANSI (far) memory allocation routines. */ +#if defined(__TURBOC__) && defined(__MSDOS__) +# include +# include +#endif + +/* I have no idea why is this necessary... */ +#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ + defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) +# include +#endif + +/* This controls how fine the dithering gets. As this allocates + * a largish chunk of memory (32K), those who are not as concerned + * with dithering quality can decrease some or all of these. + */ +#ifndef PNG_DITHER_RED_BITS +# define PNG_DITHER_RED_BITS 5 +#endif +#ifndef PNG_DITHER_GREEN_BITS +# define PNG_DITHER_GREEN_BITS 5 +#endif +#ifndef PNG_DITHER_BLUE_BITS +# define PNG_DITHER_BLUE_BITS 5 +#endif + +/* This controls how fine the gamma correction becomes when you + * are only interested in 8 bits anyway. Increasing this value + * results in more memory being used, and more pow() functions + * being called to fill in the gamma tables. Don't set this value + * less then 8, and even that may not work (I haven't tested it). + */ + +#ifndef PNG_MAX_GAMMA_8 +# define PNG_MAX_GAMMA_8 11 +#endif + +/* This controls how much a difference in gamma we can tolerate before + * we actually start doing gamma conversion. + */ +#ifndef PNG_GAMMA_THRESHOLD +# define PNG_GAMMA_THRESHOLD 0.05 +#endif + +#endif /* PNG_INTERNAL */ + +/* The following uses const char * instead of char * for error + * and warning message functions, so some compilers won't complain. + * If you do not want to use const, define PNG_NO_CONST here. + */ + +#ifndef PNG_NO_CONST +# define PNG_CONST const +#else +# define PNG_CONST +#endif + +/* The following defines give you the ability to remove code from the + * library that you will not be using. I wish I could figure out how to + * automate this, but I can't do that without making it seriously hard + * on the users. So if you are not using an ability, change the #define + * to and #undef, and that part of the library will not be compiled. If + * your linker can't find a function, you may want to make sure the + * ability is defined here. Some of these depend upon some others being + * defined. I haven't figured out all the interactions here, so you may + * have to experiment awhile to get everything to compile. If you are + * creating or using a shared library, you probably shouldn't touch this, + * as it will affect the size of the structures, and this will cause bad + * things to happen if the library and/or application ever change. + */ + +/* Any features you will not be using can be undef'ed here */ + +/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user + * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS + * on the compile line, then pick and choose which ones to define without + * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED + * if you only want to have a png-compliant reader/writer but don't need + * any of the extra transformations. This saves about 80 kbytes in a + * typical installation of the library. (PNG_NO_* form added in version + * 1.0.1c, for consistency) + */ + +/* The size of the png_text structure changed in libpng-1.0.6 when + * iTXt support was added. iTXt support was turned off by default through + * libpng-1.2.x, to support old apps that malloc the png_text structure + * instead of calling png_set_text() and letting libpng malloc it. It + * was turned on by default in libpng-1.3.0. + */ + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +# ifndef PNG_NO_iTXt_SUPPORTED +# define PNG_NO_iTXt_SUPPORTED +# endif +# ifndef PNG_NO_READ_iTXt +# define PNG_NO_READ_iTXt +# endif +# ifndef PNG_NO_WRITE_iTXt +# define PNG_NO_WRITE_iTXt +# endif +#endif + +#if !defined(PNG_NO_iTXt_SUPPORTED) +# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) +# define PNG_READ_iTXt +# endif +# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) +# define PNG_WRITE_iTXt +# endif +#endif + +/* The following support, added after version 1.0.0, can be turned off here en + * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility + * with old applications that require the length of png_struct and png_info + * to remain unchanged. + */ + +#ifdef PNG_LEGACY_SUPPORTED +# define PNG_NO_FREE_ME +# define PNG_NO_READ_UNKNOWN_CHUNKS +# define PNG_NO_WRITE_UNKNOWN_CHUNKS +# define PNG_NO_READ_USER_CHUNKS +# define PNG_NO_READ_iCCP +# define PNG_NO_WRITE_iCCP +# define PNG_NO_READ_iTXt +# define PNG_NO_WRITE_iTXt +# define PNG_NO_READ_sCAL +# define PNG_NO_WRITE_sCAL +# define PNG_NO_READ_sPLT +# define PNG_NO_WRITE_sPLT +# define PNG_NO_INFO_IMAGE +# define PNG_NO_READ_RGB_TO_GRAY +# define PNG_NO_READ_USER_TRANSFORM +# define PNG_NO_WRITE_USER_TRANSFORM +# define PNG_NO_USER_MEM +# define PNG_NO_READ_EMPTY_PLTE +# define PNG_NO_MNG_FEATURES +# define PNG_NO_FIXED_POINT_SUPPORTED +#endif + +/* Ignore attempt to turn off both floating and fixed point support */ +#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ + !defined(PNG_NO_FIXED_POINT_SUPPORTED) +# define PNG_FIXED_POINT_SUPPORTED +#endif + +#ifndef PNG_NO_FREE_ME +# define PNG_FREE_ME_SUPPORTED +#endif + +#if defined(PNG_READ_SUPPORTED) + +#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ + !defined(PNG_NO_READ_TRANSFORMS) +# define PNG_READ_TRANSFORMS_SUPPORTED +#endif + +#ifdef PNG_READ_TRANSFORMS_SUPPORTED +# ifndef PNG_NO_READ_EXPAND +# define PNG_READ_EXPAND_SUPPORTED +# endif +# ifndef PNG_NO_READ_SHIFT +# define PNG_READ_SHIFT_SUPPORTED +# endif +# ifndef PNG_NO_READ_PACK +# define PNG_READ_PACK_SUPPORTED +# endif +# ifndef PNG_NO_READ_BGR +# define PNG_READ_BGR_SUPPORTED +# endif +# ifndef PNG_NO_READ_SWAP +# define PNG_READ_SWAP_SUPPORTED +# endif +# ifndef PNG_NO_READ_PACKSWAP +# define PNG_READ_PACKSWAP_SUPPORTED +# endif +# ifndef PNG_NO_READ_INVERT +# define PNG_READ_INVERT_SUPPORTED +# endif +# ifndef PNG_NO_READ_DITHER +# define PNG_READ_DITHER_SUPPORTED +# endif +# ifndef PNG_NO_READ_BACKGROUND +# define PNG_READ_BACKGROUND_SUPPORTED +# endif +# ifndef PNG_NO_READ_16_TO_8 +# define PNG_READ_16_TO_8_SUPPORTED +# endif +# ifndef PNG_NO_READ_FILLER +# define PNG_READ_FILLER_SUPPORTED +# endif +# ifndef PNG_NO_READ_GAMMA +# define PNG_READ_GAMMA_SUPPORTED +# endif +# ifndef PNG_NO_READ_GRAY_TO_RGB +# define PNG_READ_GRAY_TO_RGB_SUPPORTED +# endif +# ifndef PNG_NO_READ_SWAP_ALPHA +# define PNG_READ_SWAP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_INVERT_ALPHA +# define PNG_READ_INVERT_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_STRIP_ALPHA +# define PNG_READ_STRIP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_USER_TRANSFORM +# define PNG_READ_USER_TRANSFORM_SUPPORTED +# endif +# ifndef PNG_NO_READ_RGB_TO_GRAY +# define PNG_READ_RGB_TO_GRAY_SUPPORTED +# endif +#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ + +#if !defined(PNG_NO_PROGRESSIVE_READ) && \ + !defined(PNG_PROGRESSIVE_READ_SUPPORTED) /* if you don't do progressive */ +# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ +#endif /* about interlacing capability! You'll */ + /* still have interlacing unless you change the following line: */ + +#define PNG_READ_INTERLACING_SUPPORTED /* required in PNG-compliant decoders */ + +#ifndef PNG_NO_READ_COMPOSITE_NODIV +# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ +# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ +# endif +#endif + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Deprecated, will be removed from version 2.0.0. + Use PNG_MNG_FEATURES_SUPPORTED instead. */ +#ifndef PNG_NO_READ_EMPTY_PLTE +# define PNG_READ_EMPTY_PLTE_SUPPORTED +#endif +#endif + +#endif /* PNG_READ_SUPPORTED */ + +#if defined(PNG_WRITE_SUPPORTED) + +# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ + !defined(PNG_NO_WRITE_TRANSFORMS) +# define PNG_WRITE_TRANSFORMS_SUPPORTED +#endif + +#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED +# ifndef PNG_NO_WRITE_SHIFT +# define PNG_WRITE_SHIFT_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_PACK +# define PNG_WRITE_PACK_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_BGR +# define PNG_WRITE_BGR_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_SWAP +# define PNG_WRITE_SWAP_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_PACKSWAP +# define PNG_WRITE_PACKSWAP_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_INVERT +# define PNG_WRITE_INVERT_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_FILLER +# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ +# endif +# ifndef PNG_NO_WRITE_SWAP_ALPHA +# define PNG_WRITE_SWAP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_INVERT_ALPHA +# define PNG_WRITE_INVERT_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_USER_TRANSFORM +# define PNG_WRITE_USER_TRANSFORM_SUPPORTED +# endif +#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ + +#if !defined(PNG_NO_WRITE_INTERLACING_SUPPORTED) && \ + !defined(PNG_WRITE_INTERLACING_SUPPORTED) +#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant + encoders, but can cause trouble + if left undefined */ +#endif + +#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ + !defined(PNG_WRITE_WEIGHTED_FILTER) && \ + defined(PNG_FLOATING_POINT_SUPPORTED) +# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +#endif + +#ifndef PNG_NO_WRITE_FLUSH +# define PNG_WRITE_FLUSH_SUPPORTED +#endif + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ +#ifndef PNG_NO_WRITE_EMPTY_PLTE +# define PNG_WRITE_EMPTY_PLTE_SUPPORTED +#endif +#endif + +#endif /* PNG_WRITE_SUPPORTED */ + +#ifndef PNG_1_0_X +# ifndef PNG_NO_ERROR_NUMBERS +# define PNG_ERROR_NUMBERS_SUPPORTED +# endif +#endif /* PNG_1_0_X */ + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +# ifndef PNG_NO_USER_TRANSFORM_PTR +# define PNG_USER_TRANSFORM_PTR_SUPPORTED +# endif +#endif + +#ifndef PNG_NO_STDIO +# define PNG_TIME_RFC1123_SUPPORTED +#endif + +/* This adds extra functions in pngget.c for accessing data from the + * info pointer (added in version 0.99) + * png_get_image_width() + * png_get_image_height() + * png_get_bit_depth() + * png_get_color_type() + * png_get_compression_type() + * png_get_filter_type() + * png_get_interlace_type() + * png_get_pixel_aspect_ratio() + * png_get_pixels_per_meter() + * png_get_x_offset_pixels() + * png_get_y_offset_pixels() + * png_get_x_offset_microns() + * png_get_y_offset_microns() + */ +#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) +# define PNG_EASY_ACCESS_SUPPORTED +#endif + +/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 + * and removed from version 1.2.20. The following will be removed + * from libpng-1.4.0 +*/ + +#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_OPTIMIZED_CODE) +# ifndef PNG_OPTIMIZED_CODE_SUPPORTED +# define PNG_OPTIMIZED_CODE_SUPPORTED +# endif +#endif + +#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) +# ifndef PNG_ASSEMBLER_CODE_SUPPORTED +# define PNG_ASSEMBLER_CODE_SUPPORTED +# endif + +# if defined(__GNUC__) && defined(__x86_64__) && (__GNUC__ < 4) + /* work around 64-bit gcc compiler bugs in gcc-3.x */ +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_NO_MMX_CODE +# endif +# endif + +# if defined(__APPLE__) +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_NO_MMX_CODE +# endif +# endif + +# if (defined(__MWERKS__) && ((__MWERKS__ < 0x0900) || macintosh)) +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_NO_MMX_CODE +# endif +# endif + +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_MMX_CODE_SUPPORTED +# endif + +#endif +/* end of obsolete code to be removed from libpng-1.4.0 */ + +#if !defined(PNG_1_0_X) +#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) +# define PNG_USER_MEM_SUPPORTED +#endif +#endif /* PNG_1_0_X */ + +/* Added at libpng-1.2.6 */ +#if !defined(PNG_1_0_X) +#ifndef PNG_SET_USER_LIMITS_SUPPORTED +#if !defined(PNG_NO_SET_USER_LIMITS) && !defined(PNG_SET_USER_LIMITS_SUPPORTED) +# define PNG_SET_USER_LIMITS_SUPPORTED +#endif +#endif +#endif /* PNG_1_0_X */ + +/* Added at libpng-1.0.16 and 1.2.6. To accept all valid PNGS no matter + * how large, set these limits to 0x7fffffffL + */ +#ifndef PNG_USER_WIDTH_MAX +# define PNG_USER_WIDTH_MAX 1000000L +#endif +#ifndef PNG_USER_HEIGHT_MAX +# define PNG_USER_HEIGHT_MAX 1000000L +#endif + +/* These are currently experimental features, define them if you want */ + +/* very little testing */ +/* +#ifdef PNG_READ_SUPPORTED +# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +# endif +#endif +*/ + +/* This is only for PowerPC big-endian and 680x0 systems */ +/* some testing */ +/* +#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED +# define PNG_READ_BIG_ENDIAN_SUPPORTED +#endif +*/ + +/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ +/* +#define PNG_NO_POINTER_INDEXING +*/ + +/* These functions are turned off by default, as they will be phased out. */ +/* +#define PNG_USELESS_TESTS_SUPPORTED +#define PNG_CORRECT_PALETTE_SUPPORTED +*/ + +/* Any chunks you are not interested in, you can undef here. The + * ones that allocate memory may be expecially important (hIST, + * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info + * a bit smaller. + */ + +#if defined(PNG_READ_SUPPORTED) && \ + !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ + !defined(PNG_NO_READ_ANCILLARY_CHUNKS) +# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +#endif + +#if defined(PNG_WRITE_SUPPORTED) && \ + !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ + !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) +# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +#endif + +#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED + +#ifdef PNG_NO_READ_TEXT +# define PNG_NO_READ_iTXt +# define PNG_NO_READ_tEXt +# define PNG_NO_READ_zTXt +#endif +#ifndef PNG_NO_READ_bKGD +# define PNG_READ_bKGD_SUPPORTED +# define PNG_bKGD_SUPPORTED +#endif +#ifndef PNG_NO_READ_cHRM +# define PNG_READ_cHRM_SUPPORTED +# define PNG_cHRM_SUPPORTED +#endif +#ifndef PNG_NO_READ_gAMA +# define PNG_READ_gAMA_SUPPORTED +# define PNG_gAMA_SUPPORTED +#endif +#ifndef PNG_NO_READ_hIST +# define PNG_READ_hIST_SUPPORTED +# define PNG_hIST_SUPPORTED +#endif +#ifndef PNG_NO_READ_iCCP +# define PNG_READ_iCCP_SUPPORTED +# define PNG_iCCP_SUPPORTED +#endif +#ifndef PNG_NO_READ_iTXt +# ifndef PNG_READ_iTXt_SUPPORTED +# define PNG_READ_iTXt_SUPPORTED +# endif +# ifndef PNG_iTXt_SUPPORTED +# define PNG_iTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_READ_oFFs +# define PNG_READ_oFFs_SUPPORTED +# define PNG_oFFs_SUPPORTED +#endif +#ifndef PNG_NO_READ_pCAL +# define PNG_READ_pCAL_SUPPORTED +# define PNG_pCAL_SUPPORTED +#endif +#ifndef PNG_NO_READ_sCAL +# define PNG_READ_sCAL_SUPPORTED +# define PNG_sCAL_SUPPORTED +#endif +#ifndef PNG_NO_READ_pHYs +# define PNG_READ_pHYs_SUPPORTED +# define PNG_pHYs_SUPPORTED +#endif +#ifndef PNG_NO_READ_sBIT +# define PNG_READ_sBIT_SUPPORTED +# define PNG_sBIT_SUPPORTED +#endif +#ifndef PNG_NO_READ_sPLT +# define PNG_READ_sPLT_SUPPORTED +# define PNG_sPLT_SUPPORTED +#endif +#ifndef PNG_NO_READ_sRGB +# define PNG_READ_sRGB_SUPPORTED +# define PNG_sRGB_SUPPORTED +#endif +#ifndef PNG_NO_READ_tEXt +# define PNG_READ_tEXt_SUPPORTED +# define PNG_tEXt_SUPPORTED +#endif +#ifndef PNG_NO_READ_tIME +# define PNG_READ_tIME_SUPPORTED +# define PNG_tIME_SUPPORTED +#endif +#ifndef PNG_NO_READ_tRNS +# define PNG_READ_tRNS_SUPPORTED +# define PNG_tRNS_SUPPORTED +#endif +#ifndef PNG_NO_READ_zTXt +# define PNG_READ_zTXt_SUPPORTED +# define PNG_zTXt_SUPPORTED +#endif +#ifndef PNG_NO_READ_UNKNOWN_CHUNKS +# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_UNKNOWN_CHUNKS_SUPPORTED +# endif +# ifndef PNG_NO_HANDLE_AS_UNKNOWN +# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# endif +#endif +#if !defined(PNG_NO_READ_USER_CHUNKS) && \ + defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +# define PNG_READ_USER_CHUNKS_SUPPORTED +# define PNG_USER_CHUNKS_SUPPORTED +# ifdef PNG_NO_READ_UNKNOWN_CHUNKS +# undef PNG_NO_READ_UNKNOWN_CHUNKS +# endif +# ifdef PNG_NO_HANDLE_AS_UNKNOWN +# undef PNG_NO_HANDLE_AS_UNKNOWN +# endif +#endif +#ifndef PNG_NO_READ_OPT_PLTE +# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ +#endif /* optional PLTE chunk in RGB and RGBA images */ +#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ + defined(PNG_READ_zTXt_SUPPORTED) +# define PNG_READ_TEXT_SUPPORTED +# define PNG_TEXT_SUPPORTED +#endif + +#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ + +#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED + +#ifdef PNG_NO_WRITE_TEXT +# define PNG_NO_WRITE_iTXt +# define PNG_NO_WRITE_tEXt +# define PNG_NO_WRITE_zTXt +#endif +#ifndef PNG_NO_WRITE_bKGD +# define PNG_WRITE_bKGD_SUPPORTED +# ifndef PNG_bKGD_SUPPORTED +# define PNG_bKGD_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_cHRM +# define PNG_WRITE_cHRM_SUPPORTED +# ifndef PNG_cHRM_SUPPORTED +# define PNG_cHRM_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_gAMA +# define PNG_WRITE_gAMA_SUPPORTED +# ifndef PNG_gAMA_SUPPORTED +# define PNG_gAMA_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_hIST +# define PNG_WRITE_hIST_SUPPORTED +# ifndef PNG_hIST_SUPPORTED +# define PNG_hIST_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_iCCP +# define PNG_WRITE_iCCP_SUPPORTED +# ifndef PNG_iCCP_SUPPORTED +# define PNG_iCCP_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_iTXt +# ifndef PNG_WRITE_iTXt_SUPPORTED +# define PNG_WRITE_iTXt_SUPPORTED +# endif +# ifndef PNG_iTXt_SUPPORTED +# define PNG_iTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_oFFs +# define PNG_WRITE_oFFs_SUPPORTED +# ifndef PNG_oFFs_SUPPORTED +# define PNG_oFFs_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_pCAL +# define PNG_WRITE_pCAL_SUPPORTED +# ifndef PNG_pCAL_SUPPORTED +# define PNG_pCAL_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sCAL +# define PNG_WRITE_sCAL_SUPPORTED +# ifndef PNG_sCAL_SUPPORTED +# define PNG_sCAL_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_pHYs +# define PNG_WRITE_pHYs_SUPPORTED +# ifndef PNG_pHYs_SUPPORTED +# define PNG_pHYs_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sBIT +# define PNG_WRITE_sBIT_SUPPORTED +# ifndef PNG_sBIT_SUPPORTED +# define PNG_sBIT_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sPLT +# define PNG_WRITE_sPLT_SUPPORTED +# ifndef PNG_sPLT_SUPPORTED +# define PNG_sPLT_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sRGB +# define PNG_WRITE_sRGB_SUPPORTED +# ifndef PNG_sRGB_SUPPORTED +# define PNG_sRGB_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tEXt +# define PNG_WRITE_tEXt_SUPPORTED +# ifndef PNG_tEXt_SUPPORTED +# define PNG_tEXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tIME +# define PNG_WRITE_tIME_SUPPORTED +# ifndef PNG_tIME_SUPPORTED +# define PNG_tIME_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tRNS +# define PNG_WRITE_tRNS_SUPPORTED +# ifndef PNG_tRNS_SUPPORTED +# define PNG_tRNS_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_zTXt +# define PNG_WRITE_zTXt_SUPPORTED +# ifndef PNG_zTXt_SUPPORTED +# define PNG_zTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS +# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_UNKNOWN_CHUNKS_SUPPORTED +# endif +# ifndef PNG_NO_HANDLE_AS_UNKNOWN +# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# endif +# endif +#endif +#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ + defined(PNG_WRITE_zTXt_SUPPORTED) +# define PNG_WRITE_TEXT_SUPPORTED +# ifndef PNG_TEXT_SUPPORTED +# define PNG_TEXT_SUPPORTED +# endif +#endif + +#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ + +/* Turn this off to disable png_read_png() and + * png_write_png() and leave the row_pointers member + * out of the info structure. + */ +#ifndef PNG_NO_INFO_IMAGE +# define PNG_INFO_IMAGE_SUPPORTED +#endif + +/* need the time information for reading tIME chunks */ +#if defined(PNG_tIME_SUPPORTED) +# if !defined(_WIN32_WCE) + /* "time.h" functions are not supported on WindowsCE */ +# include +# endif +#endif + +/* Some typedefs to get us started. These should be safe on most of the + * common platforms. The typedefs should be at least as large as the + * numbers suggest (a png_uint_32 must be at least 32 bits long), but they + * don't have to be exactly that size. Some compilers dislike passing + * unsigned shorts as function parameters, so you may be better off using + * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may + * want to have unsigned int for png_uint_32 instead of unsigned long. + */ + +typedef unsigned long png_uint_32; +typedef long png_int_32; +typedef unsigned short png_uint_16; +typedef short png_int_16; +typedef unsigned char png_byte; + +/* This is usually size_t. It is typedef'ed just in case you need it to + change (I'm not sure if you will or not, so I thought I'd be safe) */ +#ifdef PNG_SIZE_T + typedef PNG_SIZE_T png_size_t; +# define png_sizeof(x) png_convert_size(sizeof (x)) +#else + typedef size_t png_size_t; +# define png_sizeof(x) sizeof (x) +#endif + +/* The following is needed for medium model support. It cannot be in the + * PNG_INTERNAL section. Needs modification for other compilers besides + * MSC. Model independent support declares all arrays and pointers to be + * large using the far keyword. The zlib version used must also support + * model independent data. As of version zlib 1.0.4, the necessary changes + * have been made in zlib. The USE_FAR_KEYWORD define triggers other + * changes that are needed. (Tim Wegner) + */ + +/* Separate compiler dependencies (problem here is that zlib.h always + defines FAR. (SJT) */ +#ifdef __BORLANDC__ +# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) +# define LDATA 1 +# else +# define LDATA 0 +# endif + /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ +# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) +# define PNG_MAX_MALLOC_64K +# if (LDATA != 1) +# ifndef FAR +# define FAR __far +# endif +# define USE_FAR_KEYWORD +# endif /* LDATA != 1 */ + /* Possibly useful for moving data out of default segment. + * Uncomment it if you want. Could also define FARDATA as + * const if your compiler supports it. (SJT) +# define FARDATA FAR + */ +# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ +#endif /* __BORLANDC__ */ + + +/* Suggest testing for specific compiler first before testing for + * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, + * making reliance oncertain keywords suspect. (SJT) + */ + +/* MSC Medium model */ +#if defined(FAR) +# if defined(M_I86MM) +# define USE_FAR_KEYWORD +# define FARDATA FAR +# include +# endif +#endif + +/* SJT: default case */ +#ifndef FAR +# define FAR +#endif + +/* At this point FAR is always defined */ +#ifndef FARDATA +# define FARDATA +#endif + +/* Typedef for floating-point numbers that are converted + to fixed-point with a multiple of 100,000, e.g., int_gamma */ +typedef png_int_32 png_fixed_point; + +/* Add typedefs for pointers */ +typedef void FAR * png_voidp; +typedef png_byte FAR * png_bytep; +typedef png_uint_32 FAR * png_uint_32p; +typedef png_int_32 FAR * png_int_32p; +typedef png_uint_16 FAR * png_uint_16p; +typedef png_int_16 FAR * png_int_16p; +typedef PNG_CONST char FAR * png_const_charp; +typedef char FAR * png_charp; +typedef png_fixed_point FAR * png_fixed_point_p; + +#ifndef PNG_NO_STDIO +#if defined(_WIN32_WCE) +typedef HANDLE png_FILE_p; +#else +typedef FILE * png_FILE_p; +#endif +#endif + +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double FAR * png_doublep; +#endif + +/* Pointers to pointers; i.e. arrays */ +typedef png_byte FAR * FAR * png_bytepp; +typedef png_uint_32 FAR * FAR * png_uint_32pp; +typedef png_int_32 FAR * FAR * png_int_32pp; +typedef png_uint_16 FAR * FAR * png_uint_16pp; +typedef png_int_16 FAR * FAR * png_int_16pp; +typedef PNG_CONST char FAR * FAR * png_const_charpp; +typedef char FAR * FAR * png_charpp; +typedef png_fixed_point FAR * FAR * png_fixed_point_pp; +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double FAR * FAR * png_doublepp; +#endif + +/* Pointers to pointers to pointers; i.e., pointer to array */ +typedef char FAR * FAR * FAR * png_charppp; + +#if defined(PNG_1_0_X) || defined(PNG_1_2_X) +/* SPC - Is this stuff deprecated? */ +/* It'll be removed as of libpng-1.3.0 - GR-P */ +/* libpng typedefs for types in zlib. If zlib changes + * or another compression library is used, then change these. + * Eliminates need to change all the source files. + */ +typedef charf * png_zcharp; +typedef charf * FAR * png_zcharpp; +typedef z_stream FAR * png_zstreamp; +#endif /* (PNG_1_0_X) || defined(PNG_1_2_X) */ + +/* + * Define PNG_BUILD_DLL if the module being built is a Windows + * LIBPNG DLL. + * + * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. + * It is equivalent to Microsoft predefined macro _DLL that is + * automatically defined when you compile using the share + * version of the CRT (C Run-Time library) + * + * The cygwin mods make this behavior a little different: + * Define PNG_BUILD_DLL if you are building a dll for use with cygwin + * Define PNG_STATIC if you are building a static library for use with cygwin, + * -or- if you are building an application that you want to link to the + * static library. + * PNG_USE_DLL is defined by default (no user action needed) unless one of + * the other flags is defined. + */ + +#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) +# define PNG_DLL +#endif +/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. + * When building a static lib, default to no GLOBAL ARRAYS, but allow + * command-line override + */ +#if defined(__CYGWIN__) +# if !defined(PNG_STATIC) +# if defined(PNG_USE_GLOBAL_ARRAYS) +# undef PNG_USE_GLOBAL_ARRAYS +# endif +# if !defined(PNG_USE_LOCAL_ARRAYS) +# define PNG_USE_LOCAL_ARRAYS +# endif +# else +# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) +# if defined(PNG_USE_GLOBAL_ARRAYS) +# undef PNG_USE_GLOBAL_ARRAYS +# endif +# endif +# endif +# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +# define PNG_USE_LOCAL_ARRAYS +# endif +#endif + +/* Do not use global arrays (helps with building DLL's) + * They are no longer used in libpng itself, since version 1.0.5c, + * but might be required for some pre-1.0.5c applications. + */ +#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +# if defined(PNG_NO_GLOBAL_ARRAYS) || \ + (defined(__GNUC__) && defined(PNG_DLL)) || defined(_MSC_VER) +# define PNG_USE_LOCAL_ARRAYS +# else +# define PNG_USE_GLOBAL_ARRAYS +# endif +#endif + +#if defined(__CYGWIN__) +# undef PNGAPI +# define PNGAPI __cdecl +# undef PNG_IMPEXP +# define PNG_IMPEXP +#endif + +/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", + * you may get warnings regarding the linkage of png_zalloc and png_zfree. + * Don't ignore those warnings; you must also reset the default calling + * convention in your compiler to match your PNGAPI, and you must build + * zlib and your applications the same way you build libpng. + */ + +#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) +# ifndef PNG_NO_MODULEDEF +# define PNG_NO_MODULEDEF +# endif +#endif + +#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) +# define PNG_IMPEXP +#endif + +#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ + (( defined(_Windows) || defined(_WINDOWS) || \ + defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) + +# ifndef PNGAPI +# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) +# define PNGAPI __cdecl +# else +# define PNGAPI _cdecl +# endif +# endif + +# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ + 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) +# define PNG_IMPEXP +# endif + +# if !defined(PNG_IMPEXP) + +# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol +# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol + + /* Borland/Microsoft */ +# if defined(_MSC_VER) || defined(__BORLANDC__) +# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) +# define PNG_EXPORT PNG_EXPORT_TYPE1 +# else +# define PNG_EXPORT PNG_EXPORT_TYPE2 +# if defined(PNG_BUILD_DLL) +# define PNG_IMPEXP __export +# else +# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in + VC++ */ +# endif /* Exists in Borland C++ for + C++ classes (== huge) */ +# endif +# endif + +# if !defined(PNG_IMPEXP) +# if defined(PNG_BUILD_DLL) +# define PNG_IMPEXP __declspec(dllexport) +# else +# define PNG_IMPEXP __declspec(dllimport) +# endif +# endif +# endif /* PNG_IMPEXP */ +#else /* !(DLL || non-cygwin WINDOWS) */ +# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) +# ifndef PNGAPI +# define PNGAPI _System +# endif +# else +# if 0 /* ... other platforms, with other meanings */ +# endif +# endif +#endif + +#ifndef PNGAPI +# define PNGAPI +#endif +#ifndef PNG_IMPEXP +# define PNG_IMPEXP +#endif + +#ifdef PNG_BUILDSYMS +# ifndef PNG_EXPORT +# define PNG_EXPORT(type,symbol) PNG_FUNCTION_EXPORT symbol END +# endif +# ifdef PNG_USE_GLOBAL_ARRAYS +# ifndef PNG_EXPORT_VAR +# define PNG_EXPORT_VAR(type) PNG_DATA_EXPORT +# endif +# endif +#endif + +#ifndef PNG_EXPORT +# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol +#endif + +#ifdef PNG_USE_GLOBAL_ARRAYS +# ifndef PNG_EXPORT_VAR +# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type +# endif +#endif + +/* User may want to use these so they are not in PNG_INTERNAL. Any library + * functions that are passed far data must be model independent. + */ + +#ifndef PNG_ABORT +# define PNG_ABORT() abort() +#endif + +#ifdef PNG_SETJMP_SUPPORTED +# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) +#else +# define png_jmpbuf(png_ptr) \ + (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) +#endif + +#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ +/* use this to make far-to-near assignments */ +# define CHECK 1 +# define NOCHECK 0 +# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) +# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) +# define png_snprintf _fsnprintf /* Added to v 1.2.19 */ +# define png_strlen _fstrlen +# define png_memcmp _fmemcmp /* SJT: added */ +# define png_memcpy _fmemcpy +# define png_memset _fmemset +#else /* use the usual functions */ +# define CVT_PTR(ptr) (ptr) +# define CVT_PTR_NOCHECK(ptr) (ptr) +# ifndef PNG_NO_SNPRINTF +# ifdef _MSC_VER +# define png_snprintf _snprintf /* Added to v 1.2.19 */ +# define png_snprintf2 _snprintf +# define png_snprintf6 _snprintf +# else +# define png_snprintf snprintf /* Added to v 1.2.19 */ +# define png_snprintf2 snprintf +# define png_snprintf6 snprintf +# endif +# else + /* You don't have or don't want to use snprintf(). Caution: Using + * sprintf instead of snprintf exposes your application to accidental + * or malevolent buffer overflows. If you don't have snprintf() + * as a general rule you should provide one (you can get one from + * Portable OpenSSH). */ +# define png_snprintf(s1,n,fmt,x1) sprintf(s1,fmt,x1) +# define png_snprintf2(s1,n,fmt,x1,x2) sprintf(s1,fmt,x1,x2) +# define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \ + sprintf(s1,fmt,x1,x2,x3,x4,x5,x6) +# endif +# define png_strlen strlen +# define png_memcmp memcmp /* SJT: added */ +# define png_memcpy memcpy +# define png_memset memset +#endif +/* End of memory model independent support */ + +/* Just a little check that someone hasn't tried to define something + * contradictory. + */ +#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K) +# undef PNG_ZBUF_SIZE +# define PNG_ZBUF_SIZE 65536L +#endif + +/* Added at libpng-1.2.8 */ +#endif /* PNG_VERSION_INFO_ONLY */ + +#endif /* PNGCONF_H */ diff --git a/extlib/zconf.h b/extlib/zconf.h new file mode 100644 index 00000000..03a9431c --- /dev/null +++ b/extlib/zconf.h @@ -0,0 +1,332 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2005 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + */ +#ifdef Z_PREFIX +# define deflateInit_ z_deflateInit_ +# define deflate z_deflate +# define deflateEnd z_deflateEnd +# define inflateInit_ z_inflateInit_ +# define inflate z_inflate +# define inflateEnd z_inflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateSetDictionary z_deflateSetDictionary +# define deflateCopy z_deflateCopy +# define deflateReset z_deflateReset +# define deflateParams z_deflateParams +# define deflateBound z_deflateBound +# define deflatePrime z_deflatePrime +# define inflateInit2_ z_inflateInit2_ +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateCopy z_inflateCopy +# define inflateReset z_inflateReset +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# define uncompress z_uncompress +# define adler32 z_adler32 +# define crc32 z_crc32 +# define get_crc_table z_get_crc_table +# define zError z_zError + +# define alloc_func z_alloc_func +# define free_func z_free_func +# define in_func z_in_func +# define out_func z_out_func +# define Byte z_Byte +# define uInt z_uInt +# define uLong z_uLong +# define Bytef z_Bytef +# define charf z_charf +# define intf z_intf +# define uIntf z_uIntf +# define uLongf z_uLongf +# define voidpf z_voidpf +# define voidp z_voidp +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */ +# include /* for off_t */ +# include /* for SEEK_* and off_t */ +# ifdef VMS +# include /* for off_t */ +# endif +# define z_off_t off_t +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif +#ifndef z_off_t +# define z_off_t long +#endif + +#if defined(__OS400__) +# define NO_vsnprintf +#endif + +#if defined(__MVS__) +# define NO_vsnprintf +# ifdef FAR +# undef FAR +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(deflateBound,"DEBND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(compressBound,"CMBND") +# pragma map(inflate_table,"INTABL") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/extlib/zlib.h b/extlib/zlib.h new file mode 100644 index 00000000..02281792 --- /dev/null +++ b/extlib/zlib.h @@ -0,0 +1,1357 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.3, July 18th, 2005 + + Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.3" +#define ZLIB_VERNUM 0x1230 + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. + + The compressed data format used by default by the in-memory functions is + the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped + around a deflate stream, which is itself documented in RFC 1951. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio using the functions that start + with "gz". The gzip format is different from the zlib format. gzip is a + gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. + + This library can optionally read and write gzip streams in memory as well. + + The zlib format was designed to be compact and fast for use in memory + and on communications channels. The gzip format was designed for single- + file compression on file systems, has a larger header than zlib to maintain + directory information, and uses a different, slower check method than zlib. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never + crash even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: binary or text */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_in holds the total size of + the uncompressed data and may be saved for use in the decompressor + (particularly if the decompressor wants to decompress everything in + a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 +/* Possible values of the data_type field (though see inflate()) */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is + not compatible with the zlib.h header file used by the application. + This check is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. + If zalloc and zfree are set to Z_NULL, deflateInit updates them to + use default allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at + all (the input data is simply copied a block at a time). + Z_DEFAULT_COMPRESSION requests a default compromise between speed and + compression (currently equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if level is not a valid compression level, + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). + msg is set to null if there is no error message. deflateInit does not + perform any compression: this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce some + output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). + Some output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating avail_in or avail_out accordingly; avail_out + should never be zero before the call. The application can consume the + compressed output when it wants, for example when the output buffer is full + (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK + and with zero avail_out, it must be called again after making room in the + output buffer because there might be more output pending. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumualte before producing output, in order to + maximize compression. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In particular + avail_in is zero after the call if enough output space has been provided + before the call.) Flushing may degrade compression for some compression + algorithms and so it should be used only when necessary. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that + avail_out is greater than six to avoid repeated flush markers due to + avail_out == 0 on return. + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there + was enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the + stream are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least + the value returned by deflateBound (see below). If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered + binary. This field is only for information purposes and does not affect + the compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not + fatal, and deflate() can be called again with more input and more output + space to continue compressing. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, + msg may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the exact + value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller. msg is set to null if there is no error + message. inflateInit does not perform any decompression apart from reading + the zlib header if present: this will be done by inflate(). (So next_in and + avail_in may be modified, but next_out and avail_out are unchanged.) +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there + is no more input data or no more space in the output buffer (see below + about the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating the next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). If inflate returns Z_OK and with zero avail_out, it + must be called again after making room in the output buffer because there + might be more output pending. + + The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, + Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much + output as possible to the output buffer. Z_BLOCK requests that inflate() stop + if and when it gets to the next deflate block boundary. When decoding the + zlib or gzip format, this will cause inflate() to return immediately after + the header and before the first block. When doing a raw inflate, inflate() + will go ahead and process the first block, and will return when it gets to + the end of that block, or when it runs out of data. + + The Z_BLOCK option assists in appending to or combining deflate streams. + Also to assist in this, on return inflate() will set strm->data_type to the + number of unused bits in the last byte taken from strm->next_in, plus 64 + if inflate() is currently decoding the last block in the deflate stream, + plus 128 if inflate() returned immediately after decoding an end-of-block + code or decoding the complete header up to just before the first byte of the + deflate stream. The end-of-block will not be indicated until all of the + uncompressed data from that block has been written to strm->next_out. The + number of unused bits may in general be greater than seven, except when + bit 7 of data_type is set, in which case the number of unused bits will be + less than eight. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step + (a single call of inflate), the parameter flush should be set to + Z_FINISH. In this case all pending input is processed and all pending + output is flushed; avail_out must be large enough to hold all the + uncompressed data. (The size of the uncompressed data may have been saved + by the compressor for this purpose.) The next operation on this stream must + be inflateEnd to deallocate the decompression state. The use of Z_FINISH + is never required, but can be used to inform inflate that a faster approach + may be used for the single inflate() call. + + In this implementation, inflate() always flushes as much output as + possible to the output buffer, and always uses the faster approach on the + first call. So the only effect of the flush parameter in this implementation + is on the return value of inflate(), as noted below, or when it returns early + because Z_BLOCK is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary + below), inflate sets strm->adler to the adler32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the adler32 checksum of all output produced so far (that is, + total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described + below. At the end of the stream, inflate() checks that its computed adler32 + checksum is equal to that saved by the compressor and returns Z_STREAM_END + only if the checksum is correct. + + inflate() will decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically. Any information + contained in the gzip header is not retained, so applications that need that + information should instead use raw inflate, see inflateInit2() below, or + inflateBack() and perform their own processing of the gzip header and + trailer. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect check + value), Z_STREAM_ERROR if the stream structure was inconsistent (for example + if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, + Z_BUF_ERROR if no progress is possible or if there was not enough room in the + output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and + inflate() can be called again with more input and more output space to + continue decompressing. If Z_DATA_ERROR is returned, the application may then + call inflateSync() to look for a good compression block if a partial recovery + of the data is desired. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by + the caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + windowBits can also be -8..-15 for raw deflate. In this case, -windowBits + determines the window size. deflate() will then generate raw deflate data + with no zlib header or trailer, and will not compute an adler32 check value. + + windowBits can also be greater than 15 for optional gzip encoding. Add + 16 to windowBits to write a simple gzip header and trailer around the + compressed data instead of a zlib wrapper. The gzip header will have no + file name, no extra data, no comment, no modification time (set to zero), + no header crc, and the operating system will be set to 255 (unknown). If a + gzip stream is being written, strm->adler is a crc32 instead of an adler32. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but + is slow and reduces compression ratio; memLevel=9 uses maximum memory + for optimal speed. The default value is 8. See zconf.h for total memory + usage as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match), or Z_RLE to limit match distances to one (run-length + encoding). Filtered data consists mostly of small values with a somewhat + random distribution. In this case, the compression algorithm is tuned to + compress them better. The effect of Z_FILTERED is to force more Huffman + coding and less string matching; it is somewhat intermediate between + Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as + Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy + parameter only affects the compression ratio but not the correctness of the + compressed output even if it is not set appropriately. Z_FIXED prevents the + use of dynamic Huffman codes, allowing for a simpler decoder for special + applications. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid + method). msg is set to null if there is no error message. deflateInit2 does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. This function must be called + immediately after deflateInit, deflateInit2 or deflateReset, before any + call of deflate. The compressor and decompressor must use exactly the same + dictionary (see inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size in + deflate or deflate2. Thus the strings most likely to be useful should be + put at the end of the dictionary, not at the front. In addition, the + current implementation of deflate will use at most the window size minus + 262 bytes of the provided dictionary. + + Upon return of this function, strm->adler is set to the adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) If a raw deflate was requested, then the + adler32 value is not computed and strm->adler is not set. + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if the compression method is bsort). deflateSetDictionary does not + perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and + can consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. + The stream will keep the same compression level and any other attributes + that may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different + strategy. If the compression level is changed, the input available so far + is compressed with the old level (and may be flushed); the new level will + take effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to + be compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR + if strm->avail_out was zero. +*/ + +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); +/* + Fine tune deflate's internal compression parameters. This should only be + used by someone who understands the algorithm used by zlib's deflate for + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, + uLong sourceLen)); +/* + deflateBound() returns an upper bound on the compressed size after + deflation of sourceLen bytes. It must be called after deflateInit() + or deflateInit2(). This would be used to allocate an output buffer + for deflation in a single pass, and so would be called before deflate(). +*/ + +ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + deflatePrime() inserts bits in the deflate output stream. The intent + is that this function is used to start off the deflate output with the + bits leftover from a previous deflate stream when appending to it. As such, + this function can only be used for raw deflate, and must be used before the + first deflate() call after a deflateInit2() or deflateReset(). bits must be + less than or equal to 16, and that many of the least significant bits of + value will be inserted in the output. + + deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + gzip file" and give up. + + If deflateSetHeader is not used, the default gzip header has text false, + the time set to zero, and os set to 255, with no extra, name, or comment + fields. The gzip header is returned to the default state by deflateReset(). + + deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. windowBits must be greater than or equal to the windowBits value + provided to deflateInit2() while compressing, or it must be equal to 15 if + deflateInit2() was not used. If a compressed stream with a larger window + size is given as input, inflate() will return with the error code + Z_DATA_ERROR instead of trying to allocate a larger window. + + windowBits can also be -8..-15 for raw inflate. In this case, -windowBits + determines the window size. inflate() will then process raw deflate data, + not looking for a zlib or gzip header, not generating a check value, and not + looking for any check values for comparison at the end of the stream. This + is for use with other formats that use the deflate compressed data format + such as zip. Those formats provide their own check values. If a custom + format is developed using the raw deflate format for compressed data, it is + recommended that a check value such as an adler32 or a crc32 be applied to + the uncompressed data as is done in the zlib, gzip, and zip formats. For + most applications, the zlib format should be used as is. Note that comments + above on the use in deflateInit2() applies to the magnitude of windowBits. + + windowBits can also be greater than 15 for optional gzip decoding. Add + 32 to windowBits to enable zlib and gzip decoding with automatic header + detection, or add 16 to decode only the gzip format (the zlib format will + return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is + a crc32 instead of an adler32. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg + is set to null if there is no error message. inflateInit2 does not perform + any decompression apart from reading the zlib header if present: this will + be done by inflate(). (So next_in and avail_in may be modified, but next_out + and avail_out are unchanged.) +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate, + if that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the adler32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called + immediately after inflateInit2() or inflateReset() and before any call of + inflate() to set the dictionary. The application must insure that the + dictionary that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a full flush point (see above the + description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR + if no more input was provided, Z_DATA_ERROR if no flush point has been found, + or Z_STREAM_ERROR if the stream structure was inconsistent. In the success + case, the application may save the current current value of total_in which + indicates where valid compressed data was found. In the error case, the + application may repeatedly call inflateSync, providing more input each time, + until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when randomly accessing a large stream. The + first pass through the stream can periodically record the inflate state, + allowing restarting inflate at those points when randomly accessing the + stream. + + inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. + The stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + This function inserts bits in the inflate input stream. The intent is + that this function is used to start inflating at a bit position in the + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); +/* + inflateGetHeader() requests that gzip header information be stored in the + provided gz_header structure. inflateGetHeader() may be called after + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK can be used to + force inflate() to return immediately after header processing is complete + and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When + any of extra, name, or comment are not Z_NULL and the respective field is + not present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, + unsigned char FAR *window)); + + Initialize the internal stream state for decompression using inflateBack() + calls. The fields zalloc, zfree and opaque in strm must be initialized + before the call. If zalloc and zfree are Z_NULL, then the default library- + derived memory allocation routines are used. windowBits is the base two + logarithm of the window size, in the range 8..15. window is a caller + supplied buffer of that size. Except for special applications where it is + assured that deflate was used with small window sizes, windowBits must be 15 + and a 32K byte window must be supplied to be able to decompress general + deflate streams. + + See inflateBack() for the usage of these routines. + + inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of + the paramaters are invalid, Z_MEM_ERROR if the internal state could not + be allocated, or Z_VERSION_ERROR if the version of the library does not + match the version of the header file. +*/ + +typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); + +ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc)); +/* + inflateBack() does a raw inflate with a single call using a call-back + interface for input and output. This is more efficient than inflate() for + file i/o applications in that it avoids copying between the output and the + sliding window by simply making the window itself the output buffer. This + function trusts the application to not change the output buffer passed by + the output function, at least until inflateBack() returns. + + inflateBackInit() must be called first to allocate the internal state + and to initialize the state with the user-provided window buffer. + inflateBack() may then be used multiple times to inflate a complete, raw + deflate stream with each call. inflateBackEnd() is then called to free + the allocated state. + + A raw deflate stream is one with no zlib or gzip header or trailer. + This routine would normally be used in a utility that reads zip or gzip + files and writes out uncompressed files. The utility would decode the + header and process the trailer on its own, hence this routine expects + only the raw deflate stream to decompress. This is different from the + normal behavior of inflate(), which expects either a zlib or gzip header and + trailer around the deflate stream. + + inflateBack() uses two subroutines supplied by the caller that are then + called by inflateBack() for input and output. inflateBack() calls those + routines until it reads a complete deflate stream and writes out all of the + uncompressed data, or until it encounters an error. The function's + parameters and return types are defined above in the in_func and out_func + typedefs. inflateBack() will call in(in_desc, &buf) which should return the + number of bytes of provided input, and a pointer to that input in buf. If + there is no input available, in() must return zero--buf is ignored in that + case--and inflateBack() will return a buffer error. inflateBack() will call + out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() + should return zero on success, or non-zero on failure. If out() returns + non-zero, inflateBack() will return with an error. Neither in() nor out() + are permitted to change the contents of the window provided to + inflateBackInit(), which is also the buffer that out() uses to write from. + The length written by out() will be at most the window size. Any non-zero + amount of input may be provided by in(). + + For convenience, inflateBack() can be provided input on the first call by + setting strm->next_in and strm->avail_in. If that input is exhausted, then + in() will be called. Therefore strm->next_in must be initialized before + calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called + immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in + must also be initialized, and then if strm->avail_in is not zero, input will + initially be taken from strm->next_in[0 .. strm->avail_in - 1]. + + The in_desc and out_desc parameters of inflateBack() is passed as the + first parameter of in() and out() respectively when they are called. These + descriptors can be optionally used to pass any information that the caller- + supplied in() and out() functions need to do their job. + + On return, inflateBack() will set strm->next_in and strm->avail_in to + pass back any unused input that was provided by the last in() call. The + return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR + if in() or out() returned an error, Z_DATA_ERROR if there was a format + error in the deflate stream (in which case strm->msg is set to indicate the + nature of the error), or Z_STREAM_ERROR if the stream was not properly + initialized. In the case of Z_BUF_ERROR, an input or output error can be + distinguished using strm->next_in which will be Z_NULL only if in() returned + an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to + out() returning non-zero. (in() will always be called before out(), so + strm->next_in is assured to be defined if out() returns non-zero.) Note + that inflateBack() cannot return Z_OK. +*/ + +ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); +/* + All memory allocated by inflateBackInit() is freed. + + inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream + state was inconsistent. +*/ + +ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +/* Return flags indicating compile-time options. + + Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: + 1.0: size of uInt + 3.2: size of uLong + 5.4: size of voidpf (pointer) + 7.6: size of z_off_t + + Compiler, assembler, and debug options: + 8: DEBUG + 9: ASMV or ASMINF -- use ASM code + 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention + 11: 0 (reserved) + + One-time table building (smaller code, but not thread-safe if true): + 12: BUILDFIXED -- build static block decoding tables when needed + 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed + 14,15: 0 (reserved) + + Library content (indicates missing functionality): + 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking + deflate code when not needed) + 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect + and decode gzip streams (to avoid linking crc code) + 18-19: 0 (reserved) + + Operation variations (changes in library functionality): + 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate + 21: FASTEST -- deflate algorithm with only one, lowest compression level + 22,23: 0 (reserved) + + The sprintf variant used by gzprintf (zero is best): + 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format + 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! + 26: 0 = returns value, 1 = void -- 1 means inferred string length returned + + Remainder: + 27-31: 0 (reserved) + */ + + + /* utility functions */ + +/* + The following utility functions are implemented on top of the + basic stream-oriented functions. To simplify the interface, some + default options are assumed (compression level and memory usage, + standard memory allocation functions). The source code of these + utility functions can easily be modified if you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be at least the value returned + by compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + This function can be used to compress a whole file at once if the + input file is mmap'ed. + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); +/* + compressBound() returns an upper bound on the compressed size after + compress() or compress2() on sourceLen bytes. It would be used before + a compress() or compress2() call to allocate the destination buffer. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + This function can be used to decompress a whole file at once if the + input file is mmap'ed. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. +*/ + + +typedef voidp gzFile; + +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +/* + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb") but can also include a compression level + ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for + Huffman only compression as in "wb1h", or 'R' for run-length encoding + as in "wb1R". (See the description of deflateInit2 for more information + about the strategy parameter.) + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. + + gzopen returns NULL if the file could not be opened or if there was + insufficient memory to allocate the (de)compression state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). */ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen() associates a gzFile with the file descriptor fd. File + descriptors are obtained from calls like open, dup, creat, pipe or + fileno (in the file has been previously opened with fopen). + The mode parameter is as in gzopen. + The next call of gzclose on the returned gzFile will also close the + file descriptor fd, just like fclose(fdopen(fd), mode) closes the file + descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). + gzdopen returns NULL if there was insufficient memory to allocate + the (de)compression state. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. + If the input file was not in gzip format, gzread copies the given number + of bytes into the buffer. + gzread returns the number of uncompressed bytes actually read (0 for + end of file, -1 for error). */ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + voidpc buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes actually written + (0 in case of error). +*/ + +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the args to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written (0 in case of error). The number of + uncompressed bytes written is limited to 4095. The caller should assure that + this limit is not exceeded. If it is exceeded, then gzprintf() will return + return an error (0) with nothing written. In this case, there may also be a + buffer overflow with unpredictable consequences, which is possible only if + zlib was compiled with the insecure functions sprintf() or vsprintf() + because the secure snprintf() or vsnprintf() functions were not available. +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or + a newline character is read and transferred to buf, or an end-of-file + condition is encountered. The string is then terminated with a null + character. + gzgets returns buf, or Z_NULL in case of error. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. + gzputc returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte + or -1 in case of end of file or error. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read again later. + Only one character of push-back is allowed. gzungetc() returns the + character pushed, or -1 on failure. gzungetc() will fail if a + character has been pushed but not read yet, or if c is -1. The pushed + character will be discarded if the stream is repositioned with gzseek() + or gzrewind(). +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter + flush is as in the deflate() function. The return value is the zlib + error number (see function gzerror below). gzflush returns Z_OK if + the flush parameter is Z_FINISH and all output could be flushed. + gzflush should be called only when strictly necessary because it can + degrade compression. +*/ + +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); +/* + Sets the starting position for the next gzread or gzwrite on the + given compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +/* + Returns the starting position for the next gzread or gzwrite on the + given compressed file. This position represents a number of bytes in the + uncompressed data stream. + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns 1 when EOF has previously been detected reading the given + input stream, otherwise zero. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns 1 if file is being read directly without decompression, otherwise + zero. +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file + and deallocates all the (de)compression state. The return value is the zlib + error number (see function gzerror below). +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the + given compressed file. errnum is set to zlib error number. If an + error occurred in the file system and not in the compression library, + errnum is set to Z_ERRNO and the application may consult errno + to get the exact error code. +*/ + +ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +/* + Clears the error and end-of-file flags for file. This is analogous to the + clearerr() function in stdio. This is useful for continuing to read a gzip + file that is being written concurrently. +*/ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the + compression library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is NULL, this function returns + the required initial value for the checksum. + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, + z_off_t len2)); +/* + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is NULL, this function returns the required initial + value for the for the crc. Pre- and post-conditioning (one's complement) is + performed within this function so it shouldn't be done by the application. + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); + +/* + Combine two CRC-32 check values into one. For two sequences of bytes, + seq1 and seq2 with lengths len1 and len2, CRC-32 check values were + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) +#define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, sizeof(z_stream)) + + +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ diff --git a/extlib/zlib.lib b/extlib/zlib.lib new file mode 100644 index 0000000000000000000000000000000000000000..307bd088a5b7ed4484d151503888ef1c69d0c785 GIT binary patch literal 100642 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 SolveSpace SS; @@ -460,6 +461,54 @@ void SolveSpace::SolveGroup(hGroup hg) { FreeAllTemporary(); } +void SolveSpace::ExportAsPngTo(char *filename) { + int w = (int)SS.GW.width, h = (int)SS.GW.height; + // No guarantee that the back buffer contains anything valid right now, + // so repaint the scene. + SS.GW.Paint(w, h); + + FILE *f = fopen(filename, "wb"); + if(!f) goto err; + + png_struct *png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, + NULL, NULL, NULL); + if(!png_ptr) goto err; + + png_info *info_ptr = png_create_info_struct(png_ptr); + if(!png_ptr) goto err; + + if(setjmp(png_jmpbuf(png_ptr))) goto err; + + png_init_io(png_ptr, f); + + png_set_IHDR(png_ptr, info_ptr, w, h, + 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, + PNG_COMPRESSION_TYPE_DEFAULT,PNG_FILTER_TYPE_DEFAULT); + + png_write_info(png_ptr, info_ptr); + + // Get the pixel data from the framebuffer + BYTE *pixels = (BYTE *)AllocTemporary(3*w*h); + BYTE **rowptrs = (BYTE **)AllocTemporary(h*sizeof(BYTE *)); + glReadPixels(0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, pixels); + + int y; + for(y = 0; y < h; y++) { + // gl puts the origin at lower left, but png puts it top left + rowptrs[y] = pixels + ((h - 1) - y)*(3*w); + } + png_write_image(png_ptr, rowptrs); + + png_write_end(png_ptr, info_ptr); + png_destroy_write_struct(&png_ptr, &info_ptr); + return; + +err: + Error("Error writing PNG file '%s'", filename); + if(f) fclose(f); + return; +} + void SolveSpace::RemoveFromRecentList(char *file) { int src, dest; dest = 0; @@ -568,6 +617,13 @@ void SolveSpace::MenuFile(int id) { SS.GetFilenameAndSave(true); break; + case GraphicsWindow::MNU_EXPORT_PNG: { + char exportFile[MAX_PATH] = ""; + if(!GetSaveFile(exportFile, PNG_EXT, PNG_PATTERN)) break; + SS.ExportAsPngTo(exportFile); + break; + } + case GraphicsWindow::MNU_EXIT: if(!SS.OkayToStartNewFile()) break; SS.Exit(); diff --git a/solvespace.h b/solvespace.h index e73fcb87..da593a08 100644 --- a/solvespace.h +++ b/solvespace.h @@ -54,6 +54,8 @@ void RefreshRecentMenus(void); int SaveFileYesNoCancel(void); #define SLVS_PATTERN "SolveSpace Models (*.slvs)\0*.slvs\0All Files (*)\0*\0\0" #define SLVS_EXT "slvs" +#define PNG_PATTERN "PNG (*.png)\0*.png\0All Files (*)\0*\0\0" +#define PNG_EXT "png" BOOL GetSaveFile(char *file, char *defExtension, char *selPattern); BOOL GetOpenFile(char *file, char *defExtension, char *selPattern); @@ -302,6 +304,8 @@ public: bool LoadFromFile(char *filename); bool LoadEntitiesFromFile(char *filename, EntityList *le, SMesh *m); void ReloadAllImported(void); + // And the PNG export too + void ExportAsPngTo(char *file); void MarkGroupDirty(hGroup hg); void MarkGroupDirtyByEntity(hEntity he); diff --git a/ui.h b/ui.h index 32f5853c..416686c5 100644 --- a/ui.h +++ b/ui.h @@ -133,6 +133,7 @@ public: MNU_OPEN_RECENT, MNU_SAVE, MNU_SAVE_AS, + MNU_EXPORT_PNG, MNU_EXIT, // View MNU_ZOOM_IN, diff --git a/wishlist.txt b/wishlist.txt index 8ebc156a..190149e9 100644 --- a/wishlist.txt +++ b/wishlist.txt @@ -5,7 +5,6 @@ DXF export TTF font text some kind of rounding / chamfer remove back button in browser? -graphic export relative paths for import auto-generate circles and faces when lathing