From 3b6dae092bb839bf612df123ddf6c0cb11d849c1 Mon Sep 17 00:00:00 2001 From: Spoike Date: Tue, 14 Sep 2004 06:51:31 +0000 Subject: [PATCH] library files so people can just update and compile straight away. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@208 fc73d0e0-1445-4013-8a0c-d673dee63da5 --- engine/libs/jconfig.h | 45 + engine/libs/jerror.h | 291 ++++ engine/libs/jmorecfg.h | 374 +++++ engine/libs/jpeg.lib | Bin 0 -> 229998 bytes engine/libs/jpeglib.h | 1096 ++++++++++++++ engine/libs/libpng.lib | Bin 0 -> 302658 bytes engine/libs/png.h | 3278 ++++++++++++++++++++++++++++++++++++++++ engine/libs/pngconf.h | 1348 +++++++++++++++++ engine/libs/zconf.h | 280 ++++ engine/libs/zlib.h | 893 +++++++++++ engine/libs/zlib.lib | Bin 0 -> 69576 bytes 11 files changed, 7605 insertions(+) create mode 100644 engine/libs/jconfig.h create mode 100644 engine/libs/jerror.h create mode 100644 engine/libs/jmorecfg.h create mode 100644 engine/libs/jpeg.lib create mode 100644 engine/libs/jpeglib.h create mode 100644 engine/libs/libpng.lib create mode 100644 engine/libs/png.h create mode 100644 engine/libs/pngconf.h create mode 100644 engine/libs/zconf.h create mode 100644 engine/libs/zlib.h create mode 100644 engine/libs/zlib.lib diff --git a/engine/libs/jconfig.h b/engine/libs/jconfig.h new file mode 100644 index 000000000..7e291c75b --- /dev/null +++ b/engine/libs/jconfig.h @@ -0,0 +1,45 @@ +/* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */ +/* see jconfig.doc for explanations */ + +#define HAVE_PROTOTYPES +#define HAVE_UNSIGNED_CHAR +#define HAVE_UNSIGNED_SHORT +/* #define void char */ +/* #define const */ +#undef CHAR_IS_UNSIGNED +#define HAVE_STDDEF_H +#define HAVE_STDLIB_H +#undef NEED_BSD_STRINGS +#undef NEED_SYS_TYPES_H +#undef NEED_FAR_POINTERS /* we presume a 32-bit flat memory model */ +#undef NEED_SHORT_EXTERNAL_NAMES +#undef INCOMPLETE_TYPES_BROKEN + +/* Define "boolean" as unsigned char, not int, per Windows custom */ +#ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */ +typedef unsigned char boolean; +#endif +#define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */ + + +#ifdef JPEG_INTERNALS + +#undef RIGHT_SHIFT_IS_UNSIGNED + +#endif /* JPEG_INTERNALS */ + +#ifdef JPEG_CJPEG_DJPEG + +#define BMP_SUPPORTED /* BMP image file format */ +#define GIF_SUPPORTED /* GIF image file format */ +#define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ +#undef RLE_SUPPORTED /* Utah RLE image file format */ +#define TARGA_SUPPORTED /* Targa image file format */ + +#define TWO_FILE_COMMANDLINE /* optional */ +#define USE_SETMODE /* Microsoft has setmode() */ +#undef NEED_SIGNAL_CATCHER +#undef DONT_USE_B_MODE +#undef PROGRESS_REPORT /* optional */ + +#endif /* JPEG_CJPEG_DJPEG */ diff --git a/engine/libs/jerror.h b/engine/libs/jerror.h new file mode 100644 index 000000000..fc2fffeac --- /dev/null +++ b/engine/libs/jerror.h @@ -0,0 +1,291 @@ +/* + * jerror.h + * + * Copyright (C) 1994-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file defines the error and message codes for the JPEG library. + * Edit this file to add new codes, or to translate the message strings to + * some other language. + * A set of error-reporting macros are defined too. Some applications using + * the JPEG library may wish to include this file to get the error codes + * and/or the macros. + */ + +/* + * To define the enum list of message codes, include this file without + * defining macro JMESSAGE. To create a message string table, include it + * again with a suitable JMESSAGE definition (see jerror.c for an example). + */ +#ifndef JMESSAGE +#ifndef JERROR_H +/* First time through, define the enum list */ +#define JMAKE_ENUM_LIST +#else +/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */ +#define JMESSAGE(code,string) +#endif /* JERROR_H */ +#endif /* JMESSAGE */ + +#ifdef JMAKE_ENUM_LIST + +typedef enum { + +#define JMESSAGE(code,string) code , + +#endif /* JMAKE_ENUM_LIST */ + +JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */ + +/* For maintenance convenience, list is alphabetical by message code name */ +JMESSAGE(JERR_ARITH_NOTIMPL, + "Sorry, there are legal restrictions on arithmetic coding") +JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix") +JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix") +JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode") +JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS") +JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range") +JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported") +JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition") +JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace") +JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace") +JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length") +JMESSAGE(JERR_BAD_LIB_VERSION, + "Wrong JPEG library version: library is %d, caller expects %d") +JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan") +JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d") +JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d") +JMESSAGE(JERR_BAD_PROGRESSION, + "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d") +JMESSAGE(JERR_BAD_PROG_SCRIPT, + "Invalid progressive parameters at scan script entry %d") +JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors") +JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d") +JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d") +JMESSAGE(JERR_BAD_STRUCT_SIZE, + "JPEG parameter struct mismatch: library thinks size is %u, caller expects %u") +JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access") +JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small") +JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here") +JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet") +JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d") +JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request") +JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d") +JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x") +JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d") +JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d") +JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)") +JMESSAGE(JERR_EMS_READ, "Read from EMS failed") +JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed") +JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan") +JMESSAGE(JERR_FILE_READ, "Input file read error") +JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?") +JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet") +JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow") +JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry") +JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels") +JMESSAGE(JERR_INPUT_EMPTY, "Empty input file") +JMESSAGE(JERR_INPUT_EOF, "Premature end of input file") +JMESSAGE(JERR_MISMATCHED_QUANT_TABLE, + "Cannot transcode due to multiple use of quantization table %d") +JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data") +JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change") +JMESSAGE(JERR_NOTIMPL, "Not implemented yet") +JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time") +JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported") +JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined") +JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image") +JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined") +JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x") +JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)") +JMESSAGE(JERR_QUANT_COMPONENTS, + "Cannot quantize more than %d color components") +JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors") +JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors") +JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers") +JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker") +JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x") +JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers") +JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF") +JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s") +JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file") +JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file") +JMESSAGE(JERR_TFILE_WRITE, + "Write failed on temporary file --- out of disk space?") +JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines") +JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x") +JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up") +JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation") +JMESSAGE(JERR_XMS_READ, "Read from XMS failed") +JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed") +JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT) +JMESSAGE(JMSG_VERSION, JVERSION) +JMESSAGE(JTRC_16BIT_TABLES, + "Caution: quantization tables are too coarse for baseline JPEG") +JMESSAGE(JTRC_ADOBE, + "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d") +JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u") +JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u") +JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x") +JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x") +JMESSAGE(JTRC_DQT, "Define Quantization Table %d precision %d") +JMESSAGE(JTRC_DRI, "Define Restart Interval %u") +JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u") +JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u") +JMESSAGE(JTRC_EOI, "End Of Image") +JMESSAGE(JTRC_HUFFBITS, " %3d %3d %3d %3d %3d %3d %3d %3d") +JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d %d") +JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE, + "Warning: thumbnail image size does not match data length %u") +JMESSAGE(JTRC_JFIF_EXTENSION, + "JFIF extension marker: type 0x%02x, length %u") +JMESSAGE(JTRC_JFIF_THUMBNAIL, " with %d x %d thumbnail image") +JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u") +JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x") +JMESSAGE(JTRC_QUANTVALS, " %4u %4u %4u %4u %4u %4u %4u %4u") +JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors") +JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors") +JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization") +JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d") +JMESSAGE(JTRC_RST, "RST%d") +JMESSAGE(JTRC_SMOOTH_NOTIMPL, + "Smoothing not supported with nonstandard sampling ratios") +JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d") +JMESSAGE(JTRC_SOF_COMPONENT, " Component %d: %dhx%dv q=%d") +JMESSAGE(JTRC_SOI, "Start of Image") +JMESSAGE(JTRC_SOS, "Start Of Scan: %d components") +JMESSAGE(JTRC_SOS_COMPONENT, " Component %d: dc=%d ac=%d") +JMESSAGE(JTRC_SOS_PARAMS, " Ss=%d, Se=%d, Ah=%d, Al=%d") +JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s") +JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s") +JMESSAGE(JTRC_THUMB_JPEG, + "JFIF extension marker: JPEG-compressed thumbnail image, length %u") +JMESSAGE(JTRC_THUMB_PALETTE, + "JFIF extension marker: palette thumbnail image, length %u") +JMESSAGE(JTRC_THUMB_RGB, + "JFIF extension marker: RGB thumbnail image, length %u") +JMESSAGE(JTRC_UNKNOWN_IDS, + "Unrecognized component IDs %d %d %d, assuming YCbCr") +JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u") +JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u") +JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d") +JMESSAGE(JWRN_BOGUS_PROGRESSION, + "Inconsistent progression sequence for component %d coefficient %d") +JMESSAGE(JWRN_EXTRANEOUS_DATA, + "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x") +JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment") +JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code") +JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d") +JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file") +JMESSAGE(JWRN_MUST_RESYNC, + "Corrupt JPEG data: found marker 0x%02x instead of RST%d") +JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG") +JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines") + +#ifdef JMAKE_ENUM_LIST + + JMSG_LASTMSGCODE +} J_MESSAGE_CODE; + +#undef JMAKE_ENUM_LIST +#endif /* JMAKE_ENUM_LIST */ + +/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */ +#undef JMESSAGE + + +#ifndef JERROR_H +#define JERROR_H + +/* Macros to simplify using the error and trace message stuff */ +/* The first parameter is either type of cinfo pointer */ + +/* Fatal errors (print message and exit) */ +#define ERREXIT(cinfo,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT1(cinfo,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT2(cinfo,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT3(cinfo,code,p1,p2,p3) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (cinfo)->err->msg_parm.i[2] = (p3), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT4(cinfo,code,p1,p2,p3,p4) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (cinfo)->err->msg_parm.i[2] = (p3), \ + (cinfo)->err->msg_parm.i[3] = (p4), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXITS(cinfo,code,str) \ + ((cinfo)->err->msg_code = (code), \ + strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) + +#define MAKESTMT(stuff) do { stuff } while (0) + +/* Nonfatal errors (we can keep going, but the data is probably corrupt) */ +#define WARNMS(cinfo,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) +#define WARNMS1(cinfo,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) +#define WARNMS2(cinfo,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) + +/* Informational/debugging messages */ +#define TRACEMS(cinfo,lvl,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS1(cinfo,lvl,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS2(cinfo,lvl,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS3(cinfo,lvl,code,p1,p2,p3) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + _mp[4] = (p5); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMSS(cinfo,lvl,code,str) \ + ((cinfo)->err->msg_code = (code), \ + strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) + +#endif /* JERROR_H */ diff --git a/engine/libs/jmorecfg.h b/engine/libs/jmorecfg.h new file mode 100644 index 000000000..55a37a301 --- /dev/null +++ b/engine/libs/jmorecfg.h @@ -0,0 +1,374 @@ +/* + * jmorecfg.h + * + * Copyright (C) 1991-1997, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file contains additional configuration options that customize the + * JPEG software for special applications or support machine-dependent + * optimizations. Most users will not need to touch this file. + */ + + +/* + * Define BITS_IN_JSAMPLE as either + * 8 for 8-bit sample values (the usual setting) + * 12 for 12-bit sample values + * Only 8 and 12 are legal data precisions for lossy JPEG according to the + * JPEG standard, and the IJG code does not support anything else! + * We do not support run-time selection of data precision, sorry. + */ + +// mh - disable silly warning +#pragma warning( disable : 4142 ) + +#define BITS_IN_JSAMPLE 8 /* use 8 or 12 */ + + +/* + * Maximum number of components (color channels) allowed in JPEG image. + * To meet the letter of the JPEG spec, set this to 255. However, darn + * few applications need more than 4 channels (maybe 5 for CMYK + alpha + * mask). We recommend 10 as a reasonable compromise; use 4 if you are + * really short on memory. (Each allowed component costs a hundred or so + * bytes of storage, whether actually used in an image or not.) + */ + +#define MAX_COMPONENTS 10 /* maximum number of image components */ + + +/* + * Basic data types. + * You may need to change these if you have a machine with unusual data + * type sizes; for example, "char" not 8 bits, "short" not 16 bits, + * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits, + * but it had better be at least 16. + */ + +/* Representation of a single sample (pixel element value). + * We frequently allocate large arrays of these, so it's important to keep + * them small. But if you have memory to burn and access to char or short + * arrays is very slow on your hardware, you might want to change these. + */ + +#if BITS_IN_JSAMPLE == 8 +/* JSAMPLE should be the smallest type that will hold the values 0..255. + * You can use a signed char by having GETJSAMPLE mask it with 0xFF. + */ + +#ifdef HAVE_UNSIGNED_CHAR + +typedef unsigned char JSAMPLE; +#define GETJSAMPLE(value) ((int) (value)) + +#else /* not HAVE_UNSIGNED_CHAR */ + +typedef char JSAMPLE; +#ifdef CHAR_IS_UNSIGNED +#define GETJSAMPLE(value) ((int) (value)) +#else +#define GETJSAMPLE(value) ((int) (value) & 0xFF) +#endif /* CHAR_IS_UNSIGNED */ + +#endif /* HAVE_UNSIGNED_CHAR */ + +#define MAXJSAMPLE 255 +#define CENTERJSAMPLE 128 + +#endif /* BITS_IN_JSAMPLE == 8 */ + + +#if BITS_IN_JSAMPLE == 12 +/* JSAMPLE should be the smallest type that will hold the values 0..4095. + * On nearly all machines "short" will do nicely. + */ + +typedef short JSAMPLE; +#define GETJSAMPLE(value) ((int) (value)) + +#define MAXJSAMPLE 4095 +#define CENTERJSAMPLE 2048 + +#endif /* BITS_IN_JSAMPLE == 12 */ + + +/* Representation of a DCT frequency coefficient. + * This should be a signed value of at least 16 bits; "short" is usually OK. + * Again, we allocate large arrays of these, but you can change to int + * if you have memory to burn and "short" is really slow. + */ + +typedef short JCOEF; + + +/* Compressed datastreams are represented as arrays of JOCTET. + * These must be EXACTLY 8 bits wide, at least once they are written to + * external storage. Note that when using the stdio data source/destination + * managers, this is also the data type passed to fread/fwrite. + */ + +#ifdef HAVE_UNSIGNED_CHAR + +typedef unsigned char JOCTET; +#define GETJOCTET(value) (value) + +#else /* not HAVE_UNSIGNED_CHAR */ + +typedef char JOCTET; +#ifdef CHAR_IS_UNSIGNED +#define GETJOCTET(value) (value) +#else +#define GETJOCTET(value) ((value) & 0xFF) +#endif /* CHAR_IS_UNSIGNED */ + +#endif /* HAVE_UNSIGNED_CHAR */ + + +/* These typedefs are used for various table entries and so forth. + * They must be at least as wide as specified; but making them too big + * won't cost a huge amount of memory, so we don't provide special + * extraction code like we did for JSAMPLE. (In other words, these + * typedefs live at a different point on the speed/space tradeoff curve.) + */ + +/* UINT8 must hold at least the values 0..255. */ + +#ifdef HAVE_UNSIGNED_CHAR +typedef unsigned char UINT8; +#else /* not HAVE_UNSIGNED_CHAR */ +#ifdef CHAR_IS_UNSIGNED +typedef char UINT8; +#else /* not CHAR_IS_UNSIGNED */ +typedef short UINT8; +#endif /* CHAR_IS_UNSIGNED */ +#endif /* HAVE_UNSIGNED_CHAR */ + +/* UINT16 must hold at least the values 0..65535. */ + +#ifdef HAVE_UNSIGNED_SHORT +typedef unsigned short UINT16; +#else /* not HAVE_UNSIGNED_SHORT */ +typedef unsigned int UINT16; +#endif /* HAVE_UNSIGNED_SHORT */ + +/* INT16 must hold at least the values -32768..32767. */ + +#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */ +typedef short INT16; +#endif + +/* INT32 must hold at least signed 32-bit values. */ + +#ifndef XMD_H /* X11/xmd.h correctly defines INT32 */ +typedef long INT32; +#endif + +/* Datatype used for image dimensions. The JPEG standard only supports + * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore + * "unsigned int" is sufficient on all machines. However, if you need to + * handle larger images and you don't mind deviating from the spec, you + * can change this datatype. + */ + +typedef unsigned int JDIMENSION; + +#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */ + + +/* These macros are used in all function definitions and extern declarations. + * You could modify them if you need to change function linkage conventions; + * in particular, you'll need to do that to make the library a Windows DLL. + * Another application is to make all functions global for use with debuggers + * or code profilers that require it. + */ + +#ifndef JPEG_API +#define JPEG_API +#endif + +/* a function called through method pointers: */ +#define METHODDEF(type) static type JPEG_API +/* a function used only in its module: */ +#define LOCAL(type) static type JPEG_API +/* a function referenced thru EXTERNs: */ +#define GLOBAL(type) type JPEG_API +/* a reference to a GLOBAL function: */ +#define EXTERN(type) extern type JPEG_API + + +/* This macro is used to declare a "method", that is, a function pointer. + * We want to supply prototype parameters if the compiler can cope. + * Note that the arglist parameter must be parenthesized! + * Again, you can customize this if you need special linkage keywords. + */ + +#ifdef HAVE_PROTOTYPES +#define JMETHOD(type,methodname,arglist) type (JPEG_API *methodname) arglist +#else +#define JMETHOD(type,methodname,arglist) type (JPEG_API *methodname) () +#endif + + +/* Here is the pseudo-keyword for declaring pointers that must be "far" + * on 80x86 machines. Most of the specialized coding for 80x86 is handled + * by just saying "FAR *" where such a pointer is needed. In a few places + * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol. + */ + +// mfah - FAR is already defined in windef.h for glquake so i removed this block +// later - should have read the documentation fully first... sigh... +#ifdef NEED_FAR_POINTERS +#define FAR far +#else +#ifndef FAR +#define FAR +#endif +#endif + + +/* + * On a few systems, type boolean and/or its values FALSE, TRUE may appear + * in standard header files. Or you may have conflicts with application- + * specific header files that you want to include together with these files. + * Defining HAVE_BOOLEAN before including jpeglib.h should make it work. + */ + +#ifndef HAVE_BOOLEAN +typedef int boolean; +#endif +#ifndef FALSE /* in case these macros already exist */ +#define FALSE 0 /* values of boolean */ +#endif +#ifndef TRUE +#define TRUE 1 +#endif + + +/* + * The remaining options affect code selection within the JPEG library, + * but they don't need to be visible to most applications using the library. + * To minimize application namespace pollution, the symbols won't be + * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined. + */ + +#ifdef JPEG_INTERNALS +#define JPEG_INTERNAL_OPTIONS +#endif + +#ifdef JPEG_INTERNAL_OPTIONS + + +/* + * These defines indicate whether to include various optional functions. + * Undefining some of these symbols will produce a smaller but less capable + * library. Note that you can leave certain source files out of the + * compilation/linking process if you've #undef'd the corresponding symbols. + * (You may HAVE to do that if your compiler doesn't like null source files.) + */ + +/* Arithmetic coding is unsupported for legal reasons. Complaints to IBM. */ + +/* Capability options common to encoder and decoder: */ + +#define DCT_ISLOW_SUPPORTED /* slow but accurate integer algorithm */ +#define DCT_IFAST_SUPPORTED /* faster, less accurate integer method */ +#define DCT_FLOAT_SUPPORTED /* floating-point: accurate, fast on fast HW */ + +/* Encoder capability options: */ + +#undef C_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ +#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */ +/* Note: if you selected 12-bit data precision, it is dangerous to turn off + * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit + * precision, so jchuff.c normally uses entropy optimization to compute + * usable tables for higher precision. If you don't want to do optimization, + * you'll have to supply different default Huffman tables. + * The exact same statements apply for progressive JPEG: the default tables + * don't work for progressive mode. (This may get fixed, however.) + */ +#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */ + +/* Decoder capability options: */ + +#undef D_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ +#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */ +#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */ +#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */ +#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */ +#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */ +#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */ +#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */ + +/* more capability options later, no doubt */ + + +/* + * Ordering of RGB data in scanlines passed to or from the application. + * If your application wants to deal with data in the order B,G,R, just + * change these macros. You can also deal with formats such as R,G,B,X + * (one extra byte per pixel) by changing RGB_PIXELSIZE. Note that changing + * the offsets will also change the order in which colormap data is organized. + * RESTRICTIONS: + * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats. + * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not + * useful if you are using JPEG color spaces other than YCbCr or grayscale. + * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE + * is not 3 (they don't understand about dummy color components!). So you + * can't use color quantization if you change that value. + */ + +#define RGB_RED 0 /* Offset of Red in an RGB scanline element */ +#define RGB_GREEN 1 /* Offset of Green */ +#define RGB_BLUE 2 /* Offset of Blue */ +#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */ + + +/* Definitions for speed-related optimizations. */ + + +/* If your compiler supports inline functions, define INLINE + * as the inline keyword; otherwise define it as empty. + */ + +#ifndef INLINE +#ifdef __GNUC__ /* for instance, GNU C knows about inline */ +#define INLINE __inline__ +#endif +#ifndef INLINE +#define INLINE /* default is to define it as empty */ +#endif +#endif + + +/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying + * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER + * as short on such a machine. MULTIPLIER must be at least 16 bits wide. + */ + +#ifndef MULTIPLIER +#define MULTIPLIER int /* type for fastest integer multiply */ +#endif + + +/* FAST_FLOAT should be either float or double, whichever is done faster + * by your compiler. (Note that this type is only used in the floating point + * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.) + * Typically, float is faster in ANSI C compilers, while double is faster in + * pre-ANSI compilers (because they insist on converting to double anyway). + * The code below therefore chooses float if we have ANSI-style prototypes. + */ + +#ifndef FAST_FLOAT +#ifdef HAVE_PROTOTYPES +#define FAST_FLOAT float +#else +#define FAST_FLOAT double +#endif +#endif + +#endif /* JPEG_INTERNAL_OPTIONS */ diff --git a/engine/libs/jpeg.lib b/engine/libs/jpeg.lib new file mode 100644 index 0000000000000000000000000000000000000000..36bd77c655466e602937b447655c177be7ade948 GIT binary patch literal 229998 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%0A4G!tEY?_h;Z6UV;PcFT<;X6zhWIJ;>Qq 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 literal 0 HcmV?d00001 diff --git a/engine/libs/jpeglib.h b/engine/libs/jpeglib.h new file mode 100644 index 000000000..d1be8ddef --- /dev/null +++ b/engine/libs/jpeglib.h @@ -0,0 +1,1096 @@ +/* + * jpeglib.h + * + * Copyright (C) 1991-1998, Thomas G. Lane. + * This file is part of the Independent JPEG Group's software. + * For conditions of distribution and use, see the accompanying README file. + * + * This file defines the application interface for the JPEG library. + * Most applications using the library need only include this file, + * and perhaps jerror.h if they want to know the exact error codes. + */ + +#ifndef JPEGLIB_H +#define JPEGLIB_H + +/* + * First we include the configuration files that record how this + * installation of the JPEG library is set up. jconfig.h can be + * generated automatically for many systems. jmorecfg.h contains + * manual configuration options that most people need not worry about. + */ + +#ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */ +#include "jconfig.h" /* widely used configuration options */ +#endif +#include "jmorecfg.h" /* seldom changed options */ + + +/* Version ID for the JPEG library. + * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60". + */ + +#define JPEG_LIB_VERSION 62 /* Version 6b */ + + +/* Various constants determining the sizes of things. + * All of these are specified by the JPEG standard, so don't change them + * if you want to be compatible. + */ + +#define DCTSIZE 8 /* The basic DCT block is 8x8 samples */ +#define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */ +#define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */ +#define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */ +#define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */ +#define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */ +#define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */ +/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard; + * the PostScript DCT filter can emit files with many more than 10 blocks/MCU. + * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU + * to handle it. We even let you do this from the jconfig.h file. However, + * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe + * sometimes emits noncompliant files doesn't mean you should too. + */ +#define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */ +#ifndef D_MAX_BLOCKS_IN_MCU +#define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */ +#endif + + +/* Data structures for images (arrays of samples and of DCT coefficients). + * On 80x86 machines, the image arrays are too big for near pointers, + * but the pointer arrays can fit in near memory. + */ + +typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */ +typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */ +typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */ + +typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */ +typedef JBLOCK FAR *JBLOCKROW; /* pointer to one row of coefficient blocks */ +typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */ +typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */ + +typedef JCOEF FAR *JCOEFPTR; /* useful in a couple of places */ + + +/* Types for JPEG compression parameters and working tables. */ + + +/* DCT coefficient quantization tables. */ + +typedef struct { + /* This array gives the coefficient quantizers in natural array order + * (not the zigzag order in which they are stored in a JPEG DQT marker). + * CAUTION: IJG versions prior to v6a kept this array in zigzag order. + */ + UINT16 quantval[DCTSIZE2]; /* quantization step for each coefficient */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JQUANT_TBL; + + +/* Huffman coding tables. */ + +typedef struct { + /* These two fields directly represent the contents of a JPEG DHT marker */ + UINT8 bits[17]; /* bits[k] = # of symbols with codes of */ + /* length k bits; bits[0] is unused */ + UINT8 huffval[256]; /* The symbols, in order of incr code length */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JHUFF_TBL; + + +/* Basic info about one component (color channel). */ + +typedef struct { + /* These values are fixed over the whole image. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOF marker. */ + int component_id; /* identifier for this component (0..255) */ + int component_index; /* its index in SOF or cinfo->comp_info[] */ + int h_samp_factor; /* horizontal sampling factor (1..4) */ + int v_samp_factor; /* vertical sampling factor (1..4) */ + int quant_tbl_no; /* quantization table selector (0..3) */ + /* These values may vary between scans. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOS marker. */ + /* The decompressor output side may not use these variables. */ + int dc_tbl_no; /* DC entropy table selector (0..3) */ + int ac_tbl_no; /* AC entropy table selector (0..3) */ + + /* Remaining fields should be treated as private by applications. */ + + /* These values are computed during compression or decompression startup: */ + /* Component's size in DCT blocks. + * Any dummy blocks added to complete an MCU are not counted; therefore + * these values do not depend on whether a scan is interleaved or not. + */ + JDIMENSION width_in_blocks; + JDIMENSION height_in_blocks; + /* Size of a DCT block in samples. Always DCTSIZE for compression. + * For decompression this is the size of the output from one DCT block, + * reflecting any scaling we choose to apply during the IDCT step. + * Values of 1,2,4,8 are likely to be supported. Note that different + * components may receive different IDCT scalings. + */ + int DCT_scaled_size; + /* The downsampled dimensions are the component's actual, unpadded number + * of samples at the main buffer (preprocessing/compression interface), thus + * downsampled_width = ceil(image_width * Hi/Hmax) + * and similarly for height. For decompression, IDCT scaling is included, so + * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE) + */ + JDIMENSION downsampled_width; /* actual width in samples */ + JDIMENSION downsampled_height; /* actual height in samples */ + /* This flag is used only for decompression. In cases where some of the + * components will be ignored (eg grayscale output from YCbCr image), + * we can skip most computations for the unused components. + */ + boolean component_needed; /* do we need the value of this component? */ + + /* These values are computed before starting a scan of the component. */ + /* The decompressor output side may not use these variables. */ + int MCU_width; /* number of blocks per MCU, horizontally */ + int MCU_height; /* number of blocks per MCU, vertically */ + int MCU_blocks; /* MCU_width * MCU_height */ + int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_scaled_size */ + int last_col_width; /* # of non-dummy blocks across in last MCU */ + int last_row_height; /* # of non-dummy blocks down in last MCU */ + + /* Saved quantization table for component; NULL if none yet saved. + * See jdinput.c comments about the need for this information. + * This field is currently used only for decompression. + */ + JQUANT_TBL * quant_table; + + /* Private per-component storage for DCT or IDCT subsystem. */ + void * dct_table; +} jpeg_component_info; + + +/* The script for encoding a multiple-scan file is an array of these: */ + +typedef struct { + int comps_in_scan; /* number of components encoded in this scan */ + int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */ + int Ss, Se; /* progressive JPEG spectral selection parms */ + int Ah, Al; /* progressive JPEG successive approx. parms */ +} jpeg_scan_info; + +/* The decompressor can save APPn and COM markers in a list of these: */ + +typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr; + +struct jpeg_marker_struct { + jpeg_saved_marker_ptr next; /* next in list, or NULL */ + UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */ + unsigned int original_length; /* # bytes of data in the file */ + unsigned int data_length; /* # bytes of data saved at data[] */ + JOCTET FAR * data; /* the data contained in the marker */ + /* the marker length word is not counted in data_length or original_length */ +}; + +/* Known color spaces. */ + +typedef enum { + JCS_UNKNOWN, /* error/unspecified */ + JCS_GRAYSCALE, /* monochrome */ + JCS_RGB, /* red/green/blue */ + JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */ + JCS_CMYK, /* C/M/Y/K */ + JCS_YCCK /* Y/Cb/Cr/K */ +} J_COLOR_SPACE; + +/* DCT/IDCT algorithm options. */ + +typedef enum { + JDCT_ISLOW, /* slow but accurate integer algorithm */ + JDCT_IFAST, /* faster, less accurate integer method */ + JDCT_FLOAT /* floating-point: accurate, fast on fast HW */ +} J_DCT_METHOD; + +#ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */ +#define JDCT_DEFAULT JDCT_ISLOW +#endif +#ifndef JDCT_FASTEST /* may be overridden in jconfig.h */ +#define JDCT_FASTEST JDCT_IFAST +#endif + +/* Dithering options for decompression. */ + +typedef enum { + JDITHER_NONE, /* no dithering */ + JDITHER_ORDERED, /* simple ordered dither */ + JDITHER_FS /* Floyd-Steinberg error diffusion dither */ +} J_DITHER_MODE; + + +/* Common fields between JPEG compression and decompression master structs. */ + +#define jpeg_common_fields \ + struct jpeg_error_mgr * err; /* Error handler module */\ + struct jpeg_memory_mgr * mem; /* Memory manager module */\ + struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\ + void * client_data; /* Available for use by application */\ + boolean is_decompressor; /* So common code can tell which is which */\ + int global_state /* For checking call sequence validity */ + +/* Routines that are to be used by both halves of the library are declared + * to receive a pointer to this structure. There are no actual instances of + * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct. + */ +struct jpeg_common_struct { + jpeg_common_fields; /* Fields common to both master struct types */ + /* Additional fields follow in an actual jpeg_compress_struct or + * jpeg_decompress_struct. All three structs must agree on these + * initial fields! (This would be a lot cleaner in C++.) + */ +}; + +typedef struct jpeg_common_struct * j_common_ptr; +typedef struct jpeg_compress_struct * j_compress_ptr; +typedef struct jpeg_decompress_struct * j_decompress_ptr; + + +/* Master record for a compression instance */ + +struct jpeg_compress_struct { + jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */ + + /* Destination for compressed data */ + struct jpeg_destination_mgr * dest; + + /* Description of source image --- these fields must be filled in by + * outer application before starting compression. in_color_space must + * be correct before you can even call jpeg_set_defaults(). + */ + + JDIMENSION image_width; /* input image width */ + JDIMENSION image_height; /* input image height */ + int input_components; /* # of color components in input image */ + J_COLOR_SPACE in_color_space; /* colorspace of input image */ + + double input_gamma; /* image gamma of input image */ + + /* Compression parameters --- these fields must be set before calling + * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to + * initialize everything to reasonable defaults, then changing anything + * the application specifically wants to change. That way you won't get + * burnt when new parameters are added. Also note that there are several + * helper routines to simplify changing parameters. + */ + + int data_precision; /* bits of precision in image data */ + + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + jpeg_component_info * comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + + JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; + /* ptrs to coefficient quantization tables, or NULL if not defined */ + + JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + int num_scans; /* # of entries in scan_info array */ + const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */ + /* The default value of scan_info is NULL, which causes a single-scan + * sequential JPEG file to be emitted. To create a multi-scan file, + * set num_scans and scan_info to point to an array of scan definitions. + */ + + boolean raw_data_in; /* TRUE=caller supplies downsampled data */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + boolean optimize_coding; /* TRUE=optimize entropy encoding parms */ + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ + int smoothing_factor; /* 1..100, or 0 for no input smoothing */ + J_DCT_METHOD dct_method; /* DCT algorithm selector */ + + /* The restart interval can be specified in absolute MCUs by setting + * restart_interval, or in MCU rows by setting restart_in_rows + * (in which case the correct restart_interval will be figured + * for each scan). + */ + unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */ + int restart_in_rows; /* if > 0, MCU rows per restart interval */ + + /* Parameters controlling emission of special markers. */ + + boolean write_JFIF_header; /* should a JFIF marker be written? */ + UINT8 JFIF_major_version; /* What to write for the JFIF version number */ + UINT8 JFIF_minor_version; + /* These three values are not used by the JPEG code, merely copied */ + /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */ + /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */ + /* ratio is defined by X_density/Y_density even when density_unit=0. */ + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean write_Adobe_marker; /* should an Adobe marker be written? */ + + /* State variable: index of next scanline to be written to + * jpeg_write_scanlines(). Application may use this to control its + * processing loop, e.g., "while (next_scanline < image_height)". + */ + + JDIMENSION next_scanline; /* 0 .. image_height-1 */ + + /* Remaining fields are known throughout compressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during compression startup + */ + boolean progressive_mode; /* TRUE if scan script uses progressive mode */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + + JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */ + /* The coefficient controller receives data in units of MCU rows as defined + * for fully interleaved scans (whether the JPEG file is interleaved or not). + * There are v_samp_factor * DCTSIZE sample rows of each component in an + * "iMCU" (interleaved MCU) row. + */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[C_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + + /* + * Links to compression subobjects (methods and private variables of modules) + */ + struct jpeg_comp_master * master; + struct jpeg_c_main_controller * main; + struct jpeg_c_prep_controller * prep; + struct jpeg_c_coef_controller * coef; + struct jpeg_marker_writer * marker; + struct jpeg_color_converter * cconvert; + struct jpeg_downsampler * downsample; + struct jpeg_forward_dct * fdct; + struct jpeg_entropy_encoder * entropy; + jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */ + int script_space_size; +}; + + +/* Master record for a decompression instance */ + +struct jpeg_decompress_struct { + jpeg_common_fields; /* Fields shared with jpeg_compress_struct */ + + /* Source of compressed data */ + struct jpeg_source_mgr * src; + + /* Basic description of image --- filled in by jpeg_read_header(). */ + /* Application may inspect these values to decide how to process image. */ + + JDIMENSION image_width; /* nominal image width (from SOF marker) */ + JDIMENSION image_height; /* nominal image height */ + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + /* Decompression processing parameters --- these fields must be set before + * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes + * them to default values. + */ + + J_COLOR_SPACE out_color_space; /* colorspace for output */ + + unsigned int scale_num, scale_denom; /* fraction by which to scale image */ + + double output_gamma; /* image gamma wanted in output */ + + boolean buffered_image; /* TRUE=multiple output passes */ + boolean raw_data_out; /* TRUE=downsampled data wanted */ + + J_DCT_METHOD dct_method; /* IDCT algorithm selector */ + boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */ + boolean do_block_smoothing; /* TRUE=apply interblock smoothing */ + + boolean quantize_colors; /* TRUE=colormapped output wanted */ + /* the following are ignored if not quantize_colors: */ + J_DITHER_MODE dither_mode; /* type of color dithering to use */ + boolean two_pass_quantize; /* TRUE=use two-pass color quantization */ + int desired_number_of_colors; /* max # colors to use in created colormap */ + /* these are significant only in buffered-image mode: */ + boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */ + boolean enable_external_quant;/* enable future use of external colormap */ + boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */ + + /* Description of actual output image that will be returned to application. + * These fields are computed by jpeg_start_decompress(). + * You can also use jpeg_calc_output_dimensions() to determine these values + * in advance of calling jpeg_start_decompress(). + */ + + JDIMENSION output_width; /* scaled image width */ + JDIMENSION output_height; /* scaled image height */ + int out_color_components; /* # of color components in out_color_space */ + int output_components; /* # of color components returned */ + /* output_components is 1 (a colormap index) when quantizing colors; + * otherwise it equals out_color_components. + */ + int rec_outbuf_height; /* min recommended height of scanline buffer */ + /* If the buffer passed to jpeg_read_scanlines() is less than this many rows + * high, space and time will be wasted due to unnecessary data copying. + * Usually rec_outbuf_height will be 1 or 2, at most 4. + */ + + /* When quantizing colors, the output colormap is described by these fields. + * The application can supply a colormap by setting colormap non-NULL before + * calling jpeg_start_decompress; otherwise a colormap is created during + * jpeg_start_decompress or jpeg_start_output. + * The map has out_color_components rows and actual_number_of_colors columns. + */ + int actual_number_of_colors; /* number of entries in use */ + JSAMPARRAY colormap; /* The color map as a 2-D pixel array */ + + /* State variables: these variables indicate the progress of decompression. + * The application may examine these but must not modify them. + */ + + /* Row index of next scanline to be read from jpeg_read_scanlines(). + * Application may use this to control its processing loop, e.g., + * "while (output_scanline < output_height)". + */ + JDIMENSION output_scanline; /* 0 .. output_height-1 */ + + /* Current input scan number and number of iMCU rows completed in scan. + * These indicate the progress of the decompressor input side. + */ + int input_scan_number; /* Number of SOS markers seen so far */ + JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */ + + /* The "output scan number" is the notional scan being displayed by the + * output side. The decompressor will not allow output scan/row number + * to get ahead of input scan/row, but it can fall arbitrarily far behind. + */ + int output_scan_number; /* Nominal scan number being displayed */ + JDIMENSION output_iMCU_row; /* Number of iMCU rows read */ + + /* Current progression status. coef_bits[c][i] indicates the precision + * with which component c's DCT coefficient i (in zigzag order) is known. + * It is -1 when no data has yet been received, otherwise it is the point + * transform (shift) value for the most recent scan of the coefficient + * (thus, 0 at completion of the progression). + * This pointer is NULL when reading a non-progressive file. + */ + int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */ + + /* Internal JPEG parameters --- the application usually need not look at + * these fields. Note that the decompressor output side may not use + * any parameters that can change between scans. + */ + + /* Quantization and Huffman tables are carried forward across input + * datastreams when processing abbreviated JPEG datastreams. + */ + + JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; + /* ptrs to coefficient quantization tables, or NULL if not defined */ + + JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + /* These parameters are never carried across datastreams, since they + * are given in SOF/SOS markers or defined to be reset by SOI. + */ + + int data_precision; /* bits of precision in image data */ + + jpeg_component_info * comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + + boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */ + + /* These fields record data obtained from optional markers recognized by + * the JPEG library. + */ + boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */ + /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */ + UINT8 JFIF_major_version; /* JFIF version number */ + UINT8 JFIF_minor_version; + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */ + UINT8 Adobe_transform; /* Color transform code from Adobe marker */ + + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ + + /* Aside from the specific data retained from APPn markers known to the + * library, the uninterpreted contents of any or all APPn and COM markers + * can be saved in a list for examination by the application. + */ + jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */ + + /* Remaining fields are known throughout decompressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during decompression startup + */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + + int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */ + + JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */ + /* The coefficient controller's input and output progress is measured in + * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows + * in fully interleaved JPEG scans, but are used whether the scan is + * interleaved or not. We define an iMCU row as v_samp_factor DCT block + * rows of each component. Therefore, the IDCT output contains + * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row. + */ + + JSAMPLE * sample_range_limit; /* table for fast range-limiting */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + * Note that the decompressor output side must not use these fields. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[D_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + + /* This field is shared between entropy decoder and marker parser. + * It is either zero or the code of a JPEG marker that has been + * read from the data source, but has not yet been processed. + */ + int unread_marker; + + /* + * Links to decompression subobjects (methods, private variables of modules) + */ + struct jpeg_decomp_master * master; + struct jpeg_d_main_controller * main; + struct jpeg_d_coef_controller * coef; + struct jpeg_d_post_controller * post; + struct jpeg_input_controller * inputctl; + struct jpeg_marker_reader * marker; + struct jpeg_entropy_decoder * entropy; + struct jpeg_inverse_dct * idct; + struct jpeg_upsampler * upsample; + struct jpeg_color_deconverter * cconvert; + struct jpeg_color_quantizer * cquantize; +}; + + +/* "Object" declarations for JPEG modules that may be supplied or called + * directly by the surrounding application. + * As with all objects in the JPEG library, these structs only define the + * publicly visible methods and state variables of a module. Additional + * private fields may exist after the public ones. + */ + + +/* Error handler object */ + +struct jpeg_error_mgr { + /* Error exit handler: does not return to caller */ + JMETHOD(void, error_exit, (j_common_ptr cinfo)); + /* Conditionally emit a trace or warning message */ + JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level)); + /* Routine that actually outputs a trace or error message */ + JMETHOD(void, output_message, (j_common_ptr cinfo)); + /* Format a message string for the most recent JPEG error or message */ + JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer)); +#define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */ + /* Reset error state variables at start of a new image */ + JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo)); + + /* The message ID code and any parameters are saved here. + * A message can have one string parameter or up to 8 int parameters. + */ + int msg_code; +#define JMSG_STR_PARM_MAX 80 + union { + int i[8]; + char s[JMSG_STR_PARM_MAX]; + } msg_parm; + + /* Standard state variables for error facility */ + + int trace_level; /* max msg_level that will be displayed */ + + /* For recoverable corrupt-data errors, we emit a warning message, + * but keep going unless emit_message chooses to abort. emit_message + * should count warnings in num_warnings. The surrounding application + * can check for bad data by seeing if num_warnings is nonzero at the + * end of processing. + */ + long num_warnings; /* number of corrupt-data warnings */ + + /* These fields point to the table(s) of error message strings. + * An application can change the table pointer to switch to a different + * message list (typically, to change the language in which errors are + * reported). Some applications may wish to add additional error codes + * that will be handled by the JPEG library error mechanism; the second + * table pointer is used for this purpose. + * + * First table includes all errors generated by JPEG library itself. + * Error code 0 is reserved for a "no such error string" message. + */ + const char * const * jpeg_message_table; /* Library errors */ + int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */ + /* Second table can be added by application (see cjpeg/djpeg for example). + * It contains strings numbered first_addon_message..last_addon_message. + */ + const char * const * addon_message_table; /* Non-library errors */ + int first_addon_message; /* code for first string in addon table */ + int last_addon_message; /* code for last string in addon table */ +}; + + +/* Progress monitor object */ + +struct jpeg_progress_mgr { + JMETHOD(void, progress_monitor, (j_common_ptr cinfo)); + + long pass_counter; /* work units completed in this pass */ + long pass_limit; /* total number of work units in this pass */ + int completed_passes; /* passes completed so far */ + int total_passes; /* total number of passes expected */ +}; + + +/* Data destination object for compression */ + +struct jpeg_destination_mgr { + JOCTET * next_output_byte; /* => next byte to write in buffer */ + size_t free_in_buffer; /* # of byte spaces remaining in buffer */ + + JMETHOD(void, init_destination, (j_compress_ptr cinfo)); + JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo)); + JMETHOD(void, term_destination, (j_compress_ptr cinfo)); +}; + + +/* Data source object for decompression */ + +struct jpeg_source_mgr { + const JOCTET * next_input_byte; /* => next byte to read from buffer */ + size_t bytes_in_buffer; /* # of bytes remaining in buffer */ + + JMETHOD(void, init_source, (j_decompress_ptr cinfo)); + JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo)); + JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes)); + JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired)); + JMETHOD(void, term_source, (j_decompress_ptr cinfo)); +}; + + +/* Memory manager object. + * Allocates "small" objects (a few K total), "large" objects (tens of K), + * and "really big" objects (virtual arrays with backing store if needed). + * The memory manager does not allow individual objects to be freed; rather, + * each created object is assigned to a pool, and whole pools can be freed + * at once. This is faster and more convenient than remembering exactly what + * to free, especially where malloc()/free() are not too speedy. + * NB: alloc routines never return NULL. They exit to error_exit if not + * successful. + */ + +#define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */ +#define JPOOL_IMAGE 1 /* lasts until done with image/datastream */ +#define JPOOL_NUMPOOLS 2 + +typedef struct jvirt_sarray_control * jvirt_sarray_ptr; +typedef struct jvirt_barray_control * jvirt_barray_ptr; + + +struct jpeg_memory_mgr { + /* Method pointers */ + JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id, + size_t sizeofobject)); + JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id, + size_t sizeofobject)); + JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id, + JDIMENSION samplesperrow, + JDIMENSION numrows)); + JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id, + JDIMENSION blocksperrow, + JDIMENSION numrows)); + JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo, + int pool_id, + boolean pre_zero, + JDIMENSION samplesperrow, + JDIMENSION numrows, + JDIMENSION maxaccess)); + JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo, + int pool_id, + boolean pre_zero, + JDIMENSION blocksperrow, + JDIMENSION numrows, + JDIMENSION maxaccess)); + JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo)); + JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo, + jvirt_sarray_ptr ptr, + JDIMENSION start_row, + JDIMENSION num_rows, + boolean writable)); + JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo, + jvirt_barray_ptr ptr, + JDIMENSION start_row, + JDIMENSION num_rows, + boolean writable)); + JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id)); + JMETHOD(void, self_destruct, (j_common_ptr cinfo)); + + /* Limit on memory allocation for this JPEG object. (Note that this is + * merely advisory, not a guaranteed maximum; it only affects the space + * used for virtual-array buffers.) May be changed by outer application + * after creating the JPEG object. + */ + long max_memory_to_use; + + /* Maximum allocation request accepted by alloc_large. */ + long max_alloc_chunk; +}; + + +/* Routine signature for application-supplied marker processing methods. + * Need not pass marker code since it is stored in cinfo->unread_marker. + */ +typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo)); + + +/* Declarations for routines called by application. + * The JPP macro hides prototype parameters from compilers that can't cope. + * Note JPP requires double parentheses. + */ + +#ifdef HAVE_PROTOTYPES +#define JPP(arglist) arglist +#else +#define JPP(arglist) () +#endif + + +/* Short forms of external names for systems with brain-damaged linkers. + * We shorten external names to be unique in the first six letters, which + * is good enough for all known systems. + * (If your compiler itself needs names to be unique in less than 15 + * characters, you are out of luck. Get a better compiler.) + */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jpeg_std_error jStdError +#define jpeg_CreateCompress jCreaCompress +#define jpeg_CreateDecompress jCreaDecompress +#define jpeg_destroy_compress jDestCompress +#define jpeg_destroy_decompress jDestDecompress +#define jpeg_stdio_dest jStdDest +#define jpeg_stdio_src jStdSrc +#define jpeg_set_defaults jSetDefaults +#define jpeg_set_colorspace jSetColorspace +#define jpeg_default_colorspace jDefColorspace +#define jpeg_set_quality jSetQuality +#define jpeg_set_linear_quality jSetLQuality +#define jpeg_add_quant_table jAddQuantTable +#define jpeg_quality_scaling jQualityScaling +#define jpeg_simple_progression jSimProgress +#define jpeg_suppress_tables jSuppressTables +#define jpeg_alloc_quant_table jAlcQTable +#define jpeg_alloc_huff_table jAlcHTable +#define jpeg_start_compress jStrtCompress +#define jpeg_write_scanlines jWrtScanlines +#define jpeg_finish_compress jFinCompress +#define jpeg_write_raw_data jWrtRawData +#define jpeg_write_marker jWrtMarker +#define jpeg_write_m_header jWrtMHeader +#define jpeg_write_m_byte jWrtMByte +#define jpeg_write_tables jWrtTables +#define jpeg_read_header jReadHeader +#define jpeg_start_decompress jStrtDecompress +#define jpeg_read_scanlines jReadScanlines +#define jpeg_finish_decompress jFinDecompress +#define jpeg_read_raw_data jReadRawData +#define jpeg_has_multiple_scans jHasMultScn +#define jpeg_start_output jStrtOutput +#define jpeg_finish_output jFinOutput +#define jpeg_input_complete jInComplete +#define jpeg_new_colormap jNewCMap +#define jpeg_consume_input jConsumeInput +#define jpeg_calc_output_dimensions jCalcDimensions +#define jpeg_save_markers jSaveMarkers +#define jpeg_set_marker_processor jSetMarker +#define jpeg_read_coefficients jReadCoefs +#define jpeg_write_coefficients jWrtCoefs +#define jpeg_copy_critical_parameters jCopyCrit +#define jpeg_abort_compress jAbrtCompress +#define jpeg_abort_decompress jAbrtDecompress +#define jpeg_abort jAbort +#define jpeg_destroy jDestroy +#define jpeg_resync_to_restart jResyncRestart +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + + +/* Default error-management setup */ +EXTERN(struct jpeg_error_mgr *) jpeg_std_error + JPP((struct jpeg_error_mgr * err)); + +/* Initialization of JPEG compression objects. + * jpeg_create_compress() and jpeg_create_decompress() are the exported + * names that applications should call. These expand to calls on + * jpeg_CreateCompress and jpeg_CreateDecompress with additional information + * passed for version mismatch checking. + * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx. + */ +#define jpeg_create_compress(cinfo) \ + jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \ + (size_t) sizeof(struct jpeg_compress_struct)) +#define jpeg_create_decompress(cinfo) \ + jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \ + (size_t) sizeof(struct jpeg_decompress_struct)) +EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo, + int version, size_t structsize)); +EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo, + int version, size_t structsize)); +/* Destruction of JPEG compression objects */ +EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo)); + +/* Standard data source and destination managers: stdio streams. */ +/* Caller is responsible for opening the file before and closing after. */ +EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile)); +EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile)); + +/* Default parameter setup for compression */ +EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo)); +/* Compression parameter setup aids */ +EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo, + J_COLOR_SPACE colorspace)); +EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality, + boolean force_baseline)); +EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo, + int scale_factor, + boolean force_baseline)); +EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl, + const unsigned int *basic_table, + int scale_factor, + boolean force_baseline)); +EXTERN(int) jpeg_quality_scaling JPP((int quality)); +EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo, + boolean suppress)); +EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo)); +EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo)); + +/* Main entry points for compression */ +EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo, + boolean write_all_tables)); +EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION num_lines)); +EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo)); + +/* Replaces jpeg_write_scanlines when writing raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo, + JSAMPIMAGE data, + JDIMENSION num_lines)); + +/* Write a special marker. See libjpeg.doc concerning safe usage. */ +EXTERN(void) jpeg_write_marker + JPP((j_compress_ptr cinfo, int marker, + const JOCTET * dataptr, unsigned int datalen)); +/* Same, but piecemeal. */ +EXTERN(void) jpeg_write_m_header + JPP((j_compress_ptr cinfo, int marker, unsigned int datalen)); +EXTERN(void) jpeg_write_m_byte + JPP((j_compress_ptr cinfo, int val)); + +/* Alternate compression function: just write an abbreviated table file */ +EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo)); + +/* Decompression startup: read start of JPEG datastream to see what's there */ +EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo, + boolean require_image)); +/* Return value is one of: */ +#define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */ +#define JPEG_HEADER_OK 1 /* Found valid image datastream */ +#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */ +/* If you pass require_image = TRUE (normal case), you need not check for + * a TABLES_ONLY return code; an abbreviated file will cause an error exit. + * JPEG_SUSPENDED is only possible if you use a data source module that can + * give a suspension return (the stdio source module doesn't). + */ + +/* Main entry points for decompression */ +EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo)); +EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION max_lines)); +EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo)); + +/* Replaces jpeg_read_scanlines when reading raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo, + JSAMPIMAGE data, + JDIMENSION max_lines)); + +/* Additional entry points for buffered-image mode. */ +EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo, + int scan_number)); +EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo)); +EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo)); +EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo)); +/* Return value is one of: */ +/* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */ +#define JPEG_REACHED_SOS 1 /* Reached start of new scan */ +#define JPEG_REACHED_EOI 2 /* Reached end of image */ +#define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */ +#define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */ + +/* Precalculate output dimensions for current decompression parameters. */ +EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo)); + +/* Control saving of COM and APPn markers into marker_list. */ +EXTERN(void) jpeg_save_markers + JPP((j_decompress_ptr cinfo, int marker_code, + unsigned int length_limit)); + +/* Install a special processing method for COM or APPn markers. */ +EXTERN(void) jpeg_set_marker_processor + JPP((j_decompress_ptr cinfo, int marker_code, + jpeg_marker_parser_method routine)); + +/* Read or write raw DCT coefficients --- useful for lossless transcoding. */ +EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo)); +EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo, + jvirt_barray_ptr * coef_arrays)); +EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo, + j_compress_ptr dstinfo)); + +/* If you choose to abort compression or decompression before completing + * jpeg_finish_(de)compress, then you need to clean up to release memory, + * temporary files, etc. You can just call jpeg_destroy_(de)compress + * if you're done with the JPEG object, but if you want to clean it up and + * reuse it, call this: + */ +EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo)); + +/* Generic versions of jpeg_abort and jpeg_destroy that work on either + * flavor of JPEG object. These may be more convenient in some places. + */ +EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo)); +EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo)); + +/* Default restart-marker-resync procedure for use by data source modules */ +EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo, + int desired)); + + +/* These marker codes are exported since applications and data source modules + * are likely to want to use them. + */ + +#define JPEG_RST0 0xD0 /* RST0 marker code */ +#define JPEG_EOI 0xD9 /* EOI marker code */ +#define JPEG_APP0 0xE0 /* APP0 marker code */ +#define JPEG_COM 0xFE /* COM marker code */ + + +/* If we have a brain-damaged compiler that emits warnings (or worse, errors) + * for structure definitions that are never filled in, keep it quiet by + * supplying dummy definitions for the various substructures. + */ + +#ifdef INCOMPLETE_TYPES_BROKEN +#ifndef JPEG_INTERNALS /* will be defined in jpegint.h */ +struct jvirt_sarray_control { long dummy; }; +struct jvirt_barray_control { long dummy; }; +struct jpeg_comp_master { long dummy; }; +struct jpeg_c_main_controller { long dummy; }; +struct jpeg_c_prep_controller { long dummy; }; +struct jpeg_c_coef_controller { long dummy; }; +struct jpeg_marker_writer { long dummy; }; +struct jpeg_color_converter { long dummy; }; +struct jpeg_downsampler { long dummy; }; +struct jpeg_forward_dct { long dummy; }; +struct jpeg_entropy_encoder { long dummy; }; +struct jpeg_decomp_master { long dummy; }; +struct jpeg_d_main_controller { long dummy; }; +struct jpeg_d_coef_controller { long dummy; }; +struct jpeg_d_post_controller { long dummy; }; +struct jpeg_input_controller { long dummy; }; +struct jpeg_marker_reader { long dummy; }; +struct jpeg_entropy_decoder { long dummy; }; +struct jpeg_inverse_dct { long dummy; }; +struct jpeg_upsampler { long dummy; }; +struct jpeg_color_deconverter { long dummy; }; +struct jpeg_color_quantizer { long dummy; }; +#endif /* JPEG_INTERNALS */ +#endif /* INCOMPLETE_TYPES_BROKEN */ + + +/* + * The JPEG library modules define JPEG_INTERNALS before including this file. + * The internal structure declarations are read only when that is true. + * Applications using the library should not include jpegint.h, but may wish + * to include jerror.h. + */ + +#ifdef JPEG_INTERNALS +#include "jpegint.h" /* fetch private declarations */ +#include "jerror.h" /* fetch error codes too */ +#endif + +#endif /* JPEGLIB_H */ diff --git a/engine/libs/libpng.lib b/engine/libs/libpng.lib new file mode 100644 index 0000000000000000000000000000000000000000..2e8e29c57555c7d6bd5c44caed9df5b74bf1a5f9 GIT binary patch literal 302658 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 MTAP~iNP8pxA51iS@&Et; literal 0 HcmV?d00001 diff --git a/engine/libs/png.h b/engine/libs/png.h new file mode 100644 index 000000000..365c80b39 --- /dev/null +++ b/engine/libs/png.h @@ -0,0 +1,3278 @@ +/* png.h - header file for PNG reference library + * + * libpng version 1.2.4 - July 8, 2002 + * Copyright (c) 1998-2002 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * Authors and maintainers: + * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat + * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger + * libpng versions 0.97, January 1998, through 1.2.4 - July 8, 2002: Glenn + * See also "Contributing Authors", below. + * + * Note about libpng version numbers: + * + * Due to various miscommunications, unforeseen code incompatibilities + * and occasional factors outside the authors' control, version numbering + * on the library has not always been consistent and straightforward. + * The following table summarizes matters since version 0.89c, which was + * the first widely used release: + * + * source png.h png.h shared-lib + * version string int version + * ------- ------ ----- ---------- + * 0.89c "1.0 beta 3" 0.89 89 1.0.89 + * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] + * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] + * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] + * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] + * 0.97c 0.97 97 2.0.97 + * 0.98 0.98 98 2.0.98 + * 0.99 0.99 98 2.0.99 + * 0.99a-m 0.99 99 2.0.99 + * 1.00 1.00 100 2.1.0 [100 should be 10000] + * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] + * 1.0.1 png.h string is 10001 2.1.0 + * 1.0.1a-e identical to the 10002 from here on, the shared library + * 1.0.2 source version) 10002 is 2.V where V is the source code + * 1.0.2a-b 10003 version, except as noted. + * 1.0.3 10003 + * 1.0.3a-d 10004 + * 1.0.4 10004 + * 1.0.4a-f 10005 + * 1.0.5 (+ 2 patches) 10005 + * 1.0.5a-d 10006 + * 1.0.5e-r 10100 (not source compatible) + * 1.0.5s-v 10006 (not binary compatible) + * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) + * 1.0.6d-f 10007 (still binary incompatible) + * 1.0.6g 10007 + * 1.0.6h 10007 10.6h (testing xy.z so-numbering) + * 1.0.6i 10007 10.6i + * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) + * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) + * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) + * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) + * 1.0.7 1 10007 (still compatible) + * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 + * 1.0.8rc1 1 10008 2.1.0.8rc1 + * 1.0.8 1 10008 2.1.0.8 + * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 + * 1.0.9rc1 1 10009 2.1.0.9rc1 + * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 + * 1.0.9rc2 1 10009 2.1.0.9rc2 + * 1.0.9 1 10009 2.1.0.9 + * 1.0.10beta1 1 10010 2.1.0.10beta1 + * 1.0.10rc1 1 10010 2.1.0.10rc1 + * 1.0.10 1 10010 2.1.0.10 + * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 + * 1.0.11rc1 1 10011 2.1.0.11rc1 + * 1.0.11 1 10011 2.1.0.11 + * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 + * 1.0.12rc1 2 10012 2.1.0.12rc1 + * 1.0.12 2 10012 2.1.0.12 + * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) + * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 + * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 + * 1.2.0rc1 3 10200 3.1.2.0rc1 + * 1.2.0 3 10200 3.1.2.0 + * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 + * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 + * 1.2.1 3 10201 3.1.2.1 + * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 + * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 + * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 + * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 + * 1.0.13 10 10013 10.so.0.1.0.13 + * 1.2.2 12 10202 12.so.0.1.2.2 + * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 + * 1.2.3 12 10203 12.so.0.1.2.3 + * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 + * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 + * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 + * 1.0.14 10 10014 10.so.0.1.0.14 + * 1.2.4 13 10204 12.so.0.1.2.4 + * + * Henceforth the source version will match the shared-library major + * and minor numbers; the shared-library major version number will be + * used for changes in backward compatibility, as it is intended. The + * PNG_LIBPNG_VER macro, which is not used within libpng but is available + * for applications, is an unsigned integer of the form xyyzz corresponding + * to the source version x.y.z (leading zeros in y and z). Beta versions + * were given the previous public release number plus a letter, until + * version 1.0.6j; from then on they were given the upcoming public + * release number plus "betaNN" or "rcN". + * + * Binary incompatibility exists only when applications make direct access + * to the info_ptr or png_ptr members through png.h, and the compiled + * application is loaded with a different version of the library. + * + * DLLNUM will change each time there are forward or backward changes + * in binary compatibility (e.g., when a new feature is added). + * + * See libpng.txt or libpng.3 for more information. The PNG specification + * is available as RFC 2083 + * and as a W3C Recommendation + */ + +/* + * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: + * + * If you modify libpng you may insert additional notices immediately following + * this sentence. + * + * libpng versions 1.0.7, July 1, 2000, through 1.2.4, July 8, 2002, are + * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are + * distributed according to the same disclaimer and license as libpng-1.0.6 + * with the following individuals added to the list of Contributing Authors + * + * Simon-Pierre Cadieux + * Eric S. Raymond + * Gilles Vollant + * + * and with the following additions to the disclaimer: + * + * There is no warranty against interference with your enjoyment of the + * library or against infringement. There is no warranty that our + * efforts or the library will fulfill any of your particular purposes + * or needs. This library is provided with all faults, and the entire + * risk of satisfactory quality, performance, accuracy, and effort is with + * the user. + * + * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are + * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson + * Distributed according to the same disclaimer and license as libpng-0.96, + * with the following individuals added to the list of Contributing Authors: + * + * Tom Lane + * Glenn Randers-Pehrson + * Willem van Schaik + * + * libpng versions 0.89, June 1996, through 0.96, May 1997, are + * Copyright (c) 1996, 1997 Andreas Dilger + * Distributed according to the same disclaimer and license as libpng-0.88, + * with the following individuals added to the list of Contributing Authors: + * + * John Bowler + * Kevin Bracey + * Sam Bushell + * Magnus Holmgren + * Greg Roelofs + * Tom Tanner + * + * libpng versions 0.5, May 1995, through 0.88, January 1996, are + * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. + * + * For the purposes of this copyright and license, "Contributing Authors" + * is defined as the following set of individuals: + * + * Andreas Dilger + * Dave Martindale + * Guy Eric Schalnat + * Paul Schmidt + * Tim Wegner + * + * The PNG Reference Library is supplied "AS IS". The Contributing Authors + * and Group 42, Inc. disclaim all warranties, expressed or implied, + * including, without limitation, the warranties of merchantability and of + * fitness for any purpose. The Contributing Authors and Group 42, Inc. + * assume no liability for direct, indirect, incidental, special, exemplary, + * or consequential damages, which may result from the use of the PNG + * Reference Library, even if advised of the possibility of such damage. + * + * Permission is hereby granted to use, copy, modify, and distribute this + * source code, or portions hereof, for any purpose, without fee, subject + * to the following restrictions: + * + * 1. The origin of this source code must not be misrepresented. + * + * 2. Altered versions must be plainly marked as such and + * must not be misrepresented as being the original source. + * + * 3. This Copyright notice may not be removed or altered from + * any source or altered source distribution. + * + * The Contributing Authors and Group 42, Inc. specifically permit, without + * fee, and encourage the use of this source code as a component to + * supporting the PNG file format in commercial products. If you use this + * source code in a product, acknowledgment is not required but would be + * appreciated. + */ + +/* + * A "png_get_copyright" function is available, for convenient use in "about" + * boxes and the like: + * + * printf("%s",png_get_copyright(NULL)); + * + * Also, the PNG logo (in PNG format, of course) is supplied in the + * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). + */ + +/* + * Libpng is OSI Certified Open Source Software. OSI Certified is a + * certification mark of the Open Source Initiative. + */ + +/* + * The contributing authors would like to thank all those who helped + * with testing, bug fixes, and patience. This wouldn't have been + * possible without all of you. + * + * Thanks to Frank J. T. Wojcik for helping with the documentation. + */ + +/* + * Y2K compliance in libpng: + * ========================= + * + * July 8, 2002 + * + * Since the PNG Development group is an ad-hoc body, we can't make + * an official declaration. + * + * This is your unofficial assurance that libpng from version 0.71 and + * upward through 1.2.4 are Y2K compliant. It is my belief that earlier + * versions were also Y2K compliant. + * + * Libpng only has three year fields. One is a 2-byte unsigned integer + * that will hold years up to 65535. The other two hold the date in text + * format, and will hold years up to 9999. + * + * The integer is + * "png_uint_16 year" in png_time_struct. + * + * The strings are + * "png_charp time_buffer" in png_struct and + * "near_time_buffer", which is a local character string in png.c. + * + * There are seven time-related functions: + * png.c: png_convert_to_rfc_1123() in png.c + * (formerly png_convert_to_rfc_1152() in error) + * png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c + * png_convert_from_time_t() in pngwrite.c + * png_get_tIME() in pngget.c + * png_handle_tIME() in pngrutil.c, called in pngread.c + * png_set_tIME() in pngset.c + * png_write_tIME() in pngwutil.c, called in pngwrite.c + * + * All handle dates properly in a Y2K environment. The + * png_convert_from_time_t() function calls gmtime() to convert from system + * clock time, which returns (year - 1900), which we properly convert to + * the full 4-digit year. There is a possibility that applications using + * libpng are not passing 4-digit years into the png_convert_to_rfc_1123() + * function, or that they are incorrectly passing only a 2-digit year + * instead of "year - 1900" into the png_convert_from_struct_tm() function, + * but this is not under our control. The libpng documentation has always + * stated that it works with 4-digit years, and the APIs have been + * documented as such. + * + * The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned + * integer to hold the year, and can hold years as large as 65535. + * + * zlib, upon which libpng depends, is also Y2K compliant. It contains + * no date-related code. + * + * Glenn Randers-Pehrson + * libpng maintainer + * PNG Development Group + */ + +#ifndef PNG_H +#define PNG_H + +/* This is not the place to learn how to use libpng. The file libpng.txt + * describes how to use libpng, and the file example.c summarizes it + * with some code on which to build. This file is useful for looking + * at the actual function definitions and structure components. + */ + +/* Version information for png.h - this should match the version in png.c */ +#define PNG_LIBPNG_VER_STRING "1.2.4" + +#define PNG_LIBPNG_VER_SONUM 0 +#define PNG_LIBPNG_VER_DLLNUM %DLLNUM% + +/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ +#define PNG_LIBPNG_VER_MAJOR 1 +#define PNG_LIBPNG_VER_MINOR 2 +#define PNG_LIBPNG_VER_RELEASE 4 +/* This should match the numeric part of the final component of + * PNG_LIBPNG_VER_STRING, omitting any leading zero: */ + +#define PNG_LIBPNG_VER_BUILD 0 + +#define PNG_LIBPNG_BUILD_ALPHA 1 +#define PNG_LIBPNG_BUILD_BETA 2 +#define PNG_LIBPNG_BUILD_RC 3 +#define PNG_LIBPNG_BUILD_STABLE 4 +#define PNG_LIBPNG_BUILD_TYPEMASK 7 +#define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with STABLE only */ +#define PNG_LIBPNG_BUILD_TYPE 4 + +/* Careful here. At one time, Guy wanted to use 082, but that would be octal. + * We must not include leading zeros. + * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only + * version 1.0.0 was mis-numbered 100 instead of 10000). From + * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release */ +#define PNG_LIBPNG_VER 10204 /* 1.2.4 */ + +#ifndef PNG_VERSION_INFO_ONLY + +/* include the compression library's header */ +#include "zlib.h" + +/* include all user configurable info, including optional assembler routines */ +#include "pngconf.h" + +/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* This file is arranged in several sections. The first section contains + * structure and type definitions. The second section contains the external + * library functions, while the third has the internal library functions, + * which applications aren't expected to use directly. + */ + +#ifndef PNG_NO_TYPECAST_NULL +#define int_p_NULL (int *)NULL +#define png_bytep_NULL (png_bytep)NULL +#define png_bytepp_NULL (png_bytepp)NULL +#define png_doublep_NULL (png_doublep)NULL +#define png_error_ptr_NULL (png_error_ptr)NULL +#define png_flush_ptr_NULL (png_flush_ptr)NULL +#define png_free_ptr_NULL (png_free_ptr)NULL +#define png_infopp_NULL (png_infopp)NULL +#define png_malloc_ptr_NULL (png_malloc_ptr)NULL +#define png_read_status_ptr_NULL (png_read_status_ptr)NULL +#define png_rw_ptr_NULL (png_rw_ptr)NULL +#define png_structp_NULL (png_structp)NULL +#define png_uint_16p_NULL (png_uint_16p)NULL +#define png_voidp_NULL (png_voidp)NULL +#define png_write_status_ptr_NULL (png_write_status_ptr)NULL +#else +#define int_p_NULL NULL +#define png_bytep_NULL NULL +#define png_bytepp_NULL NULL +#define png_doublep_NULL NULL +#define png_error_ptr_NULL NULL +#define png_flush_ptr_NULL NULL +#define png_free_ptr_NULL NULL +#define png_infopp_NULL NULL +#define png_malloc_ptr_NULL NULL +#define png_read_status_ptr_NULL NULL +#define png_rw_ptr_NULL NULL +#define png_structp_NULL NULL +#define png_uint_16p_NULL NULL +#define png_voidp_NULL NULL +#define png_write_status_ptr_NULL NULL +#endif + +/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ +#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) +/* Version information for C files, stored in png.c. This had better match + * the version above. + */ +#ifdef PNG_USE_GLOBAL_ARRAYS +PNG_EXPORT_VAR (const char) png_libpng_ver[18]; + /* need room for 99.99.99beta99z */ +#else +#define png_libpng_ver png_get_header_ver(NULL) +#endif + +#ifdef PNG_USE_GLOBAL_ARRAYS +/* This was removed in version 1.0.5c */ +/* Structures to facilitate easy interlacing. See png.c for more details */ +PNG_EXPORT_VAR (const int FARDATA) png_pass_start[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_inc[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_ystart[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_yinc[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_mask[7]; +PNG_EXPORT_VAR (const int FARDATA) png_pass_dsp_mask[7]; +#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW +PNG_EXPORT_VAR (const int FARDATA) png_pass_width[7]; +#endif +/* This isn't currently used. If you need it, see png.c for more details. +PNG_EXPORT_VAR (const int FARDATA) png_pass_height[7]; +*/ +#endif + +#endif /* PNG_NO_EXTERN */ + +/* Three color definitions. The order of the red, green, and blue, (and the + * exact size) is not important, although the size of the fields need to + * be png_byte or png_uint_16 (as defined below). + */ +typedef struct png_color_struct +{ + png_byte red; + png_byte green; + png_byte blue; +} png_color; +typedef png_color FAR * png_colorp; +typedef png_color FAR * FAR * png_colorpp; + +typedef struct png_color_16_struct +{ + png_byte index; /* used for palette files */ + png_uint_16 red; /* for use in red green blue files */ + png_uint_16 green; + png_uint_16 blue; + png_uint_16 gray; /* for use in grayscale files */ +} png_color_16; +typedef png_color_16 FAR * png_color_16p; +typedef png_color_16 FAR * FAR * png_color_16pp; + +typedef struct png_color_8_struct +{ + png_byte red; /* for use in red green blue files */ + png_byte green; + png_byte blue; + png_byte gray; /* for use in grayscale files */ + png_byte alpha; /* for alpha channel files */ +} png_color_8; +typedef png_color_8 FAR * png_color_8p; +typedef png_color_8 FAR * FAR * png_color_8pp; + +/* + * The following two structures are used for the in-core representation + * of sPLT chunks. + */ +typedef struct png_sPLT_entry_struct +{ + png_uint_16 red; + png_uint_16 green; + png_uint_16 blue; + png_uint_16 alpha; + png_uint_16 frequency; +} png_sPLT_entry; +typedef png_sPLT_entry FAR * png_sPLT_entryp; +typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; + +/* When the depth of the sPLT palette is 8 bits, the color and alpha samples + * occupy the LSB of their respective members, and the MSB of each member + * is zero-filled. The frequency member always occupies the full 16 bits. + */ + +typedef struct png_sPLT_struct +{ + png_charp name; /* palette name */ + png_byte depth; /* depth of palette samples */ + png_sPLT_entryp entries; /* palette entries */ + png_int_32 nentries; /* number of palette entries */ +} png_sPLT_t; +typedef png_sPLT_t FAR * png_sPLT_tp; +typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; + +#ifdef PNG_TEXT_SUPPORTED +/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file, + * and whether that contents is compressed or not. The "key" field + * points to a regular zero-terminated C string. The "text", "lang", and + * "lang_key" fields can be regular C strings, empty strings, or NULL pointers. + * However, the * structure returned by png_get_text() will always contain + * regular zero-terminated C strings (possibly empty), never NULL pointers, + * so they can be safely used in printf() and other string-handling functions. + */ +typedef struct png_text_struct +{ + int compression; /* compression value: + -1: tEXt, none + 0: zTXt, deflate + 1: iTXt, none + 2: iTXt, deflate */ + png_charp key; /* keyword, 1-79 character description of "text" */ + png_charp text; /* comment, may be an empty string (ie "") + or a NULL pointer */ + png_size_t text_length; /* length of the text string */ +#ifdef PNG_iTXt_SUPPORTED + png_size_t itxt_length; /* length of the itxt string */ + png_charp lang; /* language code, 0-79 characters + or a NULL pointer */ + png_charp lang_key; /* keyword translated UTF-8 string, 0 or more + chars or a NULL pointer */ +#endif +} png_text; +typedef png_text FAR * png_textp; +typedef png_text FAR * FAR * png_textpp; +#endif + +/* Supported compression types for text in PNG files (tEXt, and zTXt). + * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */ +#define PNG_TEXT_COMPRESSION_NONE_WR -3 +#define PNG_TEXT_COMPRESSION_zTXt_WR -2 +#define PNG_TEXT_COMPRESSION_NONE -1 +#define PNG_TEXT_COMPRESSION_zTXt 0 +#define PNG_ITXT_COMPRESSION_NONE 1 +#define PNG_ITXT_COMPRESSION_zTXt 2 +#define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */ + +/* png_time is a way to hold the time in an machine independent way. + * Two conversions are provided, both from time_t and struct tm. There + * is no portable way to convert to either of these structures, as far + * as I know. If you know of a portable way, send it to me. As a side + * note - PNG has always been Year 2000 compliant! + */ +typedef struct png_time_struct +{ + png_uint_16 year; /* full year, as in, 1995 */ + png_byte month; /* month of year, 1 - 12 */ + png_byte day; /* day of month, 1 - 31 */ + png_byte hour; /* hour of day, 0 - 23 */ + png_byte minute; /* minute of hour, 0 - 59 */ + png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ +} png_time; +typedef png_time FAR * png_timep; +typedef png_time FAR * FAR * png_timepp; + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +/* png_unknown_chunk is a structure to hold queued chunks for which there is + * no specific support. The idea is that we can use this to queue + * up private chunks for output even though the library doesn't actually + * know about their semantics. + */ +typedef struct png_unknown_chunk_t +{ + png_byte name[5]; + png_byte *data; + png_size_t size; + + /* libpng-using applications should NOT directly modify this byte. */ + png_byte location; /* mode of operation at read time */ +} +png_unknown_chunk; +typedef png_unknown_chunk FAR * png_unknown_chunkp; +typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; +#endif + +/* png_info is a structure that holds the information in a PNG file so + * that the application can find out the characteristics of the image. + * If you are reading the file, this structure will tell you what is + * in the PNG file. If you are writing the file, fill in the information + * you want to put into the PNG file, then call png_write_info(). + * The names chosen should be very close to the PNG specification, so + * consult that document for information about the meaning of each field. + * + * With libpng < 0.95, it was only possible to directly set and read the + * the values in the png_info_struct, which meant that the contents and + * order of the values had to remain fixed. With libpng 0.95 and later, + * however, there are now functions that abstract the contents of + * png_info_struct from the application, so this makes it easier to use + * libpng with dynamic libraries, and even makes it possible to use + * libraries that don't have all of the libpng ancillary chunk-handing + * functionality. + * + * In any case, the order of the parameters in png_info_struct should NOT + * be changed for as long as possible to keep compatibility with applications + * that use the old direct-access method with png_info_struct. + * + * The following members may have allocated storage attached that should be + * cleaned up before the structure is discarded: palette, trans, text, + * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, + * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these + * are automatically freed when the info structure is deallocated, if they were + * allocated internally by libpng. This behavior can be changed by means + * of the png_data_freer() function. + * + * More allocation details: all the chunk-reading functions that + * change these members go through the corresponding png_set_* + * functions. A function to clear these members is available: see + * png_free_data(). The png_set_* functions do not depend on being + * able to point info structure members to any of the storage they are + * passed (they make their own copies), EXCEPT that the png_set_text + * functions use the same storage passed to them in the text_ptr or + * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns + * functions do not make their own copies. + */ +typedef struct png_info_struct +{ + /* the following are necessary for every PNG file */ + png_uint_32 width; /* width of image in pixels (from IHDR) */ + png_uint_32 height; /* height of image in pixels (from IHDR) */ + png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */ + png_uint_32 rowbytes; /* bytes needed to hold an untransformed row */ + png_colorp palette; /* array of color values (valid & PNG_INFO_PLTE) */ + png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */ + png_uint_16 num_trans; /* number of transparent palette color (tRNS) */ + png_byte bit_depth; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */ + png_byte color_type; /* see PNG_COLOR_TYPE_ below (from IHDR) */ + /* The following three should have been named *_method not *_type */ + png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */ + png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ + png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ + + /* The following is informational only on read, and not used on writes. */ + png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */ + png_byte pixel_depth; /* number of bits per pixel */ + png_byte spare_byte; /* to align the data, and for future use */ + png_byte signature[8]; /* magic bytes read by libpng from start of file */ + + /* The rest of the data is optional. If you are reading, check the + * valid field to see if the information in these are valid. If you + * are writing, set the valid field to those chunks you want written, + * and initialize the appropriate fields below. + */ + +#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) + /* The gAMA chunk describes the gamma characteristics of the system + * on which the image was created, normally in the range [1.0, 2.5]. + * Data is valid if (valid & PNG_INFO_gAMA) is non-zero. + */ + float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */ +#endif + +#if defined(PNG_sRGB_SUPPORTED) + /* GR-P, 0.96a */ + /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ + png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */ +#endif + +#if defined(PNG_TEXT_SUPPORTED) + /* The tEXt, and zTXt chunks contain human-readable textual data in + * uncompressed, compressed, and optionally compressed forms, respectively. + * The data in "text" is an array of pointers to uncompressed, + * null-terminated C strings. Each chunk has a keyword that describes the + * textual data contained in that chunk. Keywords are not required to be + * unique, and the text string may be empty. Any number of text chunks may + * be in an image. + */ + int num_text; /* number of comments read/to write */ + int max_text; /* current size of text array */ + png_textp text; /* array of comments read/to write */ +#endif /* PNG_TEXT_SUPPORTED */ + +#if defined(PNG_tIME_SUPPORTED) + /* The tIME chunk holds the last time the displayed image data was + * modified. See the png_time struct for the contents of this struct. + */ + png_time mod_time; +#endif + +#if defined(PNG_sBIT_SUPPORTED) + /* The sBIT chunk specifies the number of significant high-order bits + * in the pixel data. Values are in the range [1, bit_depth], and are + * only specified for the channels in the pixel data. The contents of + * the low-order bits is not specified. Data is valid if + * (valid & PNG_INFO_sBIT) is non-zero. + */ + png_color_8 sig_bit; /* significant bits in color channels */ +#endif + +#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ +defined(PNG_READ_BACKGROUND_SUPPORTED) + /* The tRNS chunk supplies transparency data for paletted images and + * other image types that don't need a full alpha channel. There are + * "num_trans" transparency values for a paletted image, stored in the + * same order as the palette colors, starting from index 0. Values + * for the data are in the range [0, 255], ranging from fully transparent + * to fully opaque, respectively. For non-paletted images, there is a + * single color specified that should be treated as fully transparent. + * Data is valid if (valid & PNG_INFO_tRNS) is non-zero. + */ + png_bytep trans; /* transparent values for paletted image */ + png_color_16 trans_values; /* transparent color for non-palette image */ +#endif + +#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + /* The bKGD chunk gives the suggested image background color if the + * display program does not have its own background color and the image + * is needs to composited onto a background before display. The colors + * in "background" are normally in the same color space/depth as the + * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. + */ + png_color_16 background; +#endif + +#if defined(PNG_oFFs_SUPPORTED) + /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards + * and downwards from the top-left corner of the display, page, or other + * application-specific co-ordinate space. See the PNG_OFFSET_ defines + * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. + */ + png_int_32 x_offset; /* x offset on page */ + png_int_32 y_offset; /* y offset on page */ + png_byte offset_unit_type; /* offset units type */ +#endif + +#if defined(PNG_pHYs_SUPPORTED) + /* The pHYs chunk gives the physical pixel density of the image for + * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ + * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. + */ + png_uint_32 x_pixels_per_unit; /* horizontal pixel density */ + png_uint_32 y_pixels_per_unit; /* vertical pixel density */ + png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */ +#endif + +#if defined(PNG_hIST_SUPPORTED) + /* The hIST chunk contains the relative frequency or importance of the + * various palette entries, so that a viewer can intelligently select a + * reduced-color palette, if required. Data is an array of "num_palette" + * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) + * is non-zero. + */ + png_uint_16p hist; +#endif + +#ifdef PNG_cHRM_SUPPORTED + /* The cHRM chunk describes the CIE color characteristics of the monitor + * on which the PNG was created. This data allows the viewer to do gamut + * mapping of the input image to ensure that the viewer sees the same + * colors in the image as the creator. Values are in the range + * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. + */ +#ifdef PNG_FLOATING_POINT_SUPPORTED + float x_white; + float y_white; + float x_red; + float y_red; + float x_green; + float y_green; + float x_blue; + float y_blue; +#endif +#endif + +#if defined(PNG_pCAL_SUPPORTED) + /* The pCAL chunk describes a transformation between the stored pixel + * values and original physical data values used to create the image. + * The integer range [0, 2^bit_depth - 1] maps to the floating-point + * range given by [pcal_X0, pcal_X1], and are further transformed by a + * (possibly non-linear) transformation function given by "pcal_type" + * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ + * defines below, and the PNG-Group's PNG extensions document for a + * complete description of the transformations and how they should be + * implemented, and for a description of the ASCII parameter strings. + * Data values are valid if (valid & PNG_INFO_pCAL) non-zero. + */ + png_charp pcal_purpose; /* pCAL chunk description string */ + png_int_32 pcal_X0; /* minimum value */ + png_int_32 pcal_X1; /* maximum value */ + png_charp pcal_units; /* Latin-1 string giving physical units */ + png_charpp pcal_params; /* ASCII strings containing parameter values */ + png_byte pcal_type; /* equation type (see PNG_EQUATION_ below) */ + png_byte pcal_nparams; /* number of parameters given in pcal_params */ +#endif + +/* New members added in libpng-1.0.6 */ +#ifdef PNG_FREE_ME_SUPPORTED + png_uint_32 free_me; /* flags items libpng is responsible for freeing */ +#endif + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) + /* storage for unknown chunks that the library doesn't recognize. */ + png_unknown_chunkp unknown_chunks; + png_size_t unknown_chunks_num; +#endif + +#if defined(PNG_iCCP_SUPPORTED) + /* iCCP chunk data. */ + png_charp iccp_name; /* profile name */ + png_charp iccp_profile; /* International Color Consortium profile data */ + /* Note to maintainer: should be png_bytep */ + png_uint_32 iccp_proflen; /* ICC profile data length */ + png_byte iccp_compression; /* Always zero */ +#endif + +#if defined(PNG_sPLT_SUPPORTED) + /* data on sPLT chunks (there may be more than one). */ + png_sPLT_tp splt_palettes; + png_uint_32 splt_palettes_num; +#endif + +#if defined(PNG_sCAL_SUPPORTED) + /* The sCAL chunk describes the actual physical dimensions of the + * subject matter of the graphic. The chunk contains a unit specification + * a byte value, and two ASCII strings representing floating-point + * values. The values are width and height corresponsing to one pixel + * in the image. This external representation is converted to double + * here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero. + */ + png_byte scal_unit; /* unit of physical scale */ +#ifdef PNG_FLOATING_POINT_SUPPORTED + double scal_pixel_width; /* width of one pixel */ + double scal_pixel_height; /* height of one pixel */ +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED + png_charp scal_s_width; /* string containing height */ + png_charp scal_s_height; /* string containing width */ +#endif +#endif + +#if defined(PNG_INFO_IMAGE_SUPPORTED) + /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */ + /* Data valid if (valid & PNG_INFO_IDAT) non-zero */ + png_bytepp row_pointers; /* the image bits */ +#endif + +#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED) + png_fixed_point int_gamma; /* gamma of image, if (valid & PNG_INFO_gAMA) */ +#endif + +#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED) + png_fixed_point int_x_white; + png_fixed_point int_y_white; + png_fixed_point int_x_red; + png_fixed_point int_y_red; + png_fixed_point int_x_green; + png_fixed_point int_y_green; + png_fixed_point int_x_blue; + png_fixed_point int_y_blue; +#endif + +} png_info; + +typedef png_info FAR * png_infop; +typedef png_info FAR * FAR * png_infopp; + +/* Maximum positive integer used in PNG is (2^31)-1 */ +#define PNG_MAX_UINT ((png_uint_32)0x7fffffffL) + +/* These describe the color_type field in png_info. */ +/* color type masks */ +#define PNG_COLOR_MASK_PALETTE 1 +#define PNG_COLOR_MASK_COLOR 2 +#define PNG_COLOR_MASK_ALPHA 4 + +/* color types. Note that not all combinations are legal */ +#define PNG_COLOR_TYPE_GRAY 0 +#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE) +#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR) +#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) +#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA) +/* aliases */ +#define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA +#define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA + +/* This is for compression type. PNG 1.0-1.2 only define the single type. */ +#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */ +#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE + +/* This is for filter type. PNG 1.0-1.2 only define the single type. */ +#define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */ +#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */ +#define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE + +/* These are for the interlacing type. These values should NOT be changed. */ +#define PNG_INTERLACE_NONE 0 /* Non-interlaced image */ +#define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */ +#define PNG_INTERLACE_LAST 2 /* Not a valid value */ + +/* These are for the oFFs chunk. These values should NOT be changed. */ +#define PNG_OFFSET_PIXEL 0 /* Offset in pixels */ +#define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */ +#define PNG_OFFSET_LAST 2 /* Not a valid value */ + +/* These are for the pCAL chunk. These values should NOT be changed. */ +#define PNG_EQUATION_LINEAR 0 /* Linear transformation */ +#define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */ +#define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */ +#define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */ +#define PNG_EQUATION_LAST 4 /* Not a valid value */ + +/* These are for the sCAL chunk. These values should NOT be changed. */ +#define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */ +#define PNG_SCALE_METER 1 /* meters per pixel */ +#define PNG_SCALE_RADIAN 2 /* radians per pixel */ +#define PNG_SCALE_LAST 3 /* Not a valid value */ + +/* These are for the pHYs chunk. These values should NOT be changed. */ +#define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */ +#define PNG_RESOLUTION_METER 1 /* pixels/meter */ +#define PNG_RESOLUTION_LAST 2 /* Not a valid value */ + +/* These are for the sRGB chunk. These values should NOT be changed. */ +#define PNG_sRGB_INTENT_PERCEPTUAL 0 +#define PNG_sRGB_INTENT_RELATIVE 1 +#define PNG_sRGB_INTENT_SATURATION 2 +#define PNG_sRGB_INTENT_ABSOLUTE 3 +#define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */ + +/* This is for text chunks */ +#define PNG_KEYWORD_MAX_LENGTH 79 + +/* Maximum number of entries in PLTE/sPLT/tRNS arrays */ +#define PNG_MAX_PALETTE_LENGTH 256 + +/* These determine if an ancillary chunk's data has been successfully read + * from the PNG header, or if the application has filled in the corresponding + * data in the info_struct to be written into the output file. The values + * of the PNG_INFO_ defines should NOT be changed. + */ +#define PNG_INFO_gAMA 0x0001 +#define PNG_INFO_sBIT 0x0002 +#define PNG_INFO_cHRM 0x0004 +#define PNG_INFO_PLTE 0x0008 +#define PNG_INFO_tRNS 0x0010 +#define PNG_INFO_bKGD 0x0020 +#define PNG_INFO_hIST 0x0040 +#define PNG_INFO_pHYs 0x0080 +#define PNG_INFO_oFFs 0x0100 +#define PNG_INFO_tIME 0x0200 +#define PNG_INFO_pCAL 0x0400 +#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ +#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ +#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ +#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ +#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ + +/* This is used for the transformation routines, as some of them + * change these values for the row. It also should enable using + * the routines for other purposes. + */ +typedef struct png_row_info_struct +{ + png_uint_32 width; /* width of row */ + png_uint_32 rowbytes; /* number of bytes in row */ + png_byte color_type; /* color type of row */ + png_byte bit_depth; /* bit depth of row */ + png_byte channels; /* number of channels (1, 2, 3, or 4) */ + png_byte pixel_depth; /* bits per pixel (depth * channels) */ +} png_row_info; + +typedef png_row_info FAR * png_row_infop; +typedef png_row_info FAR * FAR * png_row_infopp; + +/* These are the function types for the I/O functions and for the functions + * that allow the user to override the default I/O functions with his or her + * own. The png_error_ptr type should match that of user-supplied warning + * and error functions, while the png_rw_ptr type should match that of the + * user read/write data functions. + */ +typedef struct png_struct_def png_struct; +typedef png_struct FAR * png_structp; + +typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); +typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); +typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); +typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, + int)); +typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, + int)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); +typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); +typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, + png_uint_32, int)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, + png_row_infop, png_bytep)); +#endif + +#if defined(PNG_USER_CHUNKS_SUPPORTED) +typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); +#endif +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); +#endif + +/* Transform masks for the high-level interface */ +#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ +#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ +#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ +#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ +#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ +#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ +#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ +#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ +#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ +#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ +#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ +#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ +#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */ + +/* Flags for MNG supported features */ +#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 +#define PNG_FLAG_MNG_FILTER_64 0x04 +#define PNG_ALL_MNG_FEATURES 0x05 + +typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); +typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); + +/* The structure that holds the information to read and write PNG files. + * The only people who need to care about what is inside of this are the + * people who will be modifying the library for their own special needs. + * It should NOT be accessed directly by an application, except to store + * the jmp_buf. + */ + +struct png_struct_def +{ +#ifdef PNG_SETJMP_SUPPORTED + jmp_buf jmpbuf; /* used in png_error */ +#endif + png_error_ptr error_fn; /* function for printing errors and aborting */ + png_error_ptr warning_fn; /* function for printing warnings */ + png_voidp error_ptr; /* user supplied struct for error functions */ + png_rw_ptr write_data_fn; /* function for writing output data */ + png_rw_ptr read_data_fn; /* function for reading input data */ + png_voidp io_ptr; /* ptr to application struct for I/O functions */ + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) + png_user_transform_ptr read_user_transform_fn; /* user read transform */ +#endif + +#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) + png_user_transform_ptr write_user_transform_fn; /* user write transform */ +#endif + +/* These were added in libpng-1.0.2 */ +#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) + png_voidp user_transform_ptr; /* user supplied struct for user transform */ + png_byte user_transform_depth; /* bit depth of user transformed pixels */ + png_byte user_transform_channels; /* channels in user transformed pixels */ +#endif +#endif + + png_uint_32 mode; /* tells us where we are in the PNG file */ + png_uint_32 flags; /* flags indicating various things to libpng */ + png_uint_32 transformations; /* which transformations to perform */ + + z_stream zstream; /* pointer to decompression structure (below) */ + png_bytep zbuf; /* buffer for zlib */ + png_size_t zbuf_size; /* size of zbuf */ + int zlib_level; /* holds zlib compression level */ + int zlib_method; /* holds zlib compression method */ + int zlib_window_bits; /* holds zlib compression window bits */ + int zlib_mem_level; /* holds zlib compression memory level */ + int zlib_strategy; /* holds zlib compression strategy */ + + png_uint_32 width; /* width of image in pixels */ + png_uint_32 height; /* height of image in pixels */ + png_uint_32 num_rows; /* number of rows in current pass */ + png_uint_32 usr_width; /* width of row at start of write */ + png_uint_32 rowbytes; /* size of row in bytes */ + png_uint_32 irowbytes; /* size of current interlaced row in bytes */ + png_uint_32 iwidth; /* width of current interlaced row in pixels */ + png_uint_32 row_number; /* current row in interlace pass */ + png_bytep prev_row; /* buffer to save previous (unfiltered) row */ + png_bytep row_buf; /* buffer to save current (unfiltered) row */ + png_bytep sub_row; /* buffer to save "sub" row when filtering */ + png_bytep up_row; /* buffer to save "up" row when filtering */ + png_bytep avg_row; /* buffer to save "avg" row when filtering */ + png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ + png_row_info row_info; /* used for transformation routines */ + + png_uint_32 idat_size; /* current IDAT size for read */ + png_uint_32 crc; /* current chunk CRC value */ + png_colorp palette; /* palette from the input file */ + png_uint_16 num_palette; /* number of color entries in palette */ + png_uint_16 num_trans; /* number of transparency values */ + png_byte chunk_name[5]; /* null-terminated name of current chunk */ + png_byte compression; /* file compression type (always 0) */ + png_byte filter; /* file filter type (always 0) */ + png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ + png_byte pass; /* current interlace pass (0 - 6) */ + png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ + png_byte color_type; /* color type of file */ + png_byte bit_depth; /* bit depth of file */ + png_byte usr_bit_depth; /* bit depth of users row */ + png_byte pixel_depth; /* number of bits per pixel */ + png_byte channels; /* number of channels in file */ + png_byte usr_channels; /* channels at start of write */ + png_byte sig_bytes; /* magic bytes read/written from start of file */ + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +#ifdef PNG_LEGACY_SUPPORTED + png_byte filler; /* filler byte for pixel expansion */ +#else + png_uint_16 filler; /* filler bytes for pixel expansion */ +#endif +#endif + +#if defined(PNG_bKGD_SUPPORTED) + png_byte background_gamma_type; +# ifdef PNG_FLOATING_POINT_SUPPORTED + float background_gamma; +# endif + png_color_16 background; /* background color in screen gamma space */ +#if defined(PNG_READ_GAMMA_SUPPORTED) + png_color_16 background_1; /* background normalized to gamma 1.0 */ +#endif +#endif /* PNG_bKGD_SUPPORTED */ + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) + png_flush_ptr output_flush_fn;/* Function for flushing output */ + png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ + png_uint_32 flush_rows; /* number of rows written since last flush */ +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + int gamma_shift; /* number of "insignificant" bits 16-bit gamma */ +#ifdef PNG_FLOATING_POINT_SUPPORTED + float gamma; /* file gamma value */ + float screen_gamma; /* screen gamma value (display_exponent) */ +#endif +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_bytep gamma_table; /* gamma table for 8-bit depth files */ + png_bytep gamma_from_1; /* converts from 1.0 to screen */ + png_bytep gamma_to_1; /* converts from file to 1.0 */ + png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ + png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ + png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) + png_color_8 sig_bit; /* significant bits in each available channel */ +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) + png_color_8 shift; /* shift for significant bit tranformation */ +#endif + +#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ + || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_bytep trans; /* transparency values for paletted files */ + png_color_16 trans_values; /* transparency values for non-paletted files */ +#endif + + png_read_status_ptr read_row_fn; /* called after each row is decoded */ + png_write_status_ptr write_row_fn; /* called after each row is encoded */ +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED + png_progressive_info_ptr info_fn; /* called after header data fully read */ + png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */ + png_progressive_end_ptr end_fn; /* called after image is complete */ + png_bytep save_buffer_ptr; /* current location in save_buffer */ + png_bytep save_buffer; /* buffer for previously read data */ + png_bytep current_buffer_ptr; /* current location in current_buffer */ + png_bytep current_buffer; /* buffer for recently used data */ + png_uint_32 push_length; /* size of current input chunk */ + png_uint_32 skip_length; /* bytes to skip in input data */ + png_size_t save_buffer_size; /* amount of data now in save_buffer */ + png_size_t save_buffer_max; /* total size of save_buffer */ + png_size_t buffer_size; /* total amount of available input data */ + png_size_t current_buffer_size; /* amount of data now in current_buffer */ + int process_mode; /* what push library is currently doing */ + int cur_palette; /* current push library palette index */ + +# if defined(PNG_TEXT_SUPPORTED) + png_size_t current_text_size; /* current size of text input data */ + png_size_t current_text_left; /* how much text left to read in input */ + png_charp current_text; /* current text chunk buffer */ + png_charp current_text_ptr; /* current location in current_text */ +# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */ + +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) +/* for the Borland special 64K segment handler */ + png_bytepp offset_table_ptr; + png_bytep offset_table; + png_uint_16 offset_table_number; + png_uint_16 offset_table_count; + png_uint_16 offset_table_count_free; +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) + png_bytep palette_lookup; /* lookup table for dithering */ + png_bytep dither_index; /* index translation for palette files */ +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) + png_uint_16p hist; /* histogram */ +#endif + +#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) + png_byte heuristic_method; /* heuristic for row filter selection */ + png_byte num_prev_filters; /* number of weights for previous rows */ + png_bytep prev_filters; /* filter type(s) of previous row(s) */ + png_uint_16p filter_weights; /* weight(s) for previous line(s) */ + png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ + png_uint_16p filter_costs; /* relative filter calculation cost */ + png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ +#endif + +#if defined(PNG_TIME_RFC1123_SUPPORTED) + png_charp time_buffer; /* String to hold RFC 1123 time text */ +#endif + +/* New members added in libpng-1.0.6 */ + +#ifdef PNG_FREE_ME_SUPPORTED + png_uint_32 free_me; /* flags items libpng is responsible for freeing */ +#endif + +#if defined(PNG_USER_CHUNKS_SUPPORTED) + png_voidp user_chunk_ptr; + png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ +#endif + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) + int num_chunk_list; + png_bytep chunk_list; +#endif + +/* New members added in libpng-1.0.3 */ +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) + png_byte rgb_to_gray_status; + /* These were changed from png_byte in libpng-1.0.6 */ + png_uint_16 rgb_to_gray_red_coeff; + png_uint_16 rgb_to_gray_green_coeff; + png_uint_16 rgb_to_gray_blue_coeff; +#endif + +/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ +#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ + defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ + defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +/* changed from png_byte to png_uint_32 at version 1.2.0 */ +#ifdef PNG_1_0_X + png_byte mng_features_permitted; +#else + png_uint_32 mng_features_permitted; +#endif /* PNG_1_0_X */ +#endif + +/* New member added in libpng-1.0.7 */ +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_fixed_point int_gamma; +#endif + +/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ +#if defined(PNG_MNG_FEATURES_SUPPORTED) + png_byte filter_type; +#endif + +#if defined(PNG_1_0_X) || (defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD)) +/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ + png_uint_32 row_buf_size; +#endif + +/* New members added in libpng-1.2.0 */ +#if !defined(PNG_1_0_X) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) + png_byte mmx_bitdepth_threshold; + png_uint_32 mmx_rowbytes_threshold; + png_uint_32 asm_flags; +#endif + +/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ +#ifdef PNG_USER_MEM_SUPPORTED + png_voidp mem_ptr; /* user supplied struct for mem functions */ + png_malloc_ptr malloc_fn; /* function for allocating memory */ + png_free_ptr free_fn; /* function for freeing memory */ +#endif + +/* New member added in libpng-1.0.13 and 1.2.0 */ + png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ + +#if defined(PNG_READ_DITHER_SUPPORTED) +/* The following three members were added at version 1.0.14 and 1.2.4 */ + png_bytep dither_sort; /* working sort array */ + png_bytep index_to_palette; /* where the original index currently is */ + /* in the palette */ + png_bytep palette_to_index; /* which original index points to this */ + /* palette color */ +#endif + +}; + + +/* This prevents a compiler error in png.c if png.c and png.h are both at + version 1.2.4 + */ +typedef png_structp version_1_2_4; + +typedef png_struct FAR * FAR * png_structpp; + +/* Here are the function definitions most commonly used. This is not + * the place to find out how to use libpng. See libpng.txt for the + * full explanation, see example.c for the summary. This just provides + * a simple one line description of the use of each function. + */ + +/* Returns the version number of the library */ +extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); + +/* Tell lib we have already handled the first magic bytes. + * Handling more than 8 bytes from the beginning of the file is an error. + */ +extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, + int num_bytes)); + +/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a + * PNG file. Returns zero if the supplied bytes match the 8-byte PNG + * signature, and non-zero otherwise. Having num_to_check == 0 or + * start > 7 will always fail (ie return non-zero). + */ +extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, + png_size_t num_to_check)); + +/* Simple signature checking function. This is the same as calling + * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). + */ +extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); + +/* Allocate and initialize png_ptr struct for reading, and any other memory. */ +extern PNG_EXPORT(png_structp,png_create_read_struct) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn)); + +/* Allocate and initialize png_ptr struct for writing, and any other memory */ +extern PNG_EXPORT(png_structp,png_create_write_struct) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn)); + +extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) + PNGARG((png_structp png_ptr)); + +extern PNG_EXPORT(void,png_set_compression_buffer_size) + PNGARG((png_structp png_ptr, png_uint_32 size)); + +/* Reset the compression stream */ +extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); + +/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ +#ifdef PNG_USER_MEM_SUPPORTED +extern PNG_EXPORT(png_structp,png_create_read_struct_2) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +extern PNG_EXPORT(png_structp,png_create_write_struct_2) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +#endif + +/* Write a PNG chunk - size, type, (optional) data, CRC. */ +extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, + png_bytep chunk_name, png_bytep data, png_size_t length)); + +/* Write the start of a PNG chunk - length and chunk name. */ +extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, + png_bytep chunk_name, png_uint_32 length)); + +/* Write the data of a PNG chunk started with png_write_chunk_start(). */ +extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); + +/* Allocate and initialize the info structure */ +extern PNG_EXPORT(png_infop,png_create_info_struct) + PNGARG((png_structp png_ptr)); + +/* Initialize the info structure (old interface - DEPRECATED) */ +extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)); +#undef png_info_init +#define png_info_init(info_ptr) png_info_init_3(&info_ptr, sizeof(png_info)); +extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, + png_size_t png_info_struct_size)); + +/* Writes all the PNG information before the image. */ +extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr)); +extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* read the information before the actual image data. */ +extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#if defined(PNG_TIME_RFC1123_SUPPORTED) +extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) + PNGARG((png_structp png_ptr, png_timep ptime)); +#endif + +#if !defined(_WIN32_WCE) +/* "time.h" functions are not supported on WindowsCE */ +#if defined(PNG_WRITE_tIME_SUPPORTED) +/* convert from a struct tm to png_time */ +extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, + struct tm FAR * ttime)); + +/* convert from time_t to png_time. Uses gmtime() */ +extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, + time_t ttime)); +#endif /* PNG_WRITE_tIME_SUPPORTED */ +#endif /* _WIN32_WCE */ + +#if defined(PNG_READ_EXPAND_SUPPORTED) +/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ +extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +/* Use blue, green, red order for pixels. */ +extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +/* Expand the grayscale to 24-bit RGB if necessary. */ +extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +/* Reduce RGB to grayscale. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, + int error_action, double red, double green )); +#endif +extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, + int error_action, png_fixed_point red, png_fixed_point green )); +extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp + png_ptr)); +#endif + +extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, + png_colorp palette)); + +#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +/* Add a filler byte to 24-bit RGB images. */ +extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, + png_uint_32 filler, int flags)); +/* The values of the PNG_FILLER_ defines should NOT be changed */ +#define PNG_FILLER_BEFORE 0 +#define PNG_FILLER_AFTER 1 +#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +/* Swap bytes in 16-bit depth files. */ +extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) +/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ +extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +/* Swap packing order of pixels in bytes. */ +extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +/* Converts files to legal bit depths. */ +extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, + png_color_8p true_bits)); +#endif + +#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ + defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* Have the code handle the interlacing. Returns the number of passes. */ +extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +/* Invert monochrome files */ +extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_BACKGROUND_SUPPORTED) +/* Handle alpha and tRNS by replacing with a background color. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, + png_color_16p background_color, int background_gamma_code, + int need_expand, double background_gamma)); +#endif +#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +#define PNG_BACKGROUND_GAMMA_SCREEN 1 +#define PNG_BACKGROUND_GAMMA_FILE 2 +#define PNG_BACKGROUND_GAMMA_UNIQUE 3 +#endif + +#if defined(PNG_READ_16_TO_8_SUPPORTED) +/* strip the second byte of information from a 16-bit depth file. */ +extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) +/* Turn on dithering, and reduce the palette to the number of colors available. */ +extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, + png_colorp palette, int num_palette, int maximum_colors, + png_uint_16p histogram, int full_dither)); +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) +/* Handle gamma correction. Screen_gamma=(display_exponent) */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, + double screen_gamma, double default_file_gamma)); +#endif +#endif + +#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ + defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ +/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ +extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, + int empty_plte_permitted)); +#endif + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +/* Set how many lines between output flushes - 0 for no flushing */ +extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); +/* Flush the current PNG output buffer */ +extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); +#endif + +/* optional update palette with requested transformations */ +extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); + +/* optional call to update the users info structure */ +extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* read one or more rows of image data. */ +extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, + png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); + +/* read a row of data. */ +extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, + png_bytep row, + png_bytep display_row)); + +/* read the whole image into memory at once. */ +extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, + png_bytepp image)); + +/* write a row of image data */ +extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, + png_bytep row)); + +/* write a few rows of image data */ +extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, + png_bytepp row, png_uint_32 num_rows)); + +/* write the image data */ +extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, + png_bytepp image)); + +/* writes the end of the PNG file. */ +extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* read the end of the PNG file. */ +extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* free any memory associated with the png_info_struct */ +extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, + png_infopp info_ptr_ptr)); + +/* free any memory associated with the png_struct and the png_info_structs */ +extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp + png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); + +/* free all memory used by the read (old method - NOT DLL EXPORTED) */ +extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, + png_infop end_info_ptr)); + +/* free any memory associated with the png_struct and the png_info_structs */ +extern PNG_EXPORT(void,png_destroy_write_struct) + PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); + +/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ +extern void png_write_destroy PNGARG((png_structp png_ptr)); + +/* set the libpng method of handling chunk CRC errors */ +extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, + int crit_action, int ancil_action)); + +/* Values for png_set_crc_action() to say how to handle CRC errors in + * ancillary and critical chunks, and whether to use the data contained + * therein. Note that it is impossible to "discard" data in a critical + * chunk. For versions prior to 0.90, the action was always error/quit, + * whereas in version 0.90 and later, the action for CRC errors in ancillary + * chunks is warn/discard. These values should NOT be changed. + * + * value action:critical action:ancillary + */ +#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ +#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ +#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ +#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ +#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ +#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ + +/* These functions give the user control over the scan-line filtering in + * libpng and the compression methods used by zlib. These functions are + * mainly useful for testing, as the defaults should work with most users. + * Those users who are tight on memory or want faster performance at the + * expense of compression can modify them. See the compression library + * header file (zlib.h) for an explination of the compression functions. + */ + +/* set the filtering method(s) used by libpng. Currently, the only valid + * value for "method" is 0. + */ +extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, + int filters)); + +/* Flags for png_set_filter() to say which filters to use. The flags + * are chosen so that they don't conflict with real filter types + * below, in case they are supplied instead of the #defined constants. + * These values should NOT be changed. + */ +#define PNG_NO_FILTERS 0x00 +#define PNG_FILTER_NONE 0x08 +#define PNG_FILTER_SUB 0x10 +#define PNG_FILTER_UP 0x20 +#define PNG_FILTER_AVG 0x40 +#define PNG_FILTER_PAETH 0x80 +#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ + PNG_FILTER_AVG | PNG_FILTER_PAETH) + +/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. + * These defines should NOT be changed. + */ +#define PNG_FILTER_VALUE_NONE 0 +#define PNG_FILTER_VALUE_SUB 1 +#define PNG_FILTER_VALUE_UP 2 +#define PNG_FILTER_VALUE_AVG 3 +#define PNG_FILTER_VALUE_PAETH 4 +#define PNG_FILTER_VALUE_LAST 5 + +#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ +/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ + * defines, either the default (minimum-sum-of-absolute-differences), or + * the experimental method (weighted-minimum-sum-of-absolute-differences). + * + * Weights are factors >= 1.0, indicating how important it is to keep the + * filter type consistent between rows. Larger numbers mean the current + * filter is that many times as likely to be the same as the "num_weights" + * previous filters. This is cumulative for each previous row with a weight. + * There needs to be "num_weights" values in "filter_weights", or it can be + * NULL if the weights aren't being specified. Weights have no influence on + * the selection of the first row filter. Well chosen weights can (in theory) + * improve the compression for a given image. + * + * Costs are factors >= 1.0 indicating the relative decoding costs of a + * filter type. Higher costs indicate more decoding expense, and are + * therefore less likely to be selected over a filter with lower computational + * costs. There needs to be a value in "filter_costs" for each valid filter + * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't + * setting the costs. Costs try to improve the speed of decompression without + * unduly increasing the compressed image size. + * + * A negative weight or cost indicates the default value is to be used, and + * values in the range [0.0, 1.0) indicate the value is to remain unchanged. + * The default values for both weights and costs are currently 1.0, but may + * change if good general weighting/cost heuristics can be found. If both + * the weights and costs are set to 1.0, this degenerates the WEIGHTED method + * to the UNWEIGHTED method, but with added encoding time/computation. + */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, + int heuristic_method, int num_weights, png_doublep filter_weights, + png_doublep filter_costs)); +#endif +#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ + +/* Heuristic used for row filter selection. These defines should NOT be + * changed. + */ +#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ +#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ +#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ +#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ + +/* Set the library compression level. Currently, valid values range from + * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 + * (0 - no compression, 9 - "maximal" compression). Note that tests have + * shown that zlib compression levels 3-6 usually perform as well as level 9 + * for PNG images, and do considerably fewer caclulations. In the future, + * these values may not correspond directly to the zlib compression levels. + */ +extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, + int level)); + +extern PNG_EXPORT(void,png_set_compression_mem_level) + PNGARG((png_structp png_ptr, int mem_level)); + +extern PNG_EXPORT(void,png_set_compression_strategy) + PNGARG((png_structp png_ptr, int strategy)); + +extern PNG_EXPORT(void,png_set_compression_window_bits) + PNGARG((png_structp png_ptr, int window_bits)); + +extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, + int method)); + +/* These next functions are called for input/output, memory, and error + * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, + * and call standard C I/O routines such as fread(), fwrite(), and + * fprintf(). These functions can be made to use other I/O routines + * at run time for those applications that need to handle I/O in a + * different manner by calling png_set_???_fn(). See libpng.txt for + * more information. + */ + +#if !defined(PNG_NO_STDIO) +/* Initialize the input/output for the PNG file to the default functions. */ +extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); +#endif + +/* Replace the (error and abort), and warning functions with user + * supplied functions. If no messages are to be printed you must still + * write and use replacement functions. The replacement error_fn should + * still do a longjmp to the last setjmp location if you are using this + * method of error handling. If error_fn or warning_fn is NULL, the + * default function will be used. + */ + +extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, + png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); + +/* Return the user pointer associated with the error functions */ +extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); + +/* Replace the default data output functions with a user supplied one(s). + * If buffered output is not used, then output_flush_fn can be set to NULL. + * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time + * output_flush_fn will be ignored (and thus can be NULL). + */ +extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, + png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); + +/* Replace the default data input function with a user supplied one. */ +extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, + png_voidp io_ptr, png_rw_ptr read_data_fn)); + +/* Return the user pointer associated with the I/O functions */ +extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); + +extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, + png_read_status_ptr read_row_fn)); + +extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, + png_write_status_ptr write_row_fn)); + +#ifdef PNG_USER_MEM_SUPPORTED +/* Replace the default memory allocation functions with user supplied one(s). */ +extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +/* Return the user pointer associated with the memory functions */ +extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp + png_ptr, png_user_transform_ptr read_user_transform_fn)); +#endif + +#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp + png_ptr, png_user_transform_ptr write_user_transform_fn)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp + png_ptr, png_voidp user_transform_ptr, int user_transform_depth, + int user_transform_channels)); +/* Return the user pointer associated with the user transform functions */ +extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) + PNGARG((png_structp png_ptr)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, + png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp + png_ptr)); +#endif + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +/* Sets the function callbacks for the push reader, and a pointer to a + * user-defined structure available to the callback functions. + */ +extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, + png_voidp progressive_ptr, + png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, + png_progressive_end_ptr end_fn)); + +/* returns the user pointer associated with the push read functions */ +extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) + PNGARG((png_structp png_ptr)); + +/* function to be called when data becomes available */ +extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); + +/* function that combines rows. Not very much different than the + * png_combine_row() call. Is this even used????? + */ +extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, + png_bytep old_row, png_bytep new_row)); +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, + png_uint_32 size)); + +#if defined(PNG_1_0_X) +# define png_malloc_warn png_malloc +#else +/* Added at libpng version 1.2.4 */ +extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, + png_uint_32 size)); +#endif + +/* frees a pointer allocated by png_malloc() */ +extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); + +#if defined(PNG_1_0_X) +/* Function to allocate memory for zlib. */ +extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, + uInt size)); + +/* Function to free memory for zlib */ +extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); +#endif + +/* Free data that was allocated internally */ +extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 free_me, int num)); +#ifdef PNG_FREE_ME_SUPPORTED +/* Reassign responsibility for freeing existing data, whether allocated + * by libpng or by the application */ +extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, + png_infop info_ptr, int freer, png_uint_32 mask)); +#endif +/* assignments for png_data_freer */ +#define PNG_DESTROY_WILL_FREE_DATA 1 +#define PNG_SET_WILL_FREE_DATA 1 +#define PNG_USER_WILL_FREE_DATA 2 +/* Flags for png_ptr->free_me and info_ptr->free_me */ +#define PNG_FREE_HIST 0x0008 +#define PNG_FREE_ICCP 0x0010 +#define PNG_FREE_SPLT 0x0020 +#define PNG_FREE_ROWS 0x0040 +#define PNG_FREE_PCAL 0x0080 +#define PNG_FREE_SCAL 0x0100 +#define PNG_FREE_UNKN 0x0200 +#define PNG_FREE_LIST 0x0400 +#define PNG_FREE_PLTE 0x1000 +#define PNG_FREE_TRNS 0x2000 +#define PNG_FREE_TEXT 0x4000 +#define PNG_FREE_ALL 0x7fff +#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ + +#ifdef PNG_USER_MEM_SUPPORTED +extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, + png_uint_32 size)); +extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, + png_voidp ptr)); +#endif + +extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, + png_voidp s1, png_voidp s2, png_uint_32 size)); + +extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, + png_voidp s1, int value, png_uint_32 size)); + +#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ +extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, + int check)); +#endif /* USE_FAR_KEYWORD */ + +/* Fatal error in PNG image of libpng - can't continue */ +extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, + png_const_charp error_message)); + +/* The same, but the chunk name is prepended to the error string. */ +extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, + png_const_charp error_message)); + +/* Non-fatal error in libpng. Can continue, but may have a problem. */ +extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, + png_const_charp warning_message)); + +/* Non-fatal error in libpng, chunk name is prepended to message. */ +extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, + png_const_charp warning_message)); + +/* The png_set_ functions are for storing values in the png_info_struct. + * Similarly, the png_get_ calls are used to read values from the + * png_info_struct, either storing the parameters in the passed variables, or + * setting pointers into the png_info_struct where the data is stored. The + * png_get_ functions return a non-zero value if the data was available + * in info_ptr, or return zero and do not change any of the parameters if the + * data was not available. + * + * These functions should be used instead of directly accessing png_info + * to avoid problems with future changes in the size and internal layout of + * png_info_struct. + */ +/* Returns "flag" if chunk data is valid in info_ptr. */ +extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, +png_infop info_ptr, png_uint_32 flag)); + +/* Returns number of bytes needed to hold a transformed row. */ +extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_INFO_IMAGE_SUPPORTED) +/* Returns row_pointers, which is an array of pointers to scanlines that was +returned from png_read_png(). */ +extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, +png_infop info_ptr)); +/* Set row_pointers, which is an array of pointers to scanlines for use +by png_write_png(). */ +extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytepp row_pointers)); +#endif + +/* Returns number of color channels in image. */ +extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#ifdef PNG_EASY_ACCESS_SUPPORTED +/* Returns image width in pixels. */ +extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image height in pixels. */ +extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image bit_depth. */ +extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image color_type. */ +extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image filter_type. */ +extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image interlace_type. */ +extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image compression_type. */ +extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image resolution in pixels per meter, from pHYs chunk data. */ +extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns pixel aspect ratio, computed from pHYs chunk data. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +#endif + +/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +#endif /* PNG_EASY_ACCESS_SUPPORTED */ + +/* Returns pointer to signature string read from PNG header */ +extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_bKGD_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_16p *background)); +#endif + +#if defined(PNG_bKGD_SUPPORTED) +extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_16p background)); +#endif + +#if defined(PNG_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, double *white_x, double *white_y, double *red_x, + double *red_y, double *green_x, double *green_y, double *blue_x, + double *blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point + *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, + png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point + *int_blue_x, png_fixed_point *int_blue_y)); +#endif +#endif + +#if defined(PNG_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, double white_x, double white_y, double red_x, + double red_y, double green_x, double green_y, double blue_x, double blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, + png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point + int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +#endif +#endif + +#if defined(PNG_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, + png_infop info_ptr, double *file_gamma)); +#endif +extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point *int_file_gamma)); +#endif + +#if defined(PNG_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, + png_infop info_ptr, double file_gamma)); +#endif +extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_file_gamma)); +#endif + +#if defined(PNG_hIST_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_16p *hist)); +#endif + +#if defined(PNG_hIST_SUPPORTED) +extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_16p hist)); +#endif + +extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, + int *bit_depth, int *color_type, int *interlace_method, + int *compression_method, int *filter_method)); + +extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, + int color_type, int interlace_method, int compression_method, + int filter_method)); + +#if defined(PNG_oFFs_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, + int *unit_type)); +#endif + +#if defined(PNG_oFFs_SUPPORTED) +extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, + int unit_type)); +#endif + +#if defined(PNG_pCAL_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, + int *type, int *nparams, png_charp *units, png_charpp *params)); +#endif + +#if defined(PNG_pCAL_SUPPORTED) +extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, + int type, int nparams, png_charp units, png_charpp params)); +#endif + +#if defined(PNG_pHYs_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +#endif + +#if defined(PNG_pHYs_SUPPORTED) +extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +#endif + +extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_colorp *palette, int *num_palette)); + +extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_colorp palette, int num_palette)); + +#if defined(PNG_sBIT_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_8p *sig_bit)); +#endif + +#if defined(PNG_sBIT_SUPPORTED) +extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_8p sig_bit)); +#endif + +#if defined(PNG_sRGB_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *intent)); +#endif + +#if defined(PNG_sRGB_SUPPORTED) +extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, + png_infop info_ptr, int intent)); +extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, int intent)); +#endif + +#if defined(PNG_iCCP_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charpp name, int *compression_type, + png_charpp profile, png_uint_32 *proflen)); + /* Note to maintainer: profile should be png_bytepp */ +#endif + +#if defined(PNG_iCCP_SUPPORTED) +extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp name, int compression_type, + png_charp profile, png_uint_32 proflen)); + /* Note to maintainer: profile should be png_bytep */ +#endif + +#if defined(PNG_sPLT_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_sPLT_tpp entries)); +#endif + +#if defined(PNG_sPLT_SUPPORTED) +extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_sPLT_tp entries, int nentries)); +#endif + +#if defined(PNG_TEXT_SUPPORTED) +/* png_get_text also returns the number of text chunks in *num_text */ +extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp *text_ptr, int *num_text)); +#endif + +/* + * Note while png_set_text() will accept a structure whose text, + * language, and translated keywords are NULL pointers, the structure + * returned by png_get_text will always contain regular + * zero-terminated C strings. They might be empty strings but + * they will never be NULL pointers. + */ + +#if defined(PNG_TEXT_SUPPORTED) +extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp text_ptr, int num_text)); +#endif + +#if defined(PNG_tIME_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_timep *mod_time)); +#endif + +#if defined(PNG_tIME_SUPPORTED) +extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_timep mod_time)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep *trans, int *num_trans, + png_color_16p *trans_values)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep trans, int num_trans, + png_color_16p trans_values)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +#endif + +#if defined(PNG_sCAL_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *unit, double *width, double *height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); +#endif +#endif +#endif /* PNG_sCAL_SUPPORTED */ + +#if defined(PNG_sCAL_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, int unit, double width, double height)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, + png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); +#endif +#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +/* provide a list of chunks and how they are to be handled, if the built-in + handling or default unknown chunk handling is not desired. Any chunks not + listed will be handled in the default manner. The IHDR and IEND chunks + must not be listed. + keep = 0: follow default behavour + = 1: do not keep + = 2: keep only if safe-to-copy + = 3: keep even if unsafe-to-copy +*/ +extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp + png_ptr, int keep, png_bytep chunk_list, int num_chunks)); +extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); +extern PNG_EXPORT(void, png_set_unknown_chunk_location) + PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); +extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp + png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); +#endif +#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep + chunk_name)); +#endif + +/* Png_free_data() will turn off the "valid" flag for anything it frees. + If you need to turn it off for a chunk that your application has freed, + you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */ +extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, + png_infop info_ptr, int mask)); + +#if defined(PNG_INFO_IMAGE_SUPPORTED) +/* The "params" pointer is currently not used and is for future expansion. */ +extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, + png_infop info_ptr, + int transforms, + png_voidp params)); +extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, + png_infop info_ptr, + int transforms, + png_voidp params)); +#endif + +/* Define PNG_DEBUG at compile time for debugging information. Higher + * numbers for PNG_DEBUG mean more debugging information. This has + * only been added since version 0.95 so it is not implemented throughout + * libpng yet, but more support will be added as needed. + */ +#ifdef PNG_DEBUG +#if (PNG_DEBUG > 0) +#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) +#include +#if (PNG_DEBUG > 1) +#define png_debug(l,m) _RPT0(_CRT_WARN,m) +#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1) +#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2) +#endif +#else /* PNG_DEBUG_FILE || !_MSC_VER */ +#ifndef PNG_DEBUG_FILE +#define PNG_DEBUG_FILE stderr +#endif /* PNG_DEBUG_FILE */ +#if (PNG_DEBUG > 1) +#define png_debug(l,m) \ +{ \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ +} +#define png_debug1(l,m,p1) \ +{ \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ +} +#define png_debug2(l,m,p1,p2) \ +{ \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ +} +#endif /* (PNG_DEBUG > 1) */ +#endif /* _MSC_VER */ +#endif /* (PNG_DEBUG > 0) */ +#endif /* PNG_DEBUG */ +#ifndef png_debug +#define png_debug(l, m) +#endif +#ifndef png_debug1 +#define png_debug1(l, m, p1) +#endif +#ifndef png_debug2 +#define png_debug2(l, m, p1, p2) +#endif + +extern PNG_EXPORT(png_bytep,png_sig_bytes) PNGARG((void)); + +extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); + +#ifdef PNG_MNG_FEATURES_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp + png_ptr, png_uint_32 mng_features_permitted)); +#endif + +/* Added to version 1.2.0 */ +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ +#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ +#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 +#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 +#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 +#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 +#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 +#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 +#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ + +#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ + | PNG_ASM_FLAG_MMX_READ_INTERLACE \ + | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ + | PNG_ASM_FLAG_MMX_READ_FILTER_UP \ + | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ + | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) +#define PNG_MMX_WRITE_FLAGS ( 0 ) + +#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ + | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ + | PNG_MMX_READ_FLAGS \ + | PNG_MMX_WRITE_FLAGS ) + +#define PNG_SELECT_READ 1 +#define PNG_SELECT_WRITE 2 + + +#if !defined(PNG_1_0_X) +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) + PNGARG((int flag_select, int *compilerID)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) + PNGARG((int flag_select)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_asm_flags) + PNGARG((png_structp png_ptr)); + +/* pngget.c */ +extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) + PNGARG((png_structp png_ptr)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) + PNGARG((png_structp png_ptr)); + +/* pngset.c */ +extern PNG_EXPORT(void,png_set_asm_flags) + PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); + +/* pngset.c */ +extern PNG_EXPORT(void,png_set_mmx_thresholds) + PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, + png_uint_32 mmx_rowbytes_threshold)); + +#endif /* PNG_1_0_X */ +#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ + +#if !defined(PNG_1_0_X) +/* png.c, pnggccrd.c, or pngvcrd.c */ +extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); + +/* Strip the prepended error numbers ("#nnn ") from error and warning + * messages before passing them to the error or warning handler. */ +#ifdef PNG_ERROR_NUMBERS_SUPPORTED +extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp + png_ptr, png_uint_32 strip_mode)); +#endif +#endif /* PNG_1_0_X */ + +/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */ + +#define PNG_HEADER_VERSION_STRING \ + " libpng version 1.2.4 - July 8, 2002 (header)\n" + +#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED +/* With these routines we avoid an integer divide, which will be slower on + * most machines. However, it does take more operations than the corresponding + * divide method, so it may be slower on a few RISC systems. There are two + * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. + * + * Note that the rounding factors are NOT supposed to be the same! 128 and + * 32768 are correct for the NODIV code; 127 and 32767 are correct for the + * standard method. + * + * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] + */ + + /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ + +# define png_composite(composite, fg, alpha, bg) \ + { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ + + (png_uint_16)(bg)*(png_uint_16)(255 - \ + (png_uint_16)(alpha)) + (png_uint_16)128); \ + (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } + +# define png_composite_16(composite, fg, alpha, bg) \ + { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ + + (png_uint_32)(bg)*(png_uint_32)(65535L - \ + (png_uint_32)(alpha)) + (png_uint_32)32768L); \ + (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } + +#else /* standard method using integer division */ + +# define png_composite(composite, fg, alpha, bg) \ + (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ + (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ + (png_uint_16)127) / 255) + +# define png_composite_16(composite, fg, alpha, bg) \ + (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ + (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ + (png_uint_32)32767) / (png_uint_32)65535L) + +#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ + +/* These next functions are used internally in the code. They generally + * shouldn't be used unless you are writing code to add or replace some + * functionality in libpng. More information about most functions can + * be found in the files where the functions are located. + */ + +#if defined(PNG_INTERNAL) + +/* Various modes of operation. Note that after an init, mode is set to + * zero automatically when the structure is created. + */ +#define PNG_HAVE_IHDR 0x01 +#define PNG_HAVE_PLTE 0x02 +#define PNG_HAVE_IDAT 0x04 +#define PNG_AFTER_IDAT 0x08 +#define PNG_HAVE_IEND 0x10 +#define PNG_HAVE_gAMA 0x20 +#define PNG_HAVE_cHRM 0x40 +#define PNG_HAVE_sRGB 0x80 +#define PNG_HAVE_CHUNK_HEADER 0x100 +#define PNG_WROTE_tIME 0x200 +#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 +#define PNG_BACKGROUND_IS_GRAY 0x800 +#define PNG_HAVE_PNG_SIGNATURE 0x1000 + +/* flags for the transformations the PNG library does on the image data */ +#define PNG_BGR 0x0001 +#define PNG_INTERLACE 0x0002 +#define PNG_PACK 0x0004 +#define PNG_SHIFT 0x0008 +#define PNG_SWAP_BYTES 0x0010 +#define PNG_INVERT_MONO 0x0020 +#define PNG_DITHER 0x0040 +#define PNG_BACKGROUND 0x0080 +#define PNG_BACKGROUND_EXPAND 0x0100 + /* 0x0200 unused */ +#define PNG_16_TO_8 0x0400 +#define PNG_RGBA 0x0800 +#define PNG_EXPAND 0x1000 +#define PNG_GAMMA 0x2000 +#define PNG_GRAY_TO_RGB 0x4000 +#define PNG_FILLER 0x8000L +#define PNG_PACKSWAP 0x10000L +#define PNG_SWAP_ALPHA 0x20000L +#define PNG_STRIP_ALPHA 0x40000L +#define PNG_INVERT_ALPHA 0x80000L +#define PNG_USER_TRANSFORM 0x100000L +#define PNG_RGB_TO_GRAY_ERR 0x200000L +#define PNG_RGB_TO_GRAY_WARN 0x400000L +#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ + +/* flags for png_create_struct */ +#define PNG_STRUCT_PNG 0x0001 +#define PNG_STRUCT_INFO 0x0002 + +/* Scaling factor for filter heuristic weighting calculations */ +#define PNG_WEIGHT_SHIFT 8 +#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) +#define PNG_COST_SHIFT 3 +#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) + +/* flags for the png_ptr->flags rather than declaring a byte for each one */ +#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 +#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 +#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 +#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 +#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 +#define PNG_FLAG_ZLIB_FINISHED 0x0020 +#define PNG_FLAG_ROW_INIT 0x0040 +#define PNG_FLAG_FILLER_AFTER 0x0080 +#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 +#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 +#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 +#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 +#define PNG_FLAG_FREE_PLTE 0x1000 +#define PNG_FLAG_FREE_TRNS 0x2000 +#define PNG_FLAG_FREE_HIST 0x4000 +#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L +#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L +#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L +#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L +#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L +#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L + +/* For use in png_set_keep_unknown, png_handle_as_unknown */ +#define HANDLE_CHUNK_AS_DEFAULT 0 +#define HANDLE_CHUNK_NEVER 1 +#define HANDLE_CHUNK_IF_SAFE 2 +#define HANDLE_CHUNK_ALWAYS 3 + +#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ + PNG_FLAG_CRC_ANCILLARY_NOWARN) + +#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ + PNG_FLAG_CRC_CRITICAL_IGNORE) + +#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ + PNG_FLAG_CRC_CRITICAL_MASK) + +/* save typing and make code easier to understand */ +#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ + abs((int)((c1).green) - (int)((c2).green)) + \ + abs((int)((c1).blue) - (int)((c2).blue))) + +/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ +#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) +/* place to hold the signature string for a PNG file. */ +#ifdef PNG_USE_GLOBAL_ARRAYS + PNG_EXPORT_VAR (const png_byte FARDATA) png_sig[8]; +#else +#define png_sig png_sig_bytes(NULL) +#endif +#endif /* PNG_NO_EXTERN */ + +/* Constant strings for known chunk types. If you need to add a chunk, + * define the name here, and add an invocation of the macro in png.c and + * wherever it's needed. + */ +#define PNG_IHDR const png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} +#define PNG_IDAT const png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} +#define PNG_IEND const png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} +#define PNG_PLTE const png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} +#define PNG_bKGD const png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} +#define PNG_cHRM const png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} +#define PNG_gAMA const png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} +#define PNG_hIST const png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} +#define PNG_iCCP const png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} +#define PNG_iTXt const png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} +#define PNG_oFFs const png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} +#define PNG_pCAL const png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} +#define PNG_sCAL const png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} +#define PNG_pHYs const png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} +#define PNG_sBIT const png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} +#define PNG_sPLT const png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} +#define PNG_sRGB const png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} +#define PNG_tEXt const png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} +#define PNG_tIME const png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} +#define PNG_tRNS const png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} +#define PNG_zTXt const png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} + +#ifdef PNG_USE_GLOBAL_ARRAYS +PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_IDAT[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_IEND[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_PLTE[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_bKGD[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_cHRM[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_gAMA[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_hIST[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_iCCP[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_iTXt[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_oFFs[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_pCAL[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_sCAL[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_pHYs[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_sBIT[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_sPLT[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_sRGB[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_tEXt[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_tIME[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_tRNS[5]; +PNG_EXPORT_VAR (const png_byte FARDATA) png_zTXt[5]; +#endif /* PNG_USE_GLOBAL_ARRAYS */ + + +/* Inline macros to do direct reads of bytes from the input buffer. These + * require that you are using an architecture that uses PNG byte ordering + * (MSB first) and supports unaligned data storage. I think that PowerPC + * in big-endian mode and 680x0 are the only ones that will support this. + * The x86 line of processors definitely do not. The png_get_int_32() + * routine also assumes we are using two's complement format for negative + * values, which is almost certainly true. + */ +#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED) +# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) +# define png_get_int_32(buf) ( *((png_int_32p) (buf))) +# endif +# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) +# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) +#else +# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) +PNG_EXTERN png_int_32 png_get_int_32 PNGARG((png_bytep buf)); +# endif +PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf)); +PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf)); +#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ + +/* Initialize png_ptr struct for reading, and allocate any other memory. + * (old interface - DEPRECATED - use png_create_read_struct instead). + */ +extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)); +#undef png_read_init +#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ + PNG_LIBPNG_VER_STRING, sizeof(png_struct)); +extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size)); +extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t + png_info_size)); + +/* Initialize png_ptr struct for writing, and allocate any other memory. + * (old interface - DEPRECATED - use png_create_write_struct instead). + */ +extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)); +#undef png_write_init +#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ + PNG_LIBPNG_VER_STRING, sizeof(png_struct)); +extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size)); +extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t + png_info_size)); + +/* Allocate memory for an internal libpng struct */ +PNG_EXTERN png_voidp png_create_struct PNGARG((int type)); + +/* Free memory from internal libpng struct */ +PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); + +PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr + malloc_fn, png_voidp mem_ptr)); +PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, + png_free_ptr free_fn, png_voidp mem_ptr)); + +/* Free any memory that info_ptr points to and reset struct. */ +PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_1_0_X +/* Function to allocate memory for zlib. */ +PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size)); + +/* Function to free memory for zlib */ +PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); + +/* Next four functions are used internally as callbacks. PNGAPI is required + * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */ + +PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t length)); +#endif + +PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +#if !defined(PNG_NO_STDIO) +PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)); +#endif +#endif +#else /* PNG_1_0_X */ +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t length)); +#endif +#endif /* PNG_1_0_X */ + +/* Reset the CRC variable */ +PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); + +/* Write the "data" buffer to whatever output you are using. */ +PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +/* Read data from whatever input you are using into the "data" buffer */ +PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +/* Read bytes into buf, and update png_ptr->crc */ +PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, + png_size_t length)); + +/* Decompress data in a chunk that uses compression */ +#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ + defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) +PNG_EXTERN png_charp png_decompress_chunk PNGARG((png_structp png_ptr, + int comp_type, png_charp chunkdata, png_size_t chunklength, + png_size_t prefix_length, png_size_t *data_length)); +#endif + +/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ +PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); + +/* Read the CRC from the file and compare it to the libpng calculated CRC */ +PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); + +/* Calculate the CRC over a section of data. Note that we are only + * passing a maximum of 64K on systems that have this as a memory limit, + * since this is the maximum buffer size we can specify. + */ +PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, + png_size_t length)); + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); +#endif + + +/* Place a 32-bit number into a buffer in PNG byte order (big-endian). + * The only currently known PNG chunks that use signed numbers are + * the ancillary extension chunks, oFFs and pCAL. + */ +PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i)); + +#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) +PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i)); +#endif + +/* Place a 16-bit number into a buffer in PNG byte order. + * The parameter is declared unsigned int, not png_uint_16, + * just to avoid potential problems on pre-ANSI C compilers. + */ +PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, unsigned int i)); + +/* simple function to write the signature */ +PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)); + +/* write various chunks */ + +/* Write the IHDR chunk, and update the png_struct with the necessary + * information. + */ +PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, + png_uint_32 height, + int bit_depth, int color_type, int compression_method, int filter_method, + int interlace_method)); + +PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, + png_uint_32 num_pal)); + +PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); + +#if defined(PNG_WRITE_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point + file_gamma)); +#endif +#endif + +#if defined(PNG_WRITE_sBIT_SUPPORTED) +PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, + int color_type)); +#endif + +#if defined(PNG_WRITE_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, + double white_x, double white_y, + double red_x, double red_y, double green_x, double green_y, + double blue_x, double blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, + png_fixed_point int_white_x, png_fixed_point int_white_y, + png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point + int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +#endif +#endif + +#if defined(PNG_WRITE_sRGB_SUPPORTED) +PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, + int intent)); +#endif + +#if defined(PNG_WRITE_iCCP_SUPPORTED) +PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, + png_charp name, int compression_type, + png_charp profile, int proflen)); + /* Note to maintainer: profile should be png_bytep */ +#endif + +#if defined(PNG_WRITE_sPLT_SUPPORTED) +PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, + png_sPLT_tp palette)); +#endif + +#if defined(PNG_WRITE_tRNS_SUPPORTED) +PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, + png_color_16p values, int number, int color_type)); +#endif + +#if defined(PNG_WRITE_bKGD_SUPPORTED) +PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, + png_color_16p values, int color_type)); +#endif + +#if defined(PNG_WRITE_hIST_SUPPORTED) +PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, + int num_hist)); +#endif + +#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ + defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) +PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, + png_charp key, png_charpp new_key)); +#endif + +#if defined(PNG_WRITE_tEXt_SUPPORTED) +PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, + png_charp text, png_size_t text_len)); +#endif + +#if defined(PNG_WRITE_zTXt_SUPPORTED) +PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, + png_charp text, png_size_t text_len, int compression)); +#endif + +#if defined(PNG_WRITE_iTXt_SUPPORTED) +PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, + int compression, png_charp key, png_charp lang, png_charp lang_key, + png_charp text)); +#endif + +#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */ +PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp text_ptr, int num_text)); +#endif + +#if defined(PNG_WRITE_oFFs_SUPPORTED) +PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, + png_int_32 x_offset, png_int_32 y_offset, int unit_type)); +#endif + +#if defined(PNG_WRITE_pCAL_SUPPORTED) +PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, + png_int_32 X0, png_int_32 X1, int type, int nparams, + png_charp units, png_charpp params)); +#endif + +#if defined(PNG_WRITE_pHYs_SUPPORTED) +PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, + png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, + int unit_type)); +#endif + +#if defined(PNG_WRITE_tIME_SUPPORTED) +PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, + png_timep mod_time)); +#endif + +#if defined(PNG_WRITE_sCAL_SUPPORTED) +#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) +PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, + int unit, double width, double height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, + int unit, png_charp width, png_charp height)); +#endif +#endif +#endif + +/* Called when finished processing a row of data */ +PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); + +/* Internal use only. Called before first row of data */ +PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); + +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)); +#endif + +/* combine a row of data, dealing with alpha, etc. if requested */ +PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, + int mask)); + +#if defined(PNG_READ_INTERLACING_SUPPORTED) +/* expand an interlaced row */ +/* OLD pre-1.0.9 interface: +PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, + png_bytep row, int pass, png_uint_32 transformations)); + */ +PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); +#endif + +/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ + +#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* grab pixels out of a row for an interlaced pass */ +PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, + png_bytep row, int pass)); +#endif + +/* unfilter a row */ +PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, + png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter)); + +/* Choose the best filter to use and filter the row data */ +PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, + png_row_infop row_info)); + +/* Write out the filtered row. */ +PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, + png_bytep filtered_row)); +/* finish a row while reading, dealing with interlacing passes, etc. */ +PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); + +/* initialize the row buffers, etc. */ +PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); +/* optional call to update the users info structure */ +PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* these are the functions that do the transformations */ +#if defined(PNG_READ_FILLER_SUPPORTED) +PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 filler, png_uint_32 flags)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ + defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 flags)); +#endif + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop + row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) +PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) +PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, + png_color_8p sig_bits)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_16_TO_8_SUPPORTED) +PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) +PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, + png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); + +# if defined(PNG_CORRECT_PALETTE_SUPPORTED) +PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, + png_colorp palette, int num_palette)); +# endif +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_WRITE_PACK_SUPPORTED) +PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 bit_depth)); +#endif + +#if defined(PNG_WRITE_SHIFT_SUPPORTED) +PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, + png_color_8p bit_depth)); +#endif + +#if defined(PNG_READ_BACKGROUND_SUPPORTED) +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, + png_color_16p trans_values, png_color_16p background, + png_color_16p background_1, + png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, + png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, + png_uint_16pp gamma_16_to_1, int gamma_shift)); +#else +PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, + png_color_16p trans_values, png_color_16p background)); +#endif +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, + png_bytep gamma_table, png_uint_16pp gamma_16_table, + int gamma_shift)); +#endif + +#if defined(PNG_READ_EXPAND_SUPPORTED) +PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, + png_bytep row, png_colorp palette, png_bytep trans, int num_trans)); +PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, + png_bytep row, png_color_16p trans_value)); +#endif + +/* The following decodes the appropriate chunks, and does error correction, + * then calls the appropriate callback for the chunk if it is valid. + */ + +/* decode the IHDR chunk */ +PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); + +#if defined(PNG_READ_bKGD_SUPPORTED) +PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_cHRM_SUPPORTED) +PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_gAMA_SUPPORTED) +PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_hIST_SUPPORTED) +PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_iCCP_SUPPORTED) +extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif /* PNG_READ_iCCP_SUPPORTED */ + +#if defined(PNG_READ_iTXt_SUPPORTED) +PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_oFFs_SUPPORTED) +PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_pCAL_SUPPORTED) +PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_pHYs_SUPPORTED) +PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sBIT_SUPPORTED) +PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sCAL_SUPPORTED) +PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sPLT_SUPPORTED) +extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif /* PNG_READ_sPLT_SUPPORTED */ + +#if defined(PNG_READ_sRGB_SUPPORTED) +PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tEXt_SUPPORTED) +PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tIME_SUPPORTED) +PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tRNS_SUPPORTED) +PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_zTXt_SUPPORTED) +PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); + +PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, + png_bytep chunk_name)); + +/* handle the transformations for reading and writing */ +PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); + +PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, + png_uint_32 length)); +PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t buffer_length)); +PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t buffer_length)); +PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); +PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); +#if defined(PNG_READ_tEXt_SUPPORTED) +PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif +#if defined(PNG_READ_zTXt_SUPPORTED) +PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif +#if defined(PNG_READ_iTXt_SUPPORTED) +PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif + +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +#ifdef PNG_MNG_FEATURES_SUPPORTED +PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, + png_bytep row)); +PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +/* png.c */ /* PRIVATE */ +PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)); +#endif +/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ + +#endif /* PNG_INTERNAL */ + +#ifdef __cplusplus +} +#endif + +#endif /* PNG_VERSION_INFO_ONLY */ +/* do not put anything past this line */ +#endif /* PNG_H */ diff --git a/engine/libs/pngconf.h b/engine/libs/pngconf.h new file mode 100644 index 000000000..2a52920e3 --- /dev/null +++ b/engine/libs/pngconf.h @@ -0,0 +1,1348 @@ +/* pngconf.h - machine configurable file for libpng + * + * libpng 1.2.4 - July 8, 2002 + * For conditions of distribution and use, see copyright notice in png.h + * Copyright (c) 1998-2002 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + */ + +/* Any machine specific code is near the front of this file, so if you + * are configuring libpng for a machine, you may want to read the section + * starting here down to where it starts to typedef png_color, png_text, + * and png_info. + */ + +#ifndef PNGCONF_H +#define PNGCONF_H + +/* This is the size of the compression buffer, and thus the size of + * an IDAT chunk. Make this whatever size you feel is best for your + * machine. One of these will be allocated per png_struct. When this + * is full, it writes the data to the disk, and does some other + * calculations. Making this an extremely small size will slow + * the library down, but you may want to experiment to determine + * where it becomes significant, if you are concerned with memory + * usage. Note that zlib allocates at least 32Kb also. For readers, + * this describes the size of the buffer available to read the data in. + * Unless this gets smaller than the size of a row (compressed), + * it should not make much difference how big this is. + */ + +#ifndef PNG_ZBUF_SIZE +# define PNG_ZBUF_SIZE 8192 +#endif + +/* Enable if you want a write-only libpng */ + +#ifndef PNG_NO_READ_SUPPORTED +# define PNG_READ_SUPPORTED +#endif + +/* Enable if you want a read-only libpng */ + +#ifndef PNG_NO_WRITE_SUPPORTED +# define PNG_WRITE_SUPPORTED +#endif + +/* Enabled by default in 1.2.0. You can disable this if you don't need to + support PNGs that are embedded in MNG datastreams */ +#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) +# ifndef PNG_MNG_FEATURES_SUPPORTED +# define PNG_MNG_FEATURES_SUPPORTED +# endif +#endif + +#ifndef PNG_NO_FLOATING_POINT_SUPPORTED +# ifndef PNG_FLOATING_POINT_SUPPORTED +# define PNG_FLOATING_POINT_SUPPORTED +# endif +#endif + +/* If you are running on a machine where you cannot allocate more + * than 64K of memory at once, uncomment this. While libpng will not + * normally need that much memory in a chunk (unless you load up a very + * large file), zlib needs to know how big of a chunk it can use, and + * libpng thus makes sure to check any memory allocation to verify it + * will fit into memory. +#define PNG_MAX_MALLOC_64K + */ +#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) +# define PNG_MAX_MALLOC_64K +#endif + +/* Special munging to support doing things the 'cygwin' way: + * 'Normal' png-on-win32 defines/defaults: + * PNG_BUILD_DLL -- building dll + * PNG_USE_DLL -- building an application, linking to dll + * (no define) -- building static library, or building an + * application and linking to the static lib + * 'Cygwin' defines/defaults: + * PNG_BUILD_DLL -- (ignored) building the dll + * (no define) -- (ignored) building an application, linking to the dll + * PNG_STATIC -- (ignored) building the static lib, or building an + * application that links to the static lib. + * ALL_STATIC -- (ignored) building various static libs, or building an + * application that links to the static libs. + * Thus, + * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and + * this bit of #ifdefs will define the 'correct' config variables based on + * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but + * unnecessary. + * + * Also, the precedence order is: + * ALL_STATIC (since we can't #undef something outside our namespace) + * PNG_BUILD_DLL + * PNG_STATIC + * (nothing) == PNG_USE_DLL + * + * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent + * of auto-import in binutils, we no longer need to worry about + * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, + * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes + * to __declspec() stuff. However, we DO need to worry about + * PNG_BUILD_DLL and PNG_STATIC because those change some defaults + * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. + */ +#if defined(__CYGWIN__) +# if defined(ALL_STATIC) +# if defined(PNG_BUILD_DLL) +# undef PNG_BUILD_DLL +# endif +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if defined(PNG_DLL) +# undef PNG_DLL +# endif +# if !defined(PNG_STATIC) +# define PNG_STATIC +# endif +# else +# if defined (PNG_BUILD_DLL) +# if defined(PNG_STATIC) +# undef PNG_STATIC +# endif +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if !defined(PNG_DLL) +# define PNG_DLL +# endif +# else +# if defined(PNG_STATIC) +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if defined(PNG_DLL) +# undef PNG_DLL +# endif +# else +# if !defined(PNG_USE_DLL) +# define PNG_USE_DLL +# endif +# if !defined(PNG_DLL) +# define PNG_DLL +# endif +# endif +# endif +# endif +#endif + +/* This protects us against compilers that run on a windowing system + * and thus don't have or would rather us not use the stdio types: + * stdin, stdout, and stderr. The only one currently used is stderr + * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will + * prevent these from being compiled and used. #defining PNG_NO_STDIO + * will also prevent these, plus will prevent the entire set of stdio + * macros and functions (FILE *, printf, etc.) from being compiled and used, + * unless (PNG_DEBUG > 0) has been #defined. + * + * #define PNG_NO_CONSOLE_IO + * #define PNG_NO_STDIO + */ + +#if defined(_WIN32_WCE) +# include + /* Console I/O functions are not supported on WindowsCE */ +# define PNG_NO_CONSOLE_IO +# ifdef PNG_DEBUG +# undef PNG_DEBUG +# endif +#endif + +#ifdef PNG_BUILD_DLL +# ifndef PNG_CONSOLE_IO_SUPPORTED +# ifndef PNG_NO_CONSOLE_IO +# define PNG_NO_CONSOLE_IO +# endif +# endif +#endif + +# ifdef PNG_NO_STDIO +# ifndef PNG_NO_CONSOLE_IO +# define PNG_NO_CONSOLE_IO +# endif +# ifdef PNG_DEBUG +# if (PNG_DEBUG > 0) +# include +# endif +# endif +# else +# if !defined(_WIN32_WCE) +/* "stdio.h" functions are not supported on WindowsCE */ +# include +# endif +# endif + +/* This macro protects us against machines that don't have function + * prototypes (ie K&R style headers). If your compiler does not handle + * function prototypes, define this macro and use the included ansi2knr. + * I've always been able to use _NO_PROTO as the indicator, but you may + * need to drag the empty declaration out in front of here, or change the + * ifdef to suit your own needs. + */ +#ifndef PNGARG + +#ifdef OF /* zlib prototype munger */ +# define PNGARG(arglist) OF(arglist) +#else + +#ifdef _NO_PROTO +# define PNGARG(arglist) () +# ifndef PNG_TYPECAST_NULL +# define PNG_TYPECAST_NULL +# endif +#else +# define PNGARG(arglist) arglist +#endif /* _NO_PROTO */ + +#endif /* OF */ + +#endif /* PNGARG */ + +/* Try to determine if we are compiling on a Mac. Note that testing for + * just __MWERKS__ is not good enough, because the Codewarrior is now used + * on non-Mac platforms. + */ +#ifndef MACOS +# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ + defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) +# define MACOS +# endif +#endif + +/* enough people need this for various reasons to include it here */ +#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) +# include +#endif + +#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) +# define PNG_SETJMP_SUPPORTED +#endif + +#ifdef PNG_SETJMP_SUPPORTED +/* This is an attempt to force a single setjmp behaviour on Linux. If + * the X config stuff didn't define _BSD_SOURCE we wouldn't need this. + */ + +# ifdef __linux__ +# ifdef _BSD_SOURCE +# define PNG_SAVE_BSD_SOURCE +# undef _BSD_SOURCE +# endif +# ifdef _SETJMP_H + __png.h__ already includes setjmp.h; + __dont__ include it again.; +# endif +# endif /* __linux__ */ + + /* include setjmp.h for error handling */ +# include + +# ifdef __linux__ +# ifdef PNG_SAVE_BSD_SOURCE +# define _BSD_SOURCE +# undef PNG_SAVE_BSD_SOURCE +# endif +# endif /* __linux__ */ +#endif /* PNG_SETJMP_SUPPORTED */ + +#ifdef BSD +# include +#else +# include +#endif + +/* Other defines for things like memory and the like can go here. */ +#ifdef PNG_INTERNAL + +#include + +/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which + * aren't usually used outside the library (as far as I know), so it is + * debatable if they should be exported at all. In the future, when it is + * possible to have run-time registry of chunk-handling functions, some of + * these will be made available again. +#define PNG_EXTERN extern + */ +#define PNG_EXTERN + +/* Other defines specific to compilers can go here. Try to keep + * them inside an appropriate ifdef/endif pair for portability. + */ + +#if defined(PNG_FLOATING_POINT_SUPPORTED) +# if defined(MACOS) + /* We need to check that hasn't already been included earlier + * as it seems it doesn't agree with , yet we should really use + * if possible. + */ +# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) +# include +# endif +# else +# include +# endif +# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) + /* Amiga SAS/C: We must include builtin FPU functions when compiling using + * MATH=68881 + */ +# include +# endif +#endif + +/* Codewarrior on NT has linking problems without this. */ +#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) +# define PNG_ALWAYS_EXTERN +#endif + +/* For some reason, Borland C++ defines memcmp, etc. in mem.h, not + * stdlib.h like it should (I think). Or perhaps this is a C++ + * "feature"? + */ +#ifdef __TURBOC__ +# include +# include "alloc.h" +#endif + +#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ + defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) +# include +#endif + +/* This controls how fine the dithering gets. As this allocates + * a largish chunk of memory (32K), those who are not as concerned + * with dithering quality can decrease some or all of these. + */ +#ifndef PNG_DITHER_RED_BITS +# define PNG_DITHER_RED_BITS 5 +#endif +#ifndef PNG_DITHER_GREEN_BITS +# define PNG_DITHER_GREEN_BITS 5 +#endif +#ifndef PNG_DITHER_BLUE_BITS +# define PNG_DITHER_BLUE_BITS 5 +#endif + +/* This controls how fine the gamma correction becomes when you + * are only interested in 8 bits anyway. Increasing this value + * results in more memory being used, and more pow() functions + * being called to fill in the gamma tables. Don't set this value + * less then 8, and even that may not work (I haven't tested it). + */ + +#ifndef PNG_MAX_GAMMA_8 +# define PNG_MAX_GAMMA_8 11 +#endif + +/* This controls how much a difference in gamma we can tolerate before + * we actually start doing gamma conversion. + */ +#ifndef PNG_GAMMA_THRESHOLD +# define PNG_GAMMA_THRESHOLD 0.05 +#endif + +#endif /* PNG_INTERNAL */ + +/* The following uses const char * instead of char * for error + * and warning message functions, so some compilers won't complain. + * If you do not want to use const, define PNG_NO_CONST here. + */ + +#ifndef PNG_NO_CONST +# define PNG_CONST const +#else +# define PNG_CONST +#endif + +/* The following defines give you the ability to remove code from the + * library that you will not be using. I wish I could figure out how to + * automate this, but I can't do that without making it seriously hard + * on the users. So if you are not using an ability, change the #define + * to and #undef, and that part of the library will not be compiled. If + * your linker can't find a function, you may want to make sure the + * ability is defined here. Some of these depend upon some others being + * defined. I haven't figured out all the interactions here, so you may + * have to experiment awhile to get everything to compile. If you are + * creating or using a shared library, you probably shouldn't touch this, + * as it will affect the size of the structures, and this will cause bad + * things to happen if the library and/or application ever change. + */ + +/* Any features you will not be using can be undef'ed here */ + +/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user + * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS + * on the compile line, then pick and choose which ones to define without + * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED + * if you only want to have a png-compliant reader/writer but don't need + * any of the extra transformations. This saves about 80 kbytes in a + * typical installation of the library. (PNG_NO_* form added in version + * 1.0.1c, for consistency) + */ + +/* The size of the png_text structure changed in libpng-1.0.6 when + * iTXt is supported. It is turned off by default, to support old apps + * that malloc the png_text structure instead of calling png_set_text() + * and letting libpng malloc it. It will be turned on by default in + * libpng-1.3.0. + */ + +#ifndef PNG_iTXt_SUPPORTED +# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) +# define PNG_NO_READ_iTXt +# endif +# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) +# define PNG_NO_WRITE_iTXt +# endif +#endif + +/* The following support, added after version 1.0.0, can be turned off here en + * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility + * with old applications that require the length of png_struct and png_info + * to remain unchanged. + */ + +#ifdef PNG_LEGACY_SUPPORTED +# define PNG_NO_FREE_ME +# define PNG_NO_READ_UNKNOWN_CHUNKS +# define PNG_NO_WRITE_UNKNOWN_CHUNKS +# define PNG_NO_READ_USER_CHUNKS +# define PNG_NO_READ_iCCP +# define PNG_NO_WRITE_iCCP +# define PNG_NO_READ_iTXt +# define PNG_NO_WRITE_iTXt +# define PNG_NO_READ_sCAL +# define PNG_NO_WRITE_sCAL +# define PNG_NO_READ_sPLT +# define PNG_NO_WRITE_sPLT +# define PNG_NO_INFO_IMAGE +# define PNG_NO_READ_RGB_TO_GRAY +# define PNG_NO_READ_USER_TRANSFORM +# define PNG_NO_WRITE_USER_TRANSFORM +# define PNG_NO_USER_MEM +# define PNG_NO_READ_EMPTY_PLTE +# define PNG_NO_MNG_FEATURES +# define PNG_NO_FIXED_POINT_SUPPORTED +#endif + +/* Ignore attempt to turn off both floating and fixed point support */ +#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ + !defined(PNG_NO_FIXED_POINT_SUPPORTED) +# define PNG_FIXED_POINT_SUPPORTED +#endif + +#ifndef PNG_NO_FREE_ME +# define PNG_FREE_ME_SUPPORTED +#endif + +#if defined(PNG_READ_SUPPORTED) + +#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ + !defined(PNG_NO_READ_TRANSFORMS) +# define PNG_READ_TRANSFORMS_SUPPORTED +#endif + +#ifdef PNG_READ_TRANSFORMS_SUPPORTED +# ifndef PNG_NO_READ_EXPAND +# define PNG_READ_EXPAND_SUPPORTED +# endif +# ifndef PNG_NO_READ_SHIFT +# define PNG_READ_SHIFT_SUPPORTED +# endif +# ifndef PNG_NO_READ_PACK +# define PNG_READ_PACK_SUPPORTED +# endif +# ifndef PNG_NO_READ_BGR +# define PNG_READ_BGR_SUPPORTED +# endif +# ifndef PNG_NO_READ_SWAP +# define PNG_READ_SWAP_SUPPORTED +# endif +# ifndef PNG_NO_READ_PACKSWAP +# define PNG_READ_PACKSWAP_SUPPORTED +# endif +# ifndef PNG_NO_READ_INVERT +# define PNG_READ_INVERT_SUPPORTED +# endif +# ifndef PNG_NO_READ_DITHER +# define PNG_READ_DITHER_SUPPORTED +# endif +# ifndef PNG_NO_READ_BACKGROUND +# define PNG_READ_BACKGROUND_SUPPORTED +# endif +# ifndef PNG_NO_READ_16_TO_8 +# define PNG_READ_16_TO_8_SUPPORTED +# endif +# ifndef PNG_NO_READ_FILLER +# define PNG_READ_FILLER_SUPPORTED +# endif +# ifndef PNG_NO_READ_GAMMA +# define PNG_READ_GAMMA_SUPPORTED +# endif +# ifndef PNG_NO_READ_GRAY_TO_RGB +# define PNG_READ_GRAY_TO_RGB_SUPPORTED +# endif +# ifndef PNG_NO_READ_SWAP_ALPHA +# define PNG_READ_SWAP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_INVERT_ALPHA +# define PNG_READ_INVERT_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_STRIP_ALPHA +# define PNG_READ_STRIP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_USER_TRANSFORM +# define PNG_READ_USER_TRANSFORM_SUPPORTED +# endif +# ifndef PNG_NO_READ_RGB_TO_GRAY +# define PNG_READ_RGB_TO_GRAY_SUPPORTED +# endif +#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ + +#if !defined(PNG_NO_PROGRESSIVE_READ) && \ + !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive */ +# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ +#endif /* about interlacing capability! You'll */ + /* still have interlacing unless you change the following line: */ + +#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */ + +#ifndef PNG_NO_READ_COMPOSITE_NODIV +# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ +# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ +# endif +#endif + +/* Deprecated, will be removed from version 2.0.0. + Use PNG_MNG_FEATURES_SUPPORTED instead. */ +#ifndef PNG_NO_READ_EMPTY_PLTE +# define PNG_READ_EMPTY_PLTE_SUPPORTED +#endif + +#endif /* PNG_READ_SUPPORTED */ + +#if defined(PNG_WRITE_SUPPORTED) + +# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ + !defined(PNG_NO_WRITE_TRANSFORMS) +# define PNG_WRITE_TRANSFORMS_SUPPORTED +#endif + +#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED +# ifndef PNG_NO_WRITE_SHIFT +# define PNG_WRITE_SHIFT_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_PACK +# define PNG_WRITE_PACK_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_BGR +# define PNG_WRITE_BGR_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_SWAP +# define PNG_WRITE_SWAP_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_PACKSWAP +# define PNG_WRITE_PACKSWAP_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_INVERT +# define PNG_WRITE_INVERT_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_FILLER +# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ +# endif +# ifndef PNG_NO_WRITE_SWAP_ALPHA +# define PNG_WRITE_SWAP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_INVERT_ALPHA +# define PNG_WRITE_INVERT_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_USER_TRANSFORM +# define PNG_WRITE_USER_TRANSFORM_SUPPORTED +# endif +#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +# ifndef PNG_NO_USER_TRANSFORM_PTR +# define PNG_USER_TRANSFORM_PTR_SUPPORTED +# endif +#endif + +#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant + encoders, but can cause trouble + if left undefined */ + +#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ + defined(PNG_FLOATING_POINT_SUPPORTED) +# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +#endif + +#ifndef PNG_1_0_X +#ifndef PNG_NO_ERROR_NUMBERS +#define PNG_ERROR_NUMBERS_SUPPORTED +#endif +#endif /* PNG_1_0_X */ + +#ifndef PNG_NO_WRITE_FLUSH +# define PNG_WRITE_FLUSH_SUPPORTED +#endif + +/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ +#ifndef PNG_NO_WRITE_EMPTY_PLTE +# define PNG_WRITE_EMPTY_PLTE_SUPPORTED +#endif + +#endif /* PNG_WRITE_SUPPORTED */ + +#ifndef PNG_NO_STDIO +# define PNG_TIME_RFC1123_SUPPORTED +#endif + +/* This adds extra functions in pngget.c for accessing data from the + * info pointer (added in version 0.99) + * png_get_image_width() + * png_get_image_height() + * png_get_bit_depth() + * png_get_color_type() + * png_get_compression_type() + * png_get_filter_type() + * png_get_interlace_type() + * png_get_pixel_aspect_ratio() + * png_get_pixels_per_meter() + * png_get_x_offset_pixels() + * png_get_y_offset_pixels() + * png_get_x_offset_microns() + * png_get_y_offset_microns() + */ +#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) +# define PNG_EASY_ACCESS_SUPPORTED +#endif + +/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 + even when PNG_USE_PNGVCRD or PNG_USE_PNGGCCRD is not defined */ +#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) +# ifndef PNG_ASSEMBLER_CODE_SUPPORTED +# define PNG_ASSEMBLER_CODE_SUPPORTED +# endif +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_MMX_CODE_SUPPORTED +# endif +#endif + +/* If you are sure that you don't need thread safety and you are compiling + with PNG_USE_PNGCCRD for an MMX application, you can define this for + faster execution. See pnggccrd.c. +#define PNG_THREAD_UNSAFE_OK +*/ + +#if !defined(PNG_1_0_X) +#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) +# define PNG_USER_MEM_SUPPORTED +#endif +#endif /* PNG_1_0_X */ + +/* These are currently experimental features, define them if you want */ + +/* very little testing */ +/* +#ifdef PNG_READ_SUPPORTED +# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +# endif +#endif +*/ + +/* This is only for PowerPC big-endian and 680x0 systems */ +/* some testing */ +/* +#ifdef PNG_READ_SUPPORTED +# ifndef PNG_PNG_READ_BIG_ENDIAN_SUPPORTED +# define PNG_READ_BIG_ENDIAN_SUPPORTED +# endif +#endif +*/ + +/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ +/* +#define PNG_NO_POINTER_INDEXING +*/ + +/* These functions are turned off by default, as they will be phased out. */ +/* +#define PNG_USELESS_TESTS_SUPPORTED +#define PNG_CORRECT_PALETTE_SUPPORTED +*/ + +/* Any chunks you are not interested in, you can undef here. The + * ones that allocate memory may be expecially important (hIST, + * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info + * a bit smaller. + */ + +#if defined(PNG_READ_SUPPORTED) && \ + !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ + !defined(PNG_NO_READ_ANCILLARY_CHUNKS) +# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +#endif + +#if defined(PNG_WRITE_SUPPORTED) && \ + !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ + !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) +# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +#endif + +#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED + +#ifdef PNG_NO_READ_TEXT +# define PNG_NO_READ_iTXt +# define PNG_NO_READ_tEXt +# define PNG_NO_READ_zTXt +#endif +#ifndef PNG_NO_READ_bKGD +# define PNG_READ_bKGD_SUPPORTED +# define PNG_bKGD_SUPPORTED +#endif +#ifndef PNG_NO_READ_cHRM +# define PNG_READ_cHRM_SUPPORTED +# define PNG_cHRM_SUPPORTED +#endif +#ifndef PNG_NO_READ_gAMA +# define PNG_READ_gAMA_SUPPORTED +# define PNG_gAMA_SUPPORTED +#endif +#ifndef PNG_NO_READ_hIST +# define PNG_READ_hIST_SUPPORTED +# define PNG_hIST_SUPPORTED +#endif +#ifndef PNG_NO_READ_iCCP +# define PNG_READ_iCCP_SUPPORTED +# define PNG_iCCP_SUPPORTED +#endif +#ifndef PNG_NO_READ_iTXt +# ifndef PNG_READ_iTXt_SUPPORTED +# define PNG_READ_iTXt_SUPPORTED +# endif +# ifndef PNG_iTXt_SUPPORTED +# define PNG_iTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_READ_oFFs +# define PNG_READ_oFFs_SUPPORTED +# define PNG_oFFs_SUPPORTED +#endif +#ifndef PNG_NO_READ_pCAL +# define PNG_READ_pCAL_SUPPORTED +# define PNG_pCAL_SUPPORTED +#endif +#ifndef PNG_NO_READ_sCAL +# define PNG_READ_sCAL_SUPPORTED +# define PNG_sCAL_SUPPORTED +#endif +#ifndef PNG_NO_READ_pHYs +# define PNG_READ_pHYs_SUPPORTED +# define PNG_pHYs_SUPPORTED +#endif +#ifndef PNG_NO_READ_sBIT +# define PNG_READ_sBIT_SUPPORTED +# define PNG_sBIT_SUPPORTED +#endif +#ifndef PNG_NO_READ_sPLT +# define PNG_READ_sPLT_SUPPORTED +# define PNG_sPLT_SUPPORTED +#endif +#ifndef PNG_NO_READ_sRGB +# define PNG_READ_sRGB_SUPPORTED +# define PNG_sRGB_SUPPORTED +#endif +#ifndef PNG_NO_READ_tEXt +# define PNG_READ_tEXt_SUPPORTED +# define PNG_tEXt_SUPPORTED +#endif +#ifndef PNG_NO_READ_tIME +# define PNG_READ_tIME_SUPPORTED +# define PNG_tIME_SUPPORTED +#endif +#ifndef PNG_NO_READ_tRNS +# define PNG_READ_tRNS_SUPPORTED +# define PNG_tRNS_SUPPORTED +#endif +#ifndef PNG_NO_READ_zTXt +# define PNG_READ_zTXt_SUPPORTED +# define PNG_zTXt_SUPPORTED +#endif +#ifndef PNG_NO_READ_UNKNOWN_CHUNKS +# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_UNKNOWN_CHUNKS_SUPPORTED +# endif +# ifndef PNG_NO_HANDLE_AS_UNKNOWN +# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# endif +#endif +#if !defined(PNG_NO_READ_USER_CHUNKS) && \ + defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +# define PNG_READ_USER_CHUNKS_SUPPORTED +# define PNG_USER_CHUNKS_SUPPORTED +# ifdef PNG_NO_READ_UNKNOWN_CHUNKS +# undef PNG_NO_READ_UNKNOWN_CHUNKS +# endif +# ifdef PNG_NO_HANDLE_AS_UNKNOWN +# undef PNG_NO_HANDLE_AS_UNKNOWN +# endif +#endif +#ifndef PNG_NO_READ_OPT_PLTE +# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ +#endif /* optional PLTE chunk in RGB and RGBA images */ +#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ + defined(PNG_READ_zTXt_SUPPORTED) +# define PNG_READ_TEXT_SUPPORTED +# define PNG_TEXT_SUPPORTED +#endif + +#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ + +#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED + +#ifdef PNG_NO_WRITE_TEXT +# define PNG_NO_WRITE_iTXt +# define PNG_NO_WRITE_tEXt +# define PNG_NO_WRITE_zTXt +#endif +#ifndef PNG_NO_WRITE_bKGD +# define PNG_WRITE_bKGD_SUPPORTED +# ifndef PNG_bKGD_SUPPORTED +# define PNG_bKGD_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_cHRM +# define PNG_WRITE_cHRM_SUPPORTED +# ifndef PNG_cHRM_SUPPORTED +# define PNG_cHRM_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_gAMA +# define PNG_WRITE_gAMA_SUPPORTED +# ifndef PNG_gAMA_SUPPORTED +# define PNG_gAMA_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_hIST +# define PNG_WRITE_hIST_SUPPORTED +# ifndef PNG_hIST_SUPPORTED +# define PNG_hIST_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_iCCP +# define PNG_WRITE_iCCP_SUPPORTED +# ifndef PNG_iCCP_SUPPORTED +# define PNG_iCCP_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_iTXt +# ifndef PNG_WRITE_iTXt_SUPPORTED +# define PNG_WRITE_iTXt_SUPPORTED +# endif +# ifndef PNG_iTXt_SUPPORTED +# define PNG_iTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_oFFs +# define PNG_WRITE_oFFs_SUPPORTED +# ifndef PNG_oFFs_SUPPORTED +# define PNG_oFFs_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_pCAL +# define PNG_WRITE_pCAL_SUPPORTED +# ifndef PNG_pCAL_SUPPORTED +# define PNG_pCAL_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sCAL +# define PNG_WRITE_sCAL_SUPPORTED +# ifndef PNG_sCAL_SUPPORTED +# define PNG_sCAL_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_pHYs +# define PNG_WRITE_pHYs_SUPPORTED +# ifndef PNG_pHYs_SUPPORTED +# define PNG_pHYs_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sBIT +# define PNG_WRITE_sBIT_SUPPORTED +# ifndef PNG_sBIT_SUPPORTED +# define PNG_sBIT_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sPLT +# define PNG_WRITE_sPLT_SUPPORTED +# ifndef PNG_sPLT_SUPPORTED +# define PNG_sPLT_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sRGB +# define PNG_WRITE_sRGB_SUPPORTED +# ifndef PNG_sRGB_SUPPORTED +# define PNG_sRGB_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tEXt +# define PNG_WRITE_tEXt_SUPPORTED +# ifndef PNG_tEXt_SUPPORTED +# define PNG_tEXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tIME +# define PNG_WRITE_tIME_SUPPORTED +# ifndef PNG_tIME_SUPPORTED +# define PNG_tIME_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tRNS +# define PNG_WRITE_tRNS_SUPPORTED +# ifndef PNG_tRNS_SUPPORTED +# define PNG_tRNS_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_zTXt +# define PNG_WRITE_zTXt_SUPPORTED +# ifndef PNG_zTXt_SUPPORTED +# define PNG_zTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS +# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_UNKNOWN_CHUNKS_SUPPORTED +# endif +# ifndef PNG_NO_HANDLE_AS_UNKNOWN +# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# endif +# endif +#endif +#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ + defined(PNG_WRITE_zTXt_SUPPORTED) +# define PNG_WRITE_TEXT_SUPPORTED +# ifndef PNG_TEXT_SUPPORTED +# define PNG_TEXT_SUPPORTED +# endif +#endif + +#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ + +/* Turn this off to disable png_read_png() and + * png_write_png() and leave the row_pointers member + * out of the info structure. + */ +#ifndef PNG_NO_INFO_IMAGE +# define PNG_INFO_IMAGE_SUPPORTED +#endif + +/* need the time information for reading tIME chunks */ +#if defined(PNG_tIME_SUPPORTED) +# if !defined(_WIN32_WCE) + /* "time.h" functions are not supported on WindowsCE */ +# include +# endif +#endif + +/* Some typedefs to get us started. These should be safe on most of the + * common platforms. The typedefs should be at least as large as the + * numbers suggest (a png_uint_32 must be at least 32 bits long), but they + * don't have to be exactly that size. Some compilers dislike passing + * unsigned shorts as function parameters, so you may be better off using + * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may + * want to have unsigned int for png_uint_32 instead of unsigned long. + */ + +typedef unsigned long png_uint_32; +typedef long png_int_32; +typedef unsigned short png_uint_16; +typedef short png_int_16; +typedef unsigned char png_byte; + +/* This is usually size_t. It is typedef'ed just in case you need it to + change (I'm not sure if you will or not, so I thought I'd be safe) */ +typedef size_t png_size_t; + +/* The following is needed for medium model support. It cannot be in the + * PNG_INTERNAL section. Needs modification for other compilers besides + * MSC. Model independent support declares all arrays and pointers to be + * large using the far keyword. The zlib version used must also support + * model independent data. As of version zlib 1.0.4, the necessary changes + * have been made in zlib. The USE_FAR_KEYWORD define triggers other + * changes that are needed. (Tim Wegner) + */ + +/* Separate compiler dependencies (problem here is that zlib.h always + defines FAR. (SJT) */ +#ifdef __BORLANDC__ +# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) +# define LDATA 1 +# else +# define LDATA 0 +# endif + /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ +# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) +# define PNG_MAX_MALLOC_64K +# if (LDATA != 1) +# ifndef FAR +# define FAR __far +# endif +# define USE_FAR_KEYWORD +# endif /* LDATA != 1 */ + /* Possibly useful for moving data out of default segment. + * Uncomment it if you want. Could also define FARDATA as + * const if your compiler supports it. (SJT) +# define FARDATA FAR + */ +# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ +#endif /* __BORLANDC__ */ + + +/* Suggest testing for specific compiler first before testing for + * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, + * making reliance oncertain keywords suspect. (SJT) + */ + +/* MSC Medium model */ +#if defined(FAR) +# if defined(M_I86MM) +# define USE_FAR_KEYWORD +# define FARDATA FAR +# include +# endif +#endif + +/* SJT: default case */ +#ifndef FAR +# define FAR +#endif + +/* At this point FAR is always defined */ +#ifndef FARDATA +# define FARDATA +#endif + +/* Typedef for floating-point numbers that are converted + to fixed-point with a multiple of 100,000, e.g., int_gamma */ +typedef png_int_32 png_fixed_point; + +/* Add typedefs for pointers */ +typedef void FAR * png_voidp; +typedef png_byte FAR * png_bytep; +typedef png_uint_32 FAR * png_uint_32p; +typedef png_int_32 FAR * png_int_32p; +typedef png_uint_16 FAR * png_uint_16p; +typedef png_int_16 FAR * png_int_16p; +typedef PNG_CONST char FAR * png_const_charp; +typedef char FAR * png_charp; +typedef png_fixed_point FAR * png_fixed_point_p; + +#ifndef PNG_NO_STDIO +#if defined(_WIN32_WCE) +typedef HANDLE png_FILE_p; +#else +typedef FILE * png_FILE_p; +#endif +#endif + +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double FAR * png_doublep; +#endif + +/* Pointers to pointers; i.e. arrays */ +typedef png_byte FAR * FAR * png_bytepp; +typedef png_uint_32 FAR * FAR * png_uint_32pp; +typedef png_int_32 FAR * FAR * png_int_32pp; +typedef png_uint_16 FAR * FAR * png_uint_16pp; +typedef png_int_16 FAR * FAR * png_int_16pp; +typedef PNG_CONST char FAR * FAR * png_const_charpp; +typedef char FAR * FAR * png_charpp; +typedef png_fixed_point FAR * FAR * png_fixed_point_pp; +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double FAR * FAR * png_doublepp; +#endif + +/* Pointers to pointers to pointers; i.e., pointer to array */ +typedef char FAR * FAR * FAR * png_charppp; + +/* libpng typedefs for types in zlib. If zlib changes + * or another compression library is used, then change these. + * Eliminates need to change all the source files. + */ +typedef charf * png_zcharp; +typedef charf * FAR * png_zcharpp; +typedef z_stream FAR * png_zstreamp; + +/* + * Define PNG_BUILD_DLL if the module being built is a Windows + * LIBPNG DLL. + * + * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. + * It is equivalent to Microsoft predefined macro _DLL that is + * automatically defined when you compile using the share + * version of the CRT (C Run-Time library) + * + * The cygwin mods make this behavior a little different: + * Define PNG_BUILD_DLL if you are building a dll for use with cygwin + * Define PNG_STATIC if you are building a static library for use with cygwin, + * -or- if you are building an application that you want to link to the + * static library. + * PNG_USE_DLL is defined by default (no user action needed) unless one of + * the other flags is defined. + */ + +#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) +# define PNG_DLL +#endif +/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. + * When building a static lib, default to no GLOBAL ARRAYS, but allow + * command-line override + */ +#if defined(__CYGWIN__) +# if !defined(PNG_STATIC) +# if defined(PNG_USE_GLOBAL_ARRAYS) +# undef PNG_USE_GLOBAL_ARRAYS +# endif +# if !defined(PNG_USE_LOCAL_ARRAYS) +# define PNG_USE_LOCAL_ARRAYS +# endif +# else +# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) +# if defined(PNG_USE_GLOBAL_ARRAYS) +# undef PNG_USE_GLOBAL_ARRAYS +# endif +# endif +# endif +# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +# define PNG_USE_LOCAL_ARRAYS +# endif +#endif + +/* Do not use global arrays (helps with building DLL's) + * They are no longer used in libpng itself, since version 1.0.5c, + * but might be required for some pre-1.0.5c applications. + */ +#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +# if defined(PNG_NO_GLOBAL_ARRAYS) || (defined(__GNUC__) && defined(PNG_DLL)) +# define PNG_USE_LOCAL_ARRAYS +# else +# define PNG_USE_GLOBAL_ARRAYS +# endif +#endif + +#if defined(__CYGWIN__) +# undef PNGAPI +# define PNGAPI __cdecl +# undef PNG_IMPEXP +# define PNG_IMPEXP +#endif + +/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", + * you may get warnings regarding the linkage of png_zalloc and png_zfree. + * Don't ignore those warnings; you must also reset the default calling + * convention in your compiler to match your PNGAPI, and you must build + * zlib and your applications the same way you build libpng. + */ + +#ifndef PNGAPI + +#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) +# ifndef PNG_NO_MODULEDEF +# define PNG_NO_MODULEDEF +# endif +#endif + +#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) +# define PNG_IMPEXP +#endif + +#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ + (( defined(_Windows) || defined(_WINDOWS) || \ + defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) + +# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) +# define PNGAPI __cdecl +# else +# define PNGAPI _cdecl +# endif + +# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ + 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) +# define PNG_IMPEXP +# endif + +# if !defined(PNG_IMPEXP) + +# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol +# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol + + /* Borland/Microsoft */ +# if defined(_MSC_VER) || defined(__BORLANDC__) +# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) +# define PNG_EXPORT PNG_EXPORT_TYPE1 +# else +# define PNG_EXPORT PNG_EXPORT_TYPE2 +# if defined(PNG_BUILD_DLL) +# define PNG_IMPEXP __export +# else +# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in + VC++ */ +# endif /* Exists in Borland C++ for + C++ classes (== huge) */ +# endif +# endif + +# if !defined(PNG_IMPEXP) +# if defined(PNG_BUILD_DLL) +# define PNG_IMPEXP __declspec(dllexport) +# else +# define PNG_IMPEXP __declspec(dllimport) +# endif +# endif +# endif /* PNG_IMPEXP */ +#else /* !(DLL || non-cygwin WINDOWS) */ +# if (defined(__IBMC__) || defined(IBMCPP__)) && defined(__OS2__) +# define PNGAPI _System +# define PNG_IMPEXP +# else +# if 0 /* ... other platforms, with other meanings */ +# else +# define PNGAPI +# define PNG_IMPEXP +# endif +# endif +#endif +#endif + +#ifndef PNGAPI +# define PNGAPI +#endif +#ifndef PNG_IMPEXP +# define PNG_IMPEXP +#endif + +#ifndef PNG_EXPORT +# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol +#endif + +#ifdef PNG_USE_GLOBAL_ARRAYS +# ifndef PNG_EXPORT_VAR +# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type +# endif +#endif + +/* User may want to use these so they are not in PNG_INTERNAL. Any library + * functions that are passed far data must be model independent. + */ + +#ifndef PNG_ABORT +# define PNG_ABORT() abort() +#endif + +#ifdef PNG_SETJMP_SUPPORTED +# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) +#else +# define png_jmpbuf(png_ptr) \ + (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) +#endif + +#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ +/* use this to make far-to-near assignments */ +# define CHECK 1 +# define NOCHECK 0 +# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) +# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) +# define png_strcpy _fstrcpy +# define png_strlen _fstrlen +# define png_memcmp _fmemcmp /* SJT: added */ +# define png_memcpy _fmemcpy +# define png_memset _fmemset +#else /* use the usual functions */ +# define CVT_PTR(ptr) (ptr) +# define CVT_PTR_NOCHECK(ptr) (ptr) +# define png_strcpy strcpy +# define png_strlen strlen +# define png_memcmp memcmp /* SJT: added */ +# define png_memcpy memcpy +# define png_memset memset +#endif +/* End of memory model independent support */ + +/* Just a little check that someone hasn't tried to define something + * contradictory. + */ +#if (PNG_ZBUF_SIZE > 65536) && defined(PNG_MAX_MALLOC_64K) +# undef PNG_ZBUF_SIZE +# define PNG_ZBUF_SIZE 65536 +#endif + +#ifdef PNG_READ_SUPPORTED +/* Prior to libpng-1.0.9, this block was in pngasmrd.h */ +#if defined(PNG_INTERNAL) + +/* These are the default thresholds before the MMX code kicks in; if either + * rowbytes or bitdepth is below the threshold, plain C code is used. These + * can be overridden at runtime via the png_set_mmx_thresholds() call in + * libpng 1.2.0 and later. The values below were chosen by Intel. + */ + +#ifndef PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT +# define PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT 128 /* >= */ +#endif +#ifndef PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT +# define PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT 9 /* >= */ +#endif + +/* Set this in the makefile for VC++ on Pentium, not here. */ +/* Platform must be Pentium. Makefile must assemble and load pngvcrd.c . + * MMX will be detected at run time and used if present. + */ +#ifdef PNG_USE_PNGVCRD +# define PNG_HAVE_ASSEMBLER_COMBINE_ROW +# define PNG_HAVE_ASSEMBLER_READ_INTERLACE +# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW +#endif + +/* Set this in the makefile for gcc/as on Pentium, not here. */ +/* Platform must be Pentium. Makefile must assemble and load pnggccrd.c . + * MMX will be detected at run time and used if present. + */ +#ifdef PNG_USE_PNGGCCRD +# define PNG_HAVE_ASSEMBLER_COMBINE_ROW +# define PNG_HAVE_ASSEMBLER_READ_INTERLACE +# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW +#endif +/* - see pnggccrd.c for info about what is currently enabled */ + +#endif /* PNG_INTERNAL */ +#endif /* PNG_READ_SUPPORTED */ + +#endif /* PNGCONF_H */ + diff --git a/engine/libs/zconf.h b/engine/libs/zconf.h new file mode 100644 index 000000000..96886c087 --- /dev/null +++ b/engine/libs/zconf.h @@ -0,0 +1,280 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-1998 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef _ZCONF_H +#define _ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + */ +#ifdef Z_PREFIX +# define deflateInit_ z_deflateInit_ +# define deflate z_deflate +# define deflateEnd z_deflateEnd +# define inflateInit_ z_inflateInit_ +# define inflate z_inflate +# define inflateEnd z_inflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateSetDictionary z_deflateSetDictionary +# define deflateCopy z_deflateCopy +# define deflateReset z_deflateReset +# define deflateParams z_deflateParams +# define inflateInit2_ z_inflateInit2_ +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateReset z_inflateReset +# define compress z_compress +# define compress2 z_compress2 +# define uncompress z_uncompress +# define adler32 z_adler32 +# define crc32 z_crc32 +# define get_crc_table z_get_crc_table + +# define Byte z_Byte +# define uInt z_uInt +# define uLong z_uLong +# define Bytef z_Bytef +# define charf z_charf +# define intf z_intf +# define uIntf z_uIntf +# define uLongf z_uLongf +# define voidpf z_voidpf +# define voidp z_voidp +#endif + +#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32) +# define WIN32 +#endif +#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386) +# ifndef __32BIT__ +# define __32BIT__ +# endif +#endif +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#if defined(MSDOS) && !defined(__32BIT__) +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC) +# define STDC +#endif +#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__) +# ifndef STDC +# define STDC +# endif +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const +# endif +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Old Borland C incorrectly complains about missing returns: */ +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500) +# define NEED_DUMMY_RETURN +#endif + + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +#endif +#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__)) +# ifndef __32BIT__ +# define SMALL_MEDIUM +# define FAR _far +# endif +#endif + +/* Compile with -DZLIB_DLL for Windows DLL support */ +#if defined(ZLIB_DLL) +# if defined(_WINDOWS) || defined(WINDOWS) +# ifdef FAR +# undef FAR +# endif +# include +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR _cdecl _export +# endif +# endif +# if defined (__BORLANDC__) +# if (__BORLANDC__ >= 0x0500) && defined (WIN32) +# include +# define ZEXPORT __declspec(dllexport) WINAPI +# define ZEXPORTRVA __declspec(dllexport) WINAPIV +# else +# if defined (_Windows) && defined (__DLL__) +# define ZEXPORT _export +# define ZEXPORTVA _export +# endif +# endif +# endif +#endif + +#if defined (__BEOS__) +# if defined (ZLIB_DLL) +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +#endif + +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif +#ifndef ZEXTERN +# define ZEXTERN extern +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(MACOS) && !defined(TARGET_OS_MAC) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ +typedef unsigned short uShort; + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#ifdef HAVE_UNISTD_H +# include /* for off_t */ +# include /* for SEEK_* and off_t */ +# define z_off_t off_t +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif +#ifndef z_off_t +# define z_off_t long +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(inflate_blocks,"INBL") +# pragma map(inflate_blocks_new,"INBLNE") +# pragma map(inflate_blocks_free,"INBLFR") +# pragma map(inflate_blocks_reset,"INBLRE") +# pragma map(inflate_codes_free,"INCOFR") +# pragma map(inflate_codes,"INCO") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_flush,"INFLU") +# pragma map(inflate_mask,"INMA") +# pragma map(inflate_set_dictionary,"INSEDI2") +# pragma map(inflate_copyright,"INCOPY") +# pragma map(inflate_trees_bits,"INTRBI") +# pragma map(inflate_trees_dynamic,"INTRDY") +# pragma map(inflate_trees_fixed,"INTRFI") +# pragma map(inflate_trees_free,"INTRFR") +#endif + +#endif /* _ZCONF_H */ diff --git a/engine/libs/zlib.h b/engine/libs/zlib.h new file mode 100644 index 000000000..156b9fa27 --- /dev/null +++ b/engine/libs/zlib.h @@ -0,0 +1,893 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.1.3, July 9th, 1998 + + Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef _ZLIB_H +#define _ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.1.3" + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never + crash even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: ascii or binary */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_in holds the total size of + the uncompressed data and may be saved for use in the decompressor + (particularly if the decompressor wants to decompress everything in + a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +/* Allowed flush values; see deflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_ASCII 1 +#define Z_UNKNOWN 2 +/* Possible values of the data_type field */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is + not compatible with the zlib.h header file used by the application. + This check is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. + If zalloc and zfree are set to Z_NULL, deflateInit updates them to + use default allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at + all (the input data is simply copied a block at a time). + Z_DEFAULT_COMPRESSION requests a default compromise between speed and + compression (currently equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if level is not a valid compression level, + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). + msg is set to null if there is no error message. deflateInit does not + perform any compression: this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce some + output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). + Some output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating avail_in or avail_out accordingly; avail_out + should never be zero before the call. The application can consume the + compressed output when it wants, for example when the output buffer is full + (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK + and with zero avail_out, it must be called again after making room in the + output buffer because there might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In particular + avail_in is zero after the call if enough output space has been provided + before the call.) Flushing may degrade compression for some compression + algorithms and so it should be used only when necessary. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + the compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there + was enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the + stream are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least + 0.1% larger than avail_in plus 12 bytes. If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update data_type if it can make a good guess about + the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered + binary. This field is only for information purposes and does not affect + the compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, + msg may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the exact + value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller. msg is set to null if there is no error + message. inflateInit does not perform any decompression apart from reading + the zlib header if present: this will be done by inflate(). (So next_in and + avail_in may be modified, but next_out and avail_out are unchanged.) +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may some + introduce some output latency (reading input without producing any output) + except when forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there + is no more input data or no more space in the output buffer (see below + about the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating the next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). If inflate returns Z_OK and with zero avail_out, it + must be called again after making room in the output buffer because there + might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much + output as possible to the output buffer. The flushing behavior of inflate is + not specified for values of the flush parameter other than Z_SYNC_FLUSH + and Z_FINISH, but the current implementation actually flushes as much output + as possible anyway. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step + (a single call of inflate), the parameter flush should be set to + Z_FINISH. In this case all pending input is processed and all pending + output is flushed; avail_out must be large enough to hold all the + uncompressed data. (The size of the uncompressed data may have been saved + by the compressor for this purpose.) The next operation on this stream must + be inflateEnd to deallocate the decompression state. The use of Z_FINISH + is never required, but can be used to inform inflate that a faster routine + may be used for the single inflate() call. + + If a preset dictionary is needed at this point (see inflateSetDictionary + below), inflate sets strm-adler to the adler32 checksum of the + dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise + it sets strm->adler to the adler32 checksum of all output produced + so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or + an error code as described below. At the end of the stream, inflate() + checks that its computed adler32 checksum is equal to that saved by the + compressor and returns Z_STREAM_END only if the checksum is correct. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect + adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent + (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if no progress is possible or if there was not + enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR + case, the application may then call inflateSync to look for a good + compression block. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by + the caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but + is slow and reduces compression ratio; memLevel=9 uses maximum memory + for optimal speed. The default value is 8. See zconf.h for total memory + usage as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match). Filtered data consists mostly of small values with a + somewhat random distribution. In this case, the compression algorithm is + tuned to compress them better. The effect of Z_FILTERED is to force more + Huffman coding and less string matching; it is somewhat intermediate + between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects + the compression ratio but not the correctness of the compressed output even + if it is not set appropriately. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid + method). msg is set to null if there is no error message. deflateInit2 does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. This function must be called + immediately after deflateInit, deflateInit2 or deflateReset, before any + call of deflate. The compressor and decompressor must use exactly the same + dictionary (see inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size in + deflate or deflate2. Thus the strings most likely to be useful should be + put at the end of the dictionary, not at the front. + + Upon return of this function, strm->adler is set to the Adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The Adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if the compression method is bsort). deflateSetDictionary does not + perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and + can consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. + The stream will keep the same compression level and any other attributes + that may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different + strategy. If the compression level is changed, the input available so far + is compressed with the old level (and may be flushed); the new level will + take effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to + be compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR + if strm->avail_out was zero. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. If a compressed stream with a larger window size is given as + input, inflate() will return with the error code Z_DATA_ERROR instead of + trying to allocate a larger window. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative + memLevel). msg is set to null if there is no error message. inflateInit2 + does not perform any decompression apart from reading the zlib header if + present: this will be done by inflate(). (So next_in and avail_in may be + modified, but next_out and avail_out are unchanged.) +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate + if this call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the Adler32 value returned by this call of + inflate. The compressor and decompressor must use exactly the same + dictionary (see deflateSetDictionary). + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect Adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a full flush point (see above the + description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR + if no more input was provided, Z_DATA_ERROR if no flush point has been found, + or Z_STREAM_ERROR if the stream structure was inconsistent. In the success + case, the application may save the current current value of total_in which + indicates where valid compressed data was found. In the error case, the + application may repeatedly call inflateSync, providing more input each time, + until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. + The stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + + + /* utility functions */ + +/* + The following utility functions are implemented on top of the + basic stream-oriented functions. To simplify the interface, some + default options are assumed (compression level and memory usage, + standard memory allocation functions). The source code of these + utility functions can easily be modified if you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be at least 0.1% larger than + sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the + compressed buffer. + This function can be used to compress a whole file at once if the + input file is mmap'ed. + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least 0.1% larger than sourceLen plus + 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + This function can be used to decompress a whole file at once if the + input file is mmap'ed. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted. +*/ + + +typedef voidp gzFile; + +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +/* + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb") but can also include a compression level + ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for + Huffman only compression as in "wb1h". (See the description + of deflateInit2 for more information about the strategy parameter.) + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. + + gzopen returns NULL if the file could not be opened or if there was + insufficient memory to allocate the (de)compression state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). */ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen() associates a gzFile with the file descriptor fd. File + descriptors are obtained from calls like open, dup, creat, pipe or + fileno (in the file has been previously opened with fopen). + The mode parameter is as in gzopen. + The next call of gzclose on the returned gzFile will also close the + file descriptor fd, just like fclose(fdopen(fd), mode) closes the file + descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). + gzdopen returns NULL if there was insufficient memory to allocate + the (de)compression state. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. + If the input file was not in gzip format, gzread copies the given number + of bytes into the buffer. + gzread returns the number of uncompressed bytes actually read (0 for + end of file, -1 for error). */ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + const voidp buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes actually written + (0 in case of error). +*/ + +ZEXTERN int VARGS ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the args to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written (0 in case of error). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or + a newline character is read and transferred to buf, or an end-of-file + condition is encountered. The string is then terminated with a null + character. + gzgets returns buf, or Z_NULL in case of error. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. + gzputc returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte + or -1 in case of end of file or error. +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter + flush is as in the deflate() function. The return value is the zlib + error number (see function gzerror below). gzflush returns Z_OK if + the flush parameter is Z_FINISH and all output could be flushed. + gzflush should be called only when strictly necessary because it can + degrade compression. +*/ + +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); +/* + Sets the starting position for the next gzread or gzwrite on the + given compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +/* + Returns the starting position for the next gzread or gzwrite on the + given compressed file. This position represents a number of bytes in the + uncompressed data stream. + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns 1 when EOF has previously been detected reading the given + input stream, otherwise zero. +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file + and deallocates all the (de)compression state. The return value is the zlib + error number (see function gzerror below). +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the + given compressed file. errnum is set to zlib error number. If an + error occurred in the file system and not in the compression library, + errnum is set to Z_ERRNO and the application may consult errno + to get the exact error code. +*/ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the + compression library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); + +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is NULL, this function returns + the required initial value for the checksum. + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running crc with the bytes buf[0..len-1] and return the updated + crc. If buf is NULL, this function returns the required initial value + for the crc. Pre- and post-conditioning (one's complement) is performed + within this function so it shouldn't be done by the application. + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) + + +#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +ZEXTERN const char * ZEXPORT zError OF((int err)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* _ZLIB_H */ diff --git a/engine/libs/zlib.lib b/engine/libs/zlib.lib new file mode 100644 index 0000000000000000000000000000000000000000..8af16a06d0c3f75cd6ca51c04902916bb0753f17 GIT binary patch literal 69576 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 X_Iv39BG~UH(YSS#0EAIWqxb&+==IC7 literal 0 HcmV?d00001