From f61cd1cfbb837c7253fd0e70d8cd62465161a0ed Mon Sep 17 00:00:00 2001 From: "Ben \"root\" Anderson" Date: Thu, 24 Oct 2013 11:36:49 -0500 Subject: [PATCH] First wave of pack-in libs --- extern/for_mingw/include/bzlib.h | 282 ++ extern/for_mingw/include/jconfig.h | 45 + extern/for_mingw/include/jerror.h | 291 ++ extern/for_mingw/include/jmorecfg.h | 363 ++ extern/for_mingw/include/jpeglib.h | 1096 ++++++ extern/for_mingw/include/libpng16/png.h | 3315 +++++++++++++++++ extern/for_mingw/include/libpng16/pngconf.h | 617 +++ .../for_mingw/include/libpng16/pnglibconf.h | 209 ++ extern/for_mingw/include/png.h | 3315 +++++++++++++++++ extern/for_mingw/include/pngconf.h | 617 +++ extern/for_mingw/include/pnglibconf.h | 209 ++ extern/for_mingw/include/zconf.h | 511 +++ extern/for_mingw/include/zlib.h | 1768 +++++++++ extern/for_mingw/lib/libbz2.a | Bin 0 -> 75156 bytes extern/for_mingw/lib/libjpeg.a | Bin 0 -> 205042 bytes extern/for_mingw/lib/libpng.a | Bin 0 -> 317662 bytes extern/for_mingw/lib/libpng.la | 41 + extern/for_mingw/lib/libpng16.a | Bin 0 -> 317662 bytes extern/for_mingw/lib/libpng16.la | 41 + extern/for_mingw/lib/libz.a | Bin 0 -> 102270 bytes extern/for_mingw/lib/pkgconfig/libpng.pc | 11 + extern/for_mingw/lib/pkgconfig/libpng16.pc | 11 + extern/for_mingw/lib/pkgconfig/zlib.pc | 13 + 23 files changed, 12755 insertions(+) create mode 100644 extern/for_mingw/include/bzlib.h create mode 100644 extern/for_mingw/include/jconfig.h create mode 100644 extern/for_mingw/include/jerror.h create mode 100644 extern/for_mingw/include/jmorecfg.h create mode 100644 extern/for_mingw/include/jpeglib.h create mode 100644 extern/for_mingw/include/libpng16/png.h create mode 100644 extern/for_mingw/include/libpng16/pngconf.h create mode 100644 extern/for_mingw/include/libpng16/pnglibconf.h create mode 100644 extern/for_mingw/include/png.h create mode 100644 extern/for_mingw/include/pngconf.h create mode 100644 extern/for_mingw/include/pnglibconf.h create mode 100644 extern/for_mingw/include/zconf.h create mode 100644 extern/for_mingw/include/zlib.h create mode 100644 extern/for_mingw/lib/libbz2.a create mode 100644 extern/for_mingw/lib/libjpeg.a create mode 100644 extern/for_mingw/lib/libpng.a create mode 100644 extern/for_mingw/lib/libpng.la create mode 100644 extern/for_mingw/lib/libpng16.a create mode 100644 extern/for_mingw/lib/libpng16.la create mode 100644 extern/for_mingw/lib/libz.a create mode 100644 extern/for_mingw/lib/pkgconfig/libpng.pc create mode 100644 extern/for_mingw/lib/pkgconfig/libpng16.pc create mode 100644 extern/for_mingw/lib/pkgconfig/zlib.pc diff --git a/extern/for_mingw/include/bzlib.h b/extern/for_mingw/include/bzlib.h new file mode 100644 index 0000000000..8277123da8 --- /dev/null +++ b/extern/for_mingw/include/bzlib.h @@ -0,0 +1,282 @@ + +/*-------------------------------------------------------------*/ +/*--- Public header file for the library. ---*/ +/*--- bzlib.h ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.6 of 6 September 2010 + Copyright (C) 1996-2010 Julian Seward + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + + +#ifndef _BZLIB_H +#define _BZLIB_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define BZ_RUN 0 +#define BZ_FLUSH 1 +#define BZ_FINISH 2 + +#define BZ_OK 0 +#define BZ_RUN_OK 1 +#define BZ_FLUSH_OK 2 +#define BZ_FINISH_OK 3 +#define BZ_STREAM_END 4 +#define BZ_SEQUENCE_ERROR (-1) +#define BZ_PARAM_ERROR (-2) +#define BZ_MEM_ERROR (-3) +#define BZ_DATA_ERROR (-4) +#define BZ_DATA_ERROR_MAGIC (-5) +#define BZ_IO_ERROR (-6) +#define BZ_UNEXPECTED_EOF (-7) +#define BZ_OUTBUFF_FULL (-8) +#define BZ_CONFIG_ERROR (-9) + +typedef + struct { + char *next_in; + unsigned int avail_in; + unsigned int total_in_lo32; + unsigned int total_in_hi32; + + char *next_out; + unsigned int avail_out; + unsigned int total_out_lo32; + unsigned int total_out_hi32; + + void *state; + + void *(*bzalloc)(void *,int,int); + void (*bzfree)(void *,void *); + void *opaque; + } + bz_stream; + + +#ifndef BZ_IMPORT +#define BZ_EXPORT +#endif + +#ifndef BZ_NO_STDIO +/* Need a definitition for FILE */ +#include +#endif + +#ifdef _WIN32 +# include +# ifdef small + /* windows.h define small to char */ +# undef small +# endif +# ifdef BZ_EXPORT +# define BZ_API(func) WINAPI func +# define BZ_EXTERN extern +# else + /* import windows dll dynamically */ +# define BZ_API(func) (WINAPI * func) +# define BZ_EXTERN +# endif +#else +# define BZ_API(func) func +# define BZ_EXTERN extern +#endif + + +/*-- Core (low-level) library functions --*/ + +BZ_EXTERN int BZ_API(BZ2_bzCompressInit) ( + bz_stream* strm, + int blockSize100k, + int verbosity, + int workFactor + ); + +BZ_EXTERN int BZ_API(BZ2_bzCompress) ( + bz_stream* strm, + int action + ); + +BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) ( + bz_stream* strm + ); + +BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) ( + bz_stream *strm, + int verbosity, + int small + ); + +BZ_EXTERN int BZ_API(BZ2_bzDecompress) ( + bz_stream* strm + ); + +BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) ( + bz_stream *strm + ); + + + +/*-- High(er) level library functions --*/ + +#ifndef BZ_NO_STDIO +#define BZ_MAX_UNUSED 5000 + +typedef void BZFILE; + +BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) ( + int* bzerror, + FILE* f, + int verbosity, + int small, + void* unused, + int nUnused + ); + +BZ_EXTERN void BZ_API(BZ2_bzReadClose) ( + int* bzerror, + BZFILE* b + ); + +BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) ( + int* bzerror, + BZFILE* b, + void** unused, + int* nUnused + ); + +BZ_EXTERN int BZ_API(BZ2_bzRead) ( + int* bzerror, + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) ( + int* bzerror, + FILE* f, + int blockSize100k, + int verbosity, + int workFactor + ); + +BZ_EXTERN void BZ_API(BZ2_bzWrite) ( + int* bzerror, + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN void BZ_API(BZ2_bzWriteClose) ( + int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in, + unsigned int* nbytes_out + ); + +BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) ( + int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in_lo32, + unsigned int* nbytes_in_hi32, + unsigned int* nbytes_out_lo32, + unsigned int* nbytes_out_hi32 + ); +#endif + + +/*-- Utility functions --*/ + +BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) ( + char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int blockSize100k, + int verbosity, + int workFactor + ); + +BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) ( + char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int small, + int verbosity + ); + + +/*-- + Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp) + to support better zlib compatibility. + This code is not _officially_ part of libbzip2 (yet); + I haven't tested it, documented it, or considered the + threading-safeness of it. + If this code breaks, please contact both Yoshioka and me. +--*/ + +BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) ( + void + ); + +#ifndef BZ_NO_STDIO +BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) ( + const char *path, + const char *mode + ); + +BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) ( + int fd, + const char *mode + ); + +BZ_EXTERN int BZ_API(BZ2_bzread) ( + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN int BZ_API(BZ2_bzwrite) ( + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN int BZ_API(BZ2_bzflush) ( + BZFILE* b + ); + +BZ_EXTERN void BZ_API(BZ2_bzclose) ( + BZFILE* b + ); + +BZ_EXTERN const char * BZ_API(BZ2_bzerror) ( + BZFILE *b, + int *errnum + ); +#endif + +#ifdef __cplusplus +} +#endif + +#endif + +/*-------------------------------------------------------------*/ +/*--- end bzlib.h ---*/ +/*-------------------------------------------------------------*/ diff --git a/extern/for_mingw/include/jconfig.h b/extern/for_mingw/include/jconfig.h new file mode 100644 index 0000000000..9594ec56bb --- /dev/null +++ b/extern/for_mingw/include/jconfig.h @@ -0,0 +1,45 @@ +/* jconfig.h. Generated automatically by configure. */ +/* jconfig.cfg --- source file edited by configure script */ +/* see jconfig.doc for explanations */ + +#define HAVE_PROTOTYPES +#define HAVE_UNSIGNED_CHAR +#define HAVE_UNSIGNED_SHORT +#undef void +#undef 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 +#undef NEED_SHORT_EXTERNAL_NAMES +/* Define this if you get warnings about undefined structures. */ +#undef INCOMPLETE_TYPES_BROKEN + +#ifdef JPEG_INTERNALS + +#undef RIGHT_SHIFT_IS_UNSIGNED +#define INLINE __inline__ +/* These are for configuring the JPEG memory manager. */ +#undef DEFAULT_MAX_MEM +#undef NO_MKTEMP + +#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 */ + +#undef TWO_FILE_COMMANDLINE +#undef NEED_SIGNAL_CATCHER +#undef DONT_USE_B_MODE + +/* Define this if you want percent-done progress reports from cjpeg/djpeg. */ +#undef PROGRESS_REPORT + +#endif /* JPEG_CJPEG_DJPEG */ diff --git a/extern/for_mingw/include/jerror.h b/extern/for_mingw/include/jerror.h new file mode 100644 index 0000000000..fc2fffeac2 --- /dev/null +++ b/extern/for_mingw/include/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/extern/for_mingw/include/jmorecfg.h b/extern/for_mingw/include/jmorecfg.h new file mode 100644 index 0000000000..54a7d1c447 --- /dev/null +++ b/extern/for_mingw/include/jmorecfg.h @@ -0,0 +1,363 @@ +/* + * 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. + */ + +#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. + */ + +/* a function called through method pointers: */ +#define METHODDEF(type) static type +/* a function used only in its module: */ +#define LOCAL(type) static type +/* a function referenced thru EXTERNs: */ +#define GLOBAL(type) type +/* a reference to a GLOBAL function: */ +#define EXTERN(type) extern type + + +/* 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 (*methodname) arglist +#else +#define JMETHOD(type,methodname,arglist) type (*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. + */ + +#ifdef NEED_FAR_POINTERS +#define FAR far +#else +#define FAR +#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/extern/for_mingw/include/jpeglib.h b/extern/for_mingw/include/jpeglib.h new file mode 100644 index 0000000000..d1be8ddeff --- /dev/null +++ b/extern/for_mingw/include/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/extern/for_mingw/include/libpng16/png.h b/extern/for_mingw/include/libpng16/png.h new file mode 100644 index 0000000000..71c2ab6750 --- /dev/null +++ b/extern/for_mingw/include/libpng16/png.h @@ -0,0 +1,3315 @@ + +/* png.h - header file for PNG reference library + * + * libpng version 1.6.6 - September 16, 2013 + * Copyright (c) 1998-2013 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * This code is released under the libpng license (See LICENSE, below) + * + * Authors and maintainers: + * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat + * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger + * libpng versions 0.97, January 1998, through 1.6.6 - September 16, 2013: Glenn + * See also "Contributing Authors", below. + * + * Note about libpng version numbers: + * + * Due to various miscommunications, unforeseen code incompatibilities + * and occasional factors outside the authors' control, version numbering + * on the library has not always been consistent and straightforward. + * The following table summarizes matters since version 0.89c, which was + * the first widely used release: + * + * source png.h png.h shared-lib + * version string int version + * ------- ------ ----- ---------- + * 0.89c "1.0 beta 3" 0.89 89 1.0.89 + * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] + * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] + * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] + * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] + * 0.97c 0.97 97 2.0.97 + * 0.98 0.98 98 2.0.98 + * 0.99 0.99 98 2.0.99 + * 0.99a-m 0.99 99 2.0.99 + * 1.00 1.00 100 2.1.0 [100 should be 10000] + * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] + * 1.0.1 png.h string is 10001 2.1.0 + * 1.0.1a-e identical to the 10002 from here on, the shared library + * 1.0.2 source version) 10002 is 2.V where V is the source code + * 1.0.2a-b 10003 version, except as noted. + * 1.0.3 10003 + * 1.0.3a-d 10004 + * 1.0.4 10004 + * 1.0.4a-f 10005 + * 1.0.5 (+ 2 patches) 10005 + * 1.0.5a-d 10006 + * 1.0.5e-r 10100 (not source compatible) + * 1.0.5s-v 10006 (not binary compatible) + * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) + * 1.0.6d-f 10007 (still binary incompatible) + * 1.0.6g 10007 + * 1.0.6h 10007 10.6h (testing xy.z so-numbering) + * 1.0.6i 10007 10.6i + * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) + * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) + * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) + * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) + * 1.0.7 1 10007 (still compatible) + * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 + * 1.0.8rc1 1 10008 2.1.0.8rc1 + * 1.0.8 1 10008 2.1.0.8 + * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 + * 1.0.9rc1 1 10009 2.1.0.9rc1 + * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 + * 1.0.9rc2 1 10009 2.1.0.9rc2 + * 1.0.9 1 10009 2.1.0.9 + * 1.0.10beta1 1 10010 2.1.0.10beta1 + * 1.0.10rc1 1 10010 2.1.0.10rc1 + * 1.0.10 1 10010 2.1.0.10 + * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 + * 1.0.11rc1 1 10011 2.1.0.11rc1 + * 1.0.11 1 10011 2.1.0.11 + * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 + * 1.0.12rc1 2 10012 2.1.0.12rc1 + * 1.0.12 2 10012 2.1.0.12 + * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) + * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 + * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 + * 1.2.0rc1 3 10200 3.1.2.0rc1 + * 1.2.0 3 10200 3.1.2.0 + * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 + * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 + * 1.2.1 3 10201 3.1.2.1 + * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 + * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 + * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 + * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 + * 1.0.13 10 10013 10.so.0.1.0.13 + * 1.2.2 12 10202 12.so.0.1.2.2 + * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 + * 1.2.3 12 10203 12.so.0.1.2.3 + * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 + * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 + * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 + * 1.0.14 10 10014 10.so.0.1.0.14 + * 1.2.4 13 10204 12.so.0.1.2.4 + * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 + * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 + * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 + * 1.0.15 10 10015 10.so.0.1.0.15 + * 1.2.5 13 10205 12.so.0.1.2.5 + * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 + * 1.0.16 10 10016 10.so.0.1.0.16 + * 1.2.6 13 10206 12.so.0.1.2.6 + * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 + * 1.0.17rc1 10 10017 12.so.0.1.0.17rc1 + * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 + * 1.0.17 10 10017 12.so.0.1.0.17 + * 1.2.7 13 10207 12.so.0.1.2.7 + * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 + * 1.0.18rc1-5 10 10018 12.so.0.1.0.18rc1-5 + * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 + * 1.0.18 10 10018 12.so.0.1.0.18 + * 1.2.8 13 10208 12.so.0.1.2.8 + * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 + * 1.2.9beta4-11 13 10209 12.so.0.9[.0] + * 1.2.9rc1 13 10209 12.so.0.9[.0] + * 1.2.9 13 10209 12.so.0.9[.0] + * 1.2.10beta1-7 13 10210 12.so.0.10[.0] + * 1.2.10rc1-2 13 10210 12.so.0.10[.0] + * 1.2.10 13 10210 12.so.0.10[.0] + * 1.4.0beta1-5 14 10400 14.so.0.0[.0] + * 1.2.11beta1-4 13 10211 12.so.0.11[.0] + * 1.4.0beta7-8 14 10400 14.so.0.0[.0] + * 1.2.11 13 10211 12.so.0.11[.0] + * 1.2.12 13 10212 12.so.0.12[.0] + * 1.4.0beta9-14 14 10400 14.so.0.0[.0] + * 1.2.13 13 10213 12.so.0.13[.0] + * 1.4.0beta15-36 14 10400 14.so.0.0[.0] + * 1.4.0beta37-87 14 10400 14.so.14.0[.0] + * 1.4.0rc01 14 10400 14.so.14.0[.0] + * 1.4.0beta88-109 14 10400 14.so.14.0[.0] + * 1.4.0rc02-08 14 10400 14.so.14.0[.0] + * 1.4.0 14 10400 14.so.14.0[.0] + * 1.4.1beta01-03 14 10401 14.so.14.1[.0] + * 1.4.1rc01 14 10401 14.so.14.1[.0] + * 1.4.1beta04-12 14 10401 14.so.14.1[.0] + * 1.4.1 14 10401 14.so.14.1[.0] + * 1.4.2 14 10402 14.so.14.2[.0] + * 1.4.3 14 10403 14.so.14.3[.0] + * 1.4.4 14 10404 14.so.14.4[.0] + * 1.5.0beta01-58 15 10500 15.so.15.0[.0] + * 1.5.0rc01-07 15 10500 15.so.15.0[.0] + * 1.5.0 15 10500 15.so.15.0[.0] + * 1.5.1beta01-11 15 10501 15.so.15.1[.0] + * 1.5.1rc01-02 15 10501 15.so.15.1[.0] + * 1.5.1 15 10501 15.so.15.1[.0] + * 1.5.2beta01-03 15 10502 15.so.15.2[.0] + * 1.5.2rc01-03 15 10502 15.so.15.2[.0] + * 1.5.2 15 10502 15.so.15.2[.0] + * 1.5.3beta01-10 15 10503 15.so.15.3[.0] + * 1.5.3rc01-02 15 10503 15.so.15.3[.0] + * 1.5.3beta11 15 10503 15.so.15.3[.0] + * 1.5.3 [omitted] + * 1.5.4beta01-08 15 10504 15.so.15.4[.0] + * 1.5.4rc01 15 10504 15.so.15.4[.0] + * 1.5.4 15 10504 15.so.15.4[.0] + * 1.5.5beta01-08 15 10505 15.so.15.5[.0] + * 1.5.5rc01 15 10505 15.so.15.5[.0] + * 1.5.5 15 10505 15.so.15.5[.0] + * 1.5.6beta01-07 15 10506 15.so.15.6[.0] + * 1.5.6rc01-03 15 10506 15.so.15.6[.0] + * 1.5.6 15 10506 15.so.15.6[.0] + * 1.5.7beta01-05 15 10507 15.so.15.7[.0] + * 1.5.7rc01-03 15 10507 15.so.15.7[.0] + * 1.5.7 15 10507 15.so.15.7[.0] + * 1.6.0beta01-40 16 10600 16.so.16.0[.0] + * 1.6.0rc01-08 16 10600 16.so.16.0[.0] + * 1.6.0 16 10600 16.so.16.0[.0] + * 1.6.1beta01-09 16 10601 16.so.16.1[.0] + * 1.6.1rc01 16 10601 16.so.16.1[.0] + * 1.6.1 16 10601 16.so.16.1[.0] + * 1.6.2beta01 16 10602 16.so.16.2[.0] + * 1.6.2rc01-06 16 10602 16.so.16.2[.0] + * 1.6.2 16 10602 16.so.16.2[.0] + * 1.6.3beta01-11 16 10603 16.so.16.3[.0] + * 1.6.3rc01 16 10603 16.so.16.3[.0] + * 1.6.3 16 10603 16.so.16.3[.0] + * 1.6.4beta01-02 16 10604 16.so.16.4[.0] + * 1.6.4rc01 16 10604 16.so.16.4[.0] + * 1.6.4 16 10604 16.so.16.4[.0] + * 1.6.5 16 10605 16.so.16.5[.0] + * 1.6.6 16 10606 16.so.16.6[.0] + * + * Henceforth the source version will match the shared-library major + * and minor numbers; the shared-library major version number will be + * used for changes in backward compatibility, as it is intended. The + * PNG_LIBPNG_VER macro, which is not used within libpng but is available + * for applications, is an unsigned integer of the form xyyzz corresponding + * to the source version x.y.z (leading zeros in y and z). Beta versions + * were given the previous public release number plus a letter, until + * version 1.0.6j; from then on they were given the upcoming public + * release number plus "betaNN" or "rcNN". + * + * Binary incompatibility exists only when applications make direct access + * to the info_ptr or png_ptr members through png.h, and the compiled + * application is loaded with a different version of the library. + * + * DLLNUM will change each time there are forward or backward changes + * in binary compatibility (e.g., when a new feature is added). + * + * See libpng-manual.txt or libpng.3 for more information. The PNG + * specification is available as a W3C Recommendation and as an ISO + * Specification, defines should NOT be changed. + */ +#define PNG_INFO_gAMA 0x0001 +#define PNG_INFO_sBIT 0x0002 +#define PNG_INFO_cHRM 0x0004 +#define PNG_INFO_PLTE 0x0008 +#define PNG_INFO_tRNS 0x0010 +#define PNG_INFO_bKGD 0x0020 +#define PNG_INFO_hIST 0x0040 +#define PNG_INFO_pHYs 0x0080 +#define PNG_INFO_oFFs 0x0100 +#define PNG_INFO_tIME 0x0200 +#define PNG_INFO_pCAL 0x0400 +#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ +#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ +#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ +#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ +#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */ + +/* This is used for the transformation routines, as some of them + * change these values for the row. It also should enable using + * the routines for other purposes. + */ +typedef struct png_row_info_struct +{ + png_uint_32 width; /* width of row */ + png_size_t rowbytes; /* number of bytes in row */ + png_byte color_type; /* color type of row */ + png_byte bit_depth; /* bit depth of row */ + png_byte channels; /* number of channels (1, 2, 3, or 4) */ + png_byte pixel_depth; /* bits per pixel (depth * channels) */ +} png_row_info; + +typedef png_row_info * png_row_infop; +typedef png_row_info * * 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. Note that the 'write' function must not + * modify the buffer it is passed. The 'read' function, on the other hand, is + * expected to return the read data in the buffer. + */ +typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp)); +typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t)); +typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp)); +typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32, + int)); +typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32, + int)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop)); +typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop)); + +/* The following callback receives png_uint_32 row_number, int pass for the + * png_bytep data of the row. When transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep, + png_uint_32, int)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop, + png_bytep)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp, + png_unknown_chunkp)); +#endif +#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +/* not used anywhere */ +/* typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); */ +#endif + +#ifdef PNG_SETJMP_SUPPORTED +/* This must match the function definition in , and the application + * must include this before png.h to obtain the definition of jmp_buf. The + * function is required to be PNG_NORETURN, but this is not checked. If the + * function does return the application will crash via an abort() or similar + * system level call. + * + * If you get a warning here while building the library you may need to make + * changes to ensure that pnglibconf.h records the calling convention used by + * your compiler. This may be very difficult - try using a different compiler + * to build the library! + */ +PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef); +#endif + +/* Transform masks for the high-level interface */ +#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ +#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ +#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ +#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ +#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ +#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ +#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ +#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ +#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ +#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ +#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ +#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ +#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */ +/* Added to libpng-1.2.34 */ +#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER +#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ +/* Added to libpng-1.4.0 */ +#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ +/* Added to libpng-1.5.4 */ +#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */ +#define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */ + +/* Flags for MNG supported features */ +#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 +#define PNG_FLAG_MNG_FILTER_64 0x04 +#define PNG_ALL_MNG_FEATURES 0x05 + +/* NOTE: prior to 1.5 these functions had no 'API' style declaration, + * this allowed the zlib default functions to be used on Windows + * platforms. In 1.5 the zlib default malloc (which just calls malloc and + * ignores the first argument) should be completely compatible with the + * following. + */ +typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp, + png_alloc_size_t)); +typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp)); + +/* Section 3: exported functions + * Here are the function definitions most commonly used. This is not + * the place to find out how to use libpng. See libpng-manual.txt for the + * full explanation, see example.c for the summary. This just provides + * a simple one line description of the use of each function. + * + * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in + * pngconf.h and in the *.dfn files in the scripts directory. + * + * PNG_EXPORT(ordinal, type, name, (args)); + * + * ordinal: ordinal that is used while building + * *.def files. The ordinal value is only + * relevant when preprocessing png.h with + * the *.dfn files for building symbol table + * entries, and are removed by pngconf.h. + * type: return type of the function + * name: function name + * args: function arguments, with types + * + * When we wish to append attributes to a function prototype we use + * the PNG_EXPORTA() macro instead. + * + * PNG_EXPORTA(ordinal, type, name, (args), attributes); + * + * ordinal, type, name, and args: same as in PNG_EXPORT(). + * attributes: function attributes + */ + +/* Returns the version number of the library */ +PNG_EXPORT(1, png_uint_32, png_access_version_number, (void)); + +/* Tell lib we have already handled the first magic bytes. + * Handling more than 8 bytes from the beginning of the file is an error. + */ +PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes)); + +/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a + * PNG file. Returns zero if the supplied bytes match the 8-byte PNG + * signature, and non-zero otherwise. Having num_to_check == 0 or + * start > 7 will always fail (ie return non-zero). + */ +PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start, + png_size_t num_to_check)); + +/* Simple signature checking function. This is the same as calling + * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). + */ +#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n)) + +/* Allocate and initialize png_ptr struct for reading, and any other memory. */ +PNG_EXPORTA(4, png_structp, png_create_read_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn), + PNG_ALLOCATED); + +/* Allocate and initialize png_ptr struct for writing, and any other memory */ +PNG_EXPORTA(5, png_structp, png_create_write_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn), + PNG_ALLOCATED); + +PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size, + (png_const_structrp png_ptr)); + +PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr, + png_size_t size)); + +/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp + * match up. + */ +#ifdef PNG_SETJMP_SUPPORTED +/* This function returns the jmp_buf built in to *png_ptr. It must be + * supplied with an appropriate 'longjmp' function to use on that jmp_buf + * unless the default error function is overridden in which case NULL is + * acceptable. The size of the jmp_buf is checked against the actual size + * allocated by the library - the call will return NULL on a mismatch + * indicating an ABI mismatch. + */ +PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr, + png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)); +# define png_jmpbuf(png_ptr) \ + (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf)))) +#else +# define png_jmpbuf(png_ptr) \ + (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) +#endif +/* This function should be used by libpng applications in place of + * longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it + * will use it; otherwise it will call PNG_ABORT(). This function was + * added in libpng-1.5.0. + */ +PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val), + PNG_NORETURN); + +#ifdef PNG_READ_SUPPORTED +/* Reset the compression stream */ +PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED); +#endif + +/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ +#ifdef PNG_USER_MEM_SUPPORTED +PNG_EXPORTA(11, png_structp, png_create_read_struct_2, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), + PNG_ALLOCATED); +PNG_EXPORTA(12, png_structp, png_create_write_struct_2, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), + PNG_ALLOCATED); +#endif + +/* Write the PNG file signature. */ +PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr)); + +/* Write a PNG chunk - size, type, (optional) data, CRC. */ +PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep + chunk_name, png_const_bytep data, png_size_t length)); + +/* Write the start of a PNG chunk - length and chunk name. */ +PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr, + png_const_bytep chunk_name, png_uint_32 length)); + +/* Write the data of a PNG chunk started with png_write_chunk_start(). */ +PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr, + png_const_bytep data, png_size_t length)); + +/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr)); + +/* Allocate and initialize the info structure */ +PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr), + PNG_ALLOCATED); + +/* DEPRECATED: this function allowed init structures to be created using the + * default allocation method (typically malloc). Use is deprecated in 1.6.0 and + * the API will be removed in the future. + */ +PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr, + png_size_t png_info_struct_size), PNG_DEPRECATED); + +/* Writes all the PNG information before the image. */ +PNG_EXPORT(20, void, png_write_info_before_PLTE, + (png_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(21, void, png_write_info, + (png_structrp png_ptr, png_const_inforp info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the information before the actual image data. */ +PNG_EXPORT(22, void, png_read_info, + (png_structrp png_ptr, png_inforp info_ptr)); +#endif + +#ifdef PNG_TIME_RFC1123_SUPPORTED + /* Convert to a US string format: there is no localization support in this + * routine. The original implementation used a 29 character buffer in + * png_struct, this will be removed in future versions. + */ +#if PNG_LIBPNG_VER < 10700 +/* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */ +PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr, + png_const_timep ptime),PNG_DEPRECATED); +#endif +PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29], + png_const_timep ptime)); +#endif + +#ifdef PNG_CONVERT_tIME_SUPPORTED +/* Convert from a struct tm to png_time */ +PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime, + const struct tm * ttime)); + +/* Convert from time_t to png_time. Uses gmtime() */ +PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime)); +#endif /* PNG_CONVERT_tIME_SUPPORTED */ + +#ifdef PNG_READ_EXPAND_SUPPORTED +/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ +PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr)); +PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr)); +PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr)); +PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_EXPAND_16_SUPPORTED +/* Expand to 16-bit channels, forces conversion of palette to RGB and expansion + * of a tRNS chunk if present. + */ +PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +/* Use blue, green, red order for pixels. */ +PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED +/* Expand the grayscale to 24-bit RGB if necessary. */ +PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED +/* Reduce RGB to grayscale. */ +#define PNG_ERROR_ACTION_NONE 1 +#define PNG_ERROR_ACTION_WARN 2 +#define PNG_ERROR_ACTION_ERROR 3 +#define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/ + +PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr, + int error_action, double red, double green)) +PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structrp png_ptr, + int error_action, png_fixed_point red, png_fixed_point green)) + +PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structrp + png_ptr)); +#endif + +#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED +PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth, + png_colorp palette)); +#endif + +#ifdef PNG_READ_ALPHA_MODE_SUPPORTED +/* How the alpha channel is interpreted - this affects how the color channels of + * a PNG file are returned when an alpha channel, or tRNS chunk in a palette + * file, is present. + * + * This has no effect on the way pixels are written into a PNG output + * datastream. The color samples in a PNG datastream are never premultiplied + * with the alpha samples. + * + * The default is to return data according to the PNG specification: the alpha + * channel is a linear measure of the contribution of the pixel to the + * corresponding composited pixel. The gamma encoded color channels must be + * scaled according to the contribution and to do this it is necessary to undo + * the encoding, scale the color values, perform the composition and reencode + * the values. This is the 'PNG' mode. + * + * The alternative is to 'associate' the alpha with the color information by + * storing color channel values that have been scaled by the alpha. The + * advantage is that the color channels can be resampled (the image can be + * scaled) in this form. The disadvantage is that normal practice is to store + * linear, not (gamma) encoded, values and this requires 16-bit channels for + * still images rather than the 8-bit channels that are just about sufficient if + * gamma encoding is used. In addition all non-transparent pixel values, + * including completely opaque ones, must be gamma encoded to produce the final + * image. This is the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' mode (the + * latter being the two common names for associated alpha color channels.) + * + * Since it is not necessary to perform arithmetic on opaque color values so + * long as they are not to be resampled and are in the final color space it is + * possible to optimize the handling of alpha by storing the opaque pixels in + * the PNG format (adjusted for the output color space) while storing partially + * opaque pixels in the standard, linear, format. The accuracy required for + * standard alpha composition is relatively low, because the pixels are + * isolated, therefore typically the accuracy loss in storing 8-bit linear + * values is acceptable. (This is not true if the alpha channel is used to + * simulate transparency over large areas - use 16 bits or the PNG mode in + * this case!) This is the 'OPTIMIZED' mode. For this mode a pixel is + * treated as opaque only if the alpha value is equal to the maximum value. + * + * The final choice is to gamma encode the alpha channel as well. This is + * broken because, in practice, no implementation that uses this choice + * correctly undoes the encoding before handling alpha composition. Use this + * choice only if other serious errors in the software or hardware you use + * mandate it; the typical serious error is for dark halos to appear around + * opaque areas of the composited PNG image because of arithmetic overflow. + * + * The API function png_set_alpha_mode specifies which of these choices to use + * with an enumerated 'mode' value and the gamma of the required output: + */ +#define PNG_ALPHA_PNG 0 /* according to the PNG standard */ +#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */ +#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */ +#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */ +#define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */ +#define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */ + +PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structrp png_ptr, int mode, + double output_gamma)) +PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr, + int mode, png_fixed_point output_gamma)) +#endif + +#if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED) +/* The output_gamma value is a screen gamma in libpng terminology: it expresses + * how to decode the output values, not how they are encoded. The values used + * correspond to the normal numbers used to describe the overall gamma of a + * computer display system; for example 2.2 for an sRGB conformant system. The + * values are scaled by 100000 in the _fixed version of the API (so 220000 for + * sRGB.) + * + * The inverse of the value is always used to provide a default for the PNG file + * encoding if it has no gAMA chunk and if png_set_gamma() has not been called + * to override the PNG gamma information. + * + * When the ALPHA_OPTIMIZED mode is selected the output gamma is used to encode + * opaque pixels however pixels with lower alpha values are not encoded, + * regardless of the output gamma setting. + * + * When the standard Porter Duff handling is requested with mode 1 the output + * encoding is set to be linear and the output_gamma value is only relevant + * as a default for input data that has no gamma information. The linear output + * encoding will be overridden if png_set_gamma() is called - the results may be + * highly unexpected! + * + * The following numbers are derived from the sRGB standard and the research + * behind it. sRGB is defined to be approximated by a PNG gAMA chunk value of + * 0.45455 (1/2.2) for PNG. The value implicitly includes any viewing + * correction required to take account of any differences in the color + * environment of the original scene and the intended display environment; the + * value expresses how to *decode* the image for display, not how the original + * data was *encoded*. + * + * sRGB provides a peg for the PNG standard by defining a viewing environment. + * sRGB itself, and earlier TV standards, actually use a more complex transform + * (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is + * limited to simple power laws.) By saying that an image for direct display on + * an sRGB conformant system should be stored with a gAMA chunk value of 45455 + * (11.3.3.2 and 11.3.3.5 of the ISO PNG specification) the PNG specification + * makes it possible to derive values for other display systems and + * environments. + * + * The Mac value is deduced from the sRGB based on an assumption that the actual + * extra viewing correction used in early Mac display systems was implemented as + * a power 1.45 lookup table. + * + * Any system where a programmable lookup table is used or where the behavior of + * the final display device characteristics can be changed requires system + * specific code to obtain the current characteristic. However this can be + * difficult and most PNG gamma correction only requires an approximate value. + * + * By default, if png_set_alpha_mode() is not called, libpng assumes that all + * values are unencoded, linear, values and that the output device also has a + * linear characteristic. This is only very rarely correct - it is invariably + * better to call png_set_alpha_mode() with PNG_DEFAULT_sRGB than rely on the + * default if you don't know what the right answer is! + * + * The special value PNG_GAMMA_MAC_18 indicates an older Mac system (pre Mac OS + * 10.6) which used a correction table to implement a somewhat lower gamma on an + * otherwise sRGB system. + * + * Both these values are reserved (not simple gamma values) in order to allow + * more precise correction internally in the future. + * + * NOTE: the following values can be passed to either the fixed or floating + * point APIs, but the floating point API will also accept floating point + * values. + */ +#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */ +#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */ +#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */ +#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */ +#endif + +/* The following are examples of calls to png_set_alpha_mode to achieve the + * required overall gamma correction and, where necessary, alpha + * premultiplication. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * This is the default libpng handling of the alpha channel - it is not + * pre-multiplied into the color components. In addition the call states + * that the output is for a sRGB system and causes all PNG files without gAMA + * chunks to be assumed to be encoded using sRGB. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * In this case the output is assumed to be something like an sRGB conformant + * display preceeded by a power-law lookup table of power 1.45. This is how + * early Mac systems behaved. + * + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR); + * This is the classic Jim Blinn approach and will work in academic + * environments where everything is done by the book. It has the shortcoming + * of assuming that input PNG data with no gamma information is linear - this + * is unlikely to be correct unless the PNG files where generated locally. + * Most of the time the output precision will be so low as to show + * significant banding in dark areas of the image. + * + * png_set_expand_16(pp); + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB); + * This is a somewhat more realistic Jim Blinn inspired approach. PNG files + * are assumed to have the sRGB encoding if not marked with a gamma value and + * the output is always 16 bits per component. This permits accurate scaling + * and processing of the data. If you know that your input PNG files were + * generated locally you might need to replace PNG_DEFAULT_sRGB with the + * correct value for your system. + * + * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB); + * If you just need to composite the PNG image onto an existing background + * and if you control the code that does this you can use the optimization + * setting. In this case you just copy completely opaque pixels to the + * output. For pixels that are not completely transparent (you just skip + * those) you do the composition math using png_composite or png_composite_16 + * below then encode the resultant 8-bit or 16-bit values to match the output + * encoding. + * + * Other cases + * If neither the PNG nor the standard linear encoding work for you because + * of the software or hardware you use then you have a big problem. The PNG + * case will probably result in halos around the image. The linear encoding + * will probably result in a washed out, too bright, image (it's actually too + * contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably + * substantially reduce the halos. Alternatively try: + * + * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB); + * This option will also reduce the halos, but there will be slight dark + * halos round the opaque parts of the image where the background is light. + * In the OPTIMIZED mode the halos will be light halos where the background + * is dark. Take your pick - the halos are unavoidable unless you can get + * your hardware/software fixed! (The OPTIMIZED approach is slightly + * faster.) + * + * When the default gamma of PNG files doesn't match the output gamma. + * If you have PNG files with no gamma information png_set_alpha_mode allows + * you to provide a default gamma, but it also sets the ouput gamma to the + * matching value. If you know your PNG files have a gamma that doesn't + * match the output you can take advantage of the fact that + * png_set_alpha_mode always sets the output gamma but only sets the PNG + * default if it is not already set: + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * The first call sets both the default and the output gamma values, the + * second call overrides the output gamma without changing the default. This + * is easier than achieving the same effect with png_set_gamma. You must use + * PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will + * fire if more than one call to png_set_alpha_mode and png_set_background is + * made in the same read operation, however multiple calls with PNG_ALPHA_PNG + * are ignored. + */ + +#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED +PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ +PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler, + int flags)); +/* The values of the PNG_FILLER_ defines should NOT be changed */ +# define PNG_FILLER_BEFORE 0 +# define PNG_FILLER_AFTER 1 +/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ +PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr, + png_uint_32 filler, int flags)); +#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +/* Swap bytes in 16-bit depth files. */ +PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) +/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ +PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ + defined(PNG_WRITE_PACKSWAP_SUPPORTED) +/* Swap packing order of pixels in bytes. */ +PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +/* Converts files to legal bit depths. */ +PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p + true_bits)); +#endif + +#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ + defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* Have the code handle the interlacing. Returns the number of passes. + * MUST be called before png_read_update_info or png_start_read_image, + * otherwise it will not have the desired effect. Note that it is still + * necessary to call png_read_row or png_read_rows png_get_image_height + * times for each pass. +*/ +PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +/* Invert monochrome files */ +PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_BACKGROUND_SUPPORTED +/* Handle alpha and tRNS by replacing with a background color. Prior to + * libpng-1.5.4 this API must not be called before the PNG file header has been + * read. Doing so will result in unexpected behavior and possible warnings or + * errors if the PNG file contains a bKGD chunk. + */ +PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, double background_gamma)) +PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structrp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, png_fixed_point background_gamma)) +#endif +#ifdef PNG_READ_BACKGROUND_SUPPORTED +# define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +# define PNG_BACKGROUND_GAMMA_SCREEN 1 +# define PNG_BACKGROUND_GAMMA_FILE 2 +# define PNG_BACKGROUND_GAMMA_UNIQUE 3 +#endif + +#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED +/* Scale a 16-bit depth file down to 8-bit, accurately. */ +PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED +#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */ +/* Strip the second byte of information from a 16-bit depth file. */ +PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_QUANTIZE_SUPPORTED +/* Turn on quantizing, and reduce the palette to the number of colors + * available. + */ +PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr, + png_colorp palette, int num_palette, int maximum_colors, + png_const_uint_16p histogram, int full_quantize)); +#endif + +#ifdef PNG_READ_GAMMA_SUPPORTED +/* The threshold on gamma processing is configurable but hard-wired into the + * library. The following is the floating point variant. + */ +#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001) + +/* Handle gamma correction. Screen_gamma=(display_exponent). + * NOTE: this API simply sets the screen and file gamma values. It will + * therefore override the value for gamma in a PNG file if it is called after + * the file header has been read - use with care - call before reading the PNG + * file for best results! + * + * These routines accept the same gamma values as png_set_alpha_mode (described + * above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either + * API (floating point or fixed.) Notice, however, that the 'file_gamma' value + * is the inverse of a 'screen gamma' value. + */ +PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr, + double screen_gamma, double override_file_gamma)) +PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structrp png_ptr, + png_fixed_point screen_gamma, png_fixed_point override_file_gamma)) +#endif + +#ifdef PNG_WRITE_FLUSH_SUPPORTED +/* Set how many lines between output flushes - 0 for no flushing */ +PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows)); +/* Flush the current PNG output buffer */ +PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr)); +#endif + +/* Optional update palette with requested transformations */ +PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr)); + +/* Optional call to update the users info structure */ +PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr, + png_inforp info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read one or more rows of image data. */ +PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row, + png_bytepp display_row, png_uint_32 num_rows)); +#endif + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read a row of data. */ +PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row, + png_bytep display_row)); +#endif + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the whole image into memory at once. */ +PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image)); +#endif + +/* Write a row of image data */ +PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr, + png_const_bytep row)); + +/* Write a few rows of image data: (*row) is not written; however, the type + * is declared as writeable to maintain compatibility with previous versions + * of libpng and to allow the 'display_row' array from read_rows to be passed + * unchanged to write_rows. + */ +PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row, + png_uint_32 num_rows)); + +/* Write the image data */ +PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image)); + +/* Write the end of the PNG file. */ +PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr, + png_inforp info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the end of the PNG file. */ +PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr)); +#endif + +/* Free any memory associated with the png_info_struct */ +PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr, + png_infopp info_ptr_ptr)); + +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); + +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr)); + +/* Set the libpng method of handling chunk CRC errors */ +PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action, + int ancil_action)); + +/* Values for png_set_crc_action() say how to handle CRC errors in + * ancillary and critical chunks, and whether to use the data contained + * therein. Note that it is impossible to "discard" data in a critical + * chunk. For versions prior to 0.90, the action was always error/quit, + * whereas in version 0.90 and later, the action for CRC errors in ancillary + * chunks is warn/discard. These values should NOT be changed. + * + * value action:critical action:ancillary + */ +#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ +#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ +#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ +#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ +#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ +#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ + +/* These functions give the user control over the scan-line filtering in + * libpng and the compression methods used by zlib. These functions are + * mainly useful for testing, as the defaults should work with most users. + * Those users who are tight on memory or want faster performance at the + * expense of compression can modify them. See the compression library + * header file (zlib.h) for an explination of the compression functions. + */ + +/* Set the filtering method(s) used by libpng. Currently, the only valid + * value for "method" is 0. + */ +PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method, + int filters)); + +/* Flags for png_set_filter() to say which filters to use. The flags + * are chosen so that they don't conflict with real filter types + * below, in case they are supplied instead of the #defined constants. + * These values should NOT be changed. + */ +#define PNG_NO_FILTERS 0x00 +#define PNG_FILTER_NONE 0x08 +#define PNG_FILTER_SUB 0x10 +#define PNG_FILTER_UP 0x20 +#define PNG_FILTER_AVG 0x40 +#define PNG_FILTER_PAETH 0x80 +#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ + PNG_FILTER_AVG | PNG_FILTER_PAETH) + +/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. + * These defines should NOT be changed. + */ +#define PNG_FILTER_VALUE_NONE 0 +#define PNG_FILTER_VALUE_SUB 1 +#define PNG_FILTER_VALUE_UP 2 +#define PNG_FILTER_VALUE_AVG 3 +#define PNG_FILTER_VALUE_PAETH 4 +#define PNG_FILTER_VALUE_LAST 5 + +#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* EXPERIMENTAL */ +/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ + * defines, either the default (minimum-sum-of-absolute-differences), or + * the experimental method (weighted-minimum-sum-of-absolute-differences). + * + * Weights are factors >= 1.0, indicating how important it is to keep the + * filter type consistent between rows. Larger numbers mean the current + * filter is that many times as likely to be the same as the "num_weights" + * previous filters. This is cumulative for each previous row with a weight. + * There needs to be "num_weights" values in "filter_weights", or it can be + * NULL if the weights aren't being specified. Weights have no influence on + * the selection of the first row filter. Well chosen weights can (in theory) + * improve the compression for a given image. + * + * Costs are factors >= 1.0 indicating the relative decoding costs of a + * filter type. Higher costs indicate more decoding expense, and are + * therefore less likely to be selected over a filter with lower computational + * costs. There needs to be a value in "filter_costs" for each valid filter + * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't + * setting the costs. Costs try to improve the speed of decompression without + * unduly increasing the compressed image size. + * + * A negative weight or cost indicates the default value is to be used, and + * values in the range [0.0, 1.0) indicate the value is to remain unchanged. + * The default values for both weights and costs are currently 1.0, but may + * change if good general weighting/cost heuristics can be found. If both + * the weights and costs are set to 1.0, this degenerates the WEIGHTED method + * to the UNWEIGHTED method, but with added encoding time/computation. + */ +PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr, + int heuristic_method, int num_weights, png_const_doublep filter_weights, + png_const_doublep filter_costs)) +PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed, + (png_structrp png_ptr, int heuristic_method, int num_weights, + png_const_fixed_point_p filter_weights, + png_const_fixed_point_p filter_costs)) +#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ + +/* Heuristic used for row filter selection. These defines should NOT be + * changed. + */ +#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ +#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ +#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ +#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ + +#ifdef PNG_WRITE_SUPPORTED +/* Set the library compression level. Currently, valid values range from + * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 + * (0 - no compression, 9 - "maximal" compression). Note that tests have + * shown that zlib compression levels 3-6 usually perform as well as level 9 + * for PNG images, and do considerably fewer caclulations. In the future, + * these values may not correspond directly to the zlib compression levels. + */ +PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr, + int level)); + +PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr, + int mem_level)); + +PNG_EXPORT(71, void, png_set_compression_strategy, (png_structrp png_ptr, + int strategy)); + +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr, + int window_bits)); + +PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr, + int method)); +#endif + +#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED +/* Also set zlib parameters for compressing non-IDAT chunks */ +PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr, + int level)); + +PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr, + int mem_level)); + +PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr, + int strategy)); + +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(225, void, png_set_text_compression_window_bits, + (png_structrp png_ptr, int window_bits)); + +PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr, + int method)); +#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ + +/* These next functions are called for input/output, memory, and error + * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, + * and call standard C I/O routines such as fread(), fwrite(), and + * fprintf(). These functions can be made to use other I/O routines + * at run time for those applications that need to handle I/O in a + * different manner by calling png_set_???_fn(). See libpng-manual.txt for + * more information. + */ + +#ifdef PNG_STDIO_SUPPORTED +/* Initialize the input/output for the PNG file to the default functions. */ +PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp)); +#endif + +/* Replace the (error and abort), and warning functions with user + * supplied functions. If no messages are to be printed you must still + * write and use replacement functions. The replacement error_fn should + * still do a longjmp to the last setjmp location if you are using this + * method of error handling. If error_fn or warning_fn is NULL, the + * default function will be used. + */ + +PNG_EXPORT(75, void, png_set_error_fn, (png_structrp png_ptr, + png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); + +/* Return the user pointer associated with the error functions */ +PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr)); + +/* Replace the default data output functions with a user supplied one(s). + * If buffered output is not used, then output_flush_fn can be set to NULL. + * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time + * output_flush_fn will be ignored (and thus can be NULL). + * It is probably a mistake to use NULL for output_flush_fn if + * write_data_fn is not also NULL unless you have built libpng with + * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's + * default flush function, which uses the standard *FILE structure, will + * be used. + */ +PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr, + png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); + +/* Replace the default data input function with a user supplied one. */ +PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr, + png_rw_ptr read_data_fn)); + +/* Return the user pointer associated with the I/O functions */ +PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr)); + +PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr, + png_read_status_ptr read_row_fn)); + +PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr, + png_write_status_ptr write_row_fn)); + +#ifdef PNG_USER_MEM_SUPPORTED +/* Replace the default memory allocation functions with user supplied one(s). */ +PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +/* Return the user pointer associated with the memory functions */ +PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr)); +#endif + +#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr, + png_user_transform_ptr read_user_transform_fn)); +#endif + +#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr, + png_user_transform_ptr write_user_transform_fn)); +#endif + +#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED +PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr, + png_voidp user_transform_ptr, int user_transform_depth, + int user_transform_channels)); +/* Return the user pointer associated with the user transform functions */ +PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr, + (png_const_structrp png_ptr)); +#endif + +#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED +/* Return information about the row currently being processed. Note that these + * APIs do not fail but will return unexpected results if called outside a user + * transform callback. Also note that when transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp)); +PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp)); +#endif + +#ifdef PNG_READ_USER_CHUNKS_SUPPORTED +/* This callback is called only for *unknown* chunks. If + * PNG_HANDLE_AS_UNKNOWN_SUPPORTED is set then it is possible to set known + * chunks to be treated as unknown, however in this case the callback must do + * any processing required by the chunk (e.g. by calling the appropriate + * png_set_ APIs.) + * + * There is no write support - on write, by default, all the chunks in the + * 'unknown' list are written in the specified position. + * + * The integer return from the callback function is interpreted thus: + * + * negative: An error occured, png_chunk_error will be called. + * zero: The chunk was not handled, the chunk will be saved. A critical + * chunk will cause an error at this point unless it is to be saved. + * positive: The chunk was handled, libpng will ignore/discard it. + * + * See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about + * how this behavior will change in libpng 1.7 + */ +PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr, + png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr)); +#endif + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +/* Sets the function callbacks for the push reader, and a pointer to a + * user-defined structure available to the callback functions. + */ +PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr, + png_voidp progressive_ptr, png_progressive_info_ptr info_fn, + png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)); + +/* Returns the user pointer associated with the push read functions */ +PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, + (png_const_structrp png_ptr)); + +/* Function to be called when data becomes available */ +PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr, + png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size)); + +/* A function which may be called *only* within png_process_data to stop the + * processing of any more data. The function returns the number of bytes + * remaining, excluding any that libpng has cached internally. A subsequent + * call to png_process_data must supply these bytes again. If the argument + * 'save' is set to true the routine will first save all the pending data and + * will always return 0. + */ +PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save)); + +/* A function which may be called *only* outside (after) a call to + * png_process_data. It returns the number of bytes of data to skip in the + * input. Normally it will return 0, but if it returns a non-zero value the + * application must skip than number of bytes of input data and pass the + * following data to the next call to png_process_data. + */ +PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp)); + +#ifdef PNG_READ_INTERLACING_SUPPORTED +/* Function that combines rows. 'new_row' is a flag that should come from + * the callback and be non-NULL if anything needs to be done; the library + * stores its own version of the new data internally and ignores the passed + * in value. + */ +PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr, + png_bytep old_row, png_const_bytep new_row)); +#endif /* PNG_READ_INTERLACING_SUPPORTED */ +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); +/* Added at libpng version 1.4.0 */ +PNG_EXPORTA(95, png_voidp, png_calloc, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); + +/* Added at libpng version 1.2.4 */ +PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); + +/* Frees a pointer allocated by png_malloc() */ +PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr)); + +/* Free data that was allocated internally */ +PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_32 free_me, int num)); + +/* Reassign responsibility for freeing existing data, whether allocated + * by libpng or by the application; this works on the png_info structure passed + * in, it does not change the state for other png_info structures. + * + * It is unlikely that this function works correctly as of 1.6.0 and using it + * may result either in memory leaks or double free of allocated data. + */ +PNG_EXPORTA(99, void, png_data_freer, (png_const_structrp png_ptr, + png_inforp info_ptr, int freer, png_uint_32 mask), PNG_DEPRECATED); + +/* 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 +#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_FREE_UNKN 0x0200 +#endif +/* PNG_FREE_LIST 0x0400 removed in 1.6.0 because it is ignored */ +#define PNG_FREE_PLTE 0x1000 +#define PNG_FREE_TRNS 0x2000 +#define PNG_FREE_TEXT 0x4000 +#define PNG_FREE_ALL 0x7fff +#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ + +#ifdef PNG_USER_MEM_SUPPORTED +PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED); +PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr, + png_voidp ptr), PNG_DEPRECATED); +#endif + +#ifdef PNG_ERROR_TEXT_SUPPORTED +/* Fatal error in PNG image of libpng - can't continue */ +PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr, + png_const_charp error_message), PNG_NORETURN); + +/* The same, but the chunk name is prepended to the error string. */ +PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr, + png_const_charp error_message), PNG_NORETURN); + +#else +/* Fatal error in PNG image of libpng - can't continue */ +PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN); +#endif + +#ifdef PNG_WARNINGS_SUPPORTED +/* Non-fatal error in libpng. Can continue, but may have a problem. */ +PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr, + png_const_charp warning_message)); + +/* Non-fatal error in libpng, chunk name is prepended to message. */ +PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr, + png_const_charp warning_message)); +#endif + +#ifdef PNG_BENIGN_ERRORS_SUPPORTED +/* Benign error in libpng. Can continue, but may have a problem. + * User can choose whether to handle as a fatal error or as a warning. */ +PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr, + png_const_charp warning_message)); + +#ifdef PNG_READ_SUPPORTED +/* Same, chunk name is prepended to message (only during read) */ +PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr, + png_const_charp warning_message)); +#endif + +PNG_EXPORT(109, void, png_set_benign_errors, + (png_structrp png_ptr, int allowed)); +#else +# ifdef PNG_ALLOW_BENIGN_ERRORS +# define png_benign_error png_warning +# define png_chunk_benign_error png_chunk_warning +# else +# define png_benign_error png_error +# define png_chunk_benign_error png_chunk_error +# endif +#endif + +/* The png_set_ functions are for storing values in the png_info_struct. + * Similarly, the png_get_ calls are used to read values from the + * png_info_struct, either storing the parameters in the passed variables, or + * setting pointers into the png_info_struct where the data is stored. The + * png_get_ functions return a non-zero value if the data was available + * in info_ptr, or return zero and do not change any of the parameters if the + * data was not available. + * + * These functions should be used instead of directly accessing png_info + * to avoid problems with future changes in the size and internal layout of + * png_info_struct. + */ +/* Returns "flag" if chunk data is valid in info_ptr. */ +PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 flag)); + +/* Returns number of bytes needed to hold a transformed row. */ +PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +#ifdef PNG_INFO_IMAGE_SUPPORTED +/* Returns row_pointers, which is an array of pointers to scanlines that was + * returned from png_read_png(). + */ +PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Set row_pointers, which is an array of pointers to scanlines for use + * by png_write_png(). + */ +PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr, + png_inforp info_ptr, png_bytepp row_pointers)); +#endif + +/* Returns number of color channels in image. */ +PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +#ifdef PNG_EASY_ACCESS_SUPPORTED +/* Returns image width in pixels. */ +PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image height in pixels. */ +PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image bit_depth. */ +PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image color_type. */ +PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image filter_type. */ +PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image interlace_type. */ +PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image compression_type. */ +PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image resolution in pixels per meter, from pHYs chunk data. */ +PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +/* Returns pixel aspect ratio, computed from pHYs chunk data. */ +PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) + +/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(128, png_int_32, png_get_x_offset_microns, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +#endif /* PNG_EASY_ACCESS_SUPPORTED */ + +#ifdef PNG_READ_SUPPORTED +/* Returns pointer to signature string read from PNG header */ +PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); +#endif + +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr, + png_inforp info_ptr, png_color_16p *background)); +#endif + +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_color_16p background)); +#endif + +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structrp png_ptr, + png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x, + double *red_y, double *green_x, double *green_y, double *blue_x, + double *blue_y)) +PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_const_structrp png_ptr, + png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z, + double *green_X, double *green_Y, double *green_Z, double *blue_X, + double *blue_Y, double *blue_Z)) +PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, + png_fixed_point *int_white_x, png_fixed_point *int_white_y, + png_fixed_point *int_red_x, png_fixed_point *int_red_y, + png_fixed_point *int_green_x, png_fixed_point *int_green_y, + png_fixed_point *int_blue_x, png_fixed_point *int_blue_y)) +PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, + png_fixed_point *int_red_X, png_fixed_point *int_red_Y, + png_fixed_point *int_red_Z, png_fixed_point *int_green_X, + png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, + png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, + png_fixed_point *int_blue_Z)) +#endif + +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr, + png_inforp info_ptr, + double white_x, double white_y, double red_x, double red_y, double green_x, + double green_y, double blue_x, double blue_y)) +PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_const_structrp png_ptr, + png_inforp info_ptr, double red_X, double red_Y, double red_Z, + double green_X, double green_Y, double green_Z, double blue_X, + double blue_Y, double blue_Z)) +PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, png_fixed_point int_white_x, + png_fixed_point int_white_y, png_fixed_point int_red_x, + png_fixed_point int_red_y, png_fixed_point int_green_x, + png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)) +PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, + png_fixed_point int_red_Z, png_fixed_point int_green_X, + png_fixed_point int_green_Y, png_fixed_point int_green_Z, + png_fixed_point int_blue_X, png_fixed_point int_blue_Y, + png_fixed_point int_blue_Z)) +#endif + +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, (png_const_structrp png_ptr, + png_const_inforp info_ptr, double *file_gamma)) +PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, + png_fixed_point *int_file_gamma)) +#endif + +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr, + png_inforp info_ptr, double file_gamma)) +PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, png_fixed_point int_file_gamma)) +#endif + +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_16p *hist)); +#endif + +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_uint_16p hist)); +#endif + +PNG_EXPORT(143, png_uint_32, png_get_IHDR, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height, + int *bit_depth, int *color_type, int *interlace_method, + int *compression_method, int *filter_method)); + +PNG_EXPORT(144, void, png_set_IHDR, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, + int color_type, int interlace_method, int compression_method, + int filter_method)); + +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, + int *unit_type)); +#endif + +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr, + png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y, + int unit_type)); +#endif + +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr, + png_inforp info_ptr, png_charp *purpose, png_int_32 *X0, + png_int_32 *X1, int *type, int *nparams, png_charp *units, + png_charpp *params)); +#endif + +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1, + int type, int nparams, png_const_charp units, png_charpp params)); +#endif + +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, + int *unit_type)); +#endif + +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +#endif + +PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr, + png_inforp info_ptr, png_colorp *palette, int *num_palette)); + +PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr, + png_inforp info_ptr, png_const_colorp palette, int num_palette)); + +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_color_8p *sig_bit)); +#endif + +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_color_8p sig_bit)); +#endif + +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr, + png_const_inforp info_ptr, int *file_srgb_intent)); +#endif + +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr, + png_inforp info_ptr, int srgb_intent)); +PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr, + png_inforp info_ptr, int srgb_intent)); +#endif + +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr, + png_inforp info_ptr, png_charpp name, int *compression_type, + png_bytepp profile, png_uint_32 *proflen)); +#endif + +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_charp name, int compression_type, + png_const_bytep profile, png_uint_32 proflen)); +#endif + +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_sPLT_tpp entries)); +#endif + +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_sPLT_tp entries, int nentries)); +#endif + +#ifdef PNG_TEXT_SUPPORTED +/* png_get_text also returns the number of text chunks in *num_text */ +PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr, + png_inforp info_ptr, png_textp *text_ptr, int *num_text)); +#endif + +/* Note while png_set_text() will accept a structure whose text, + * language, and translated keywords are NULL pointers, the structure + * returned by png_get_text will always contain regular + * zero-terminated C strings. They might be empty strings but + * they will never be NULL pointers. + */ + +#ifdef PNG_TEXT_SUPPORTED +PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_textp text_ptr, int num_text)); +#endif + +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr, + png_inforp info_ptr, png_timep *mod_time)); +#endif + +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_timep mod_time)); +#endif + +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr, + png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans, + png_color_16p *trans_color)); +#endif + +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr, + png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans, + png_const_color_16p trans_color)); +#endif + +#ifdef PNG_sCAL_SUPPORTED +PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr, + png_const_inforp info_ptr, int *unit, double *width, double *height)) +#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \ + defined(PNG_FLOATING_POINT_SUPPORTED) +/* NOTE: this API is currently implemented using floating point arithmetic, + * consequently it can only be used on systems with floating point support. + * In any case the range of values supported by png_fixed_point is small and it + * is highly recommended that png_get_sCAL_s be used instead. + */ +PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, + png_fixed_point *width, png_fixed_point *height)) +#endif +PNG_EXPORT(169, png_uint_32, png_get_sCAL_s, + (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, + png_charpp swidth, png_charpp sheight)); + +PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr, + png_inforp info_ptr, int unit, double width, double height)) +PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, int unit, png_fixed_point width, + png_fixed_point height)) +PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr, + png_inforp info_ptr, int unit, + png_const_charp swidth, png_const_charp sheight)); +#endif /* PNG_sCAL_SUPPORTED */ + +#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED +/* Provide the default handling for all unknown chunks or, optionally, for + * specific unknown chunks. + * + * NOTE: prior to 1.6.0 the handling specified for particular chunks on read was + * ignored and the default was used, the per-chunk setting only had an effect on + * write. If you wish to have chunk-specific handling on read in code that must + * work on earlier versions you must use a user chunk callback to specify the + * desired handling (keep or discard.) + * + * The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below. The + * parameter is interpreted as follows: + * + * READ: + * PNG_HANDLE_CHUNK_AS_DEFAULT: + * Known chunks: do normal libpng processing, do not keep the chunk (but + * see the comments below about PNG_HANDLE_AS_UNKNOWN_SUPPORTED) + * Unknown chunks: for a specific chunk use the global default, when used + * as the default discard the chunk data. + * PNG_HANDLE_CHUNK_NEVER: + * Discard the chunk data. + * PNG_HANDLE_CHUNK_IF_SAFE: + * Keep the chunk data if the chunk is not critical else raise a chunk + * error. + * PNG_HANDLE_CHUNK_ALWAYS: + * Keep the chunk data. + * + * If the chunk data is saved it can be retrieved using png_get_unknown_chunks, + * below. Notice that specifying "AS_DEFAULT" as a global default is equivalent + * to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks + * it simply resets the behavior to the libpng default. + * + * INTERACTION WTIH USER CHUNK CALLBACKS: + * The per-chunk handling is always used when there is a png_user_chunk_ptr + * callback and the callback returns 0; the chunk is then always stored *unless* + * it is critical and the per-chunk setting is other than ALWAYS. Notice that + * the global default is *not* used in this case. (In effect the per-chunk + * value is incremented to at least IF_SAFE.) + * + * IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and + * per-chunk defaults will be honored. If you want to preserve the current + * behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE + * as the default - if you don't do this libpng 1.6 will issue a warning. + * + * If you want unhandled unknown chunks to be discarded in libpng 1.6 and + * earlier simply return '1' (handled). + * + * PNG_HANDLE_AS_UNKNOWN_SUPPORTED: + * If this is *not* set known chunks will always be handled by libpng and + * will never be stored in the unknown chunk list. Known chunks listed to + * png_set_keep_unknown_chunks will have no effect. If it is set then known + * chunks listed with a keep other than AS_DEFAULT will *never* be processed + * by libpng, in addition critical chunks must either be processed by the + * callback or saved. + * + * The IHDR and IEND chunks must not be listed. Because this turns off the + * default handling for chunks that would otherwise be recognized the + * behavior of libpng transformations may well become incorrect! + * + * WRITE: + * When writing chunks the options only apply to the chunks specified by + * png_set_unknown_chunks (below), libpng will *always* write known chunks + * required by png_set_ calls and will always write the core critical chunks + * (as required for PLTE). + * + * Each chunk in the png_set_unknown_chunks list is looked up in the + * png_set_keep_unknown_chunks list to find the keep setting, this is then + * interpreted as follows: + * + * PNG_HANDLE_CHUNK_AS_DEFAULT: + * Write safe-to-copy chunks and write other chunks if the global + * default is set to _ALWAYS, otherwise don't write this chunk. + * PNG_HANDLE_CHUNK_NEVER: + * Do not write the chunk. + * PNG_HANDLE_CHUNK_IF_SAFE: + * Write the chunk if it is safe-to-copy, otherwise do not write it. + * PNG_HANDLE_CHUNK_ALWAYS: + * Write the chunk. + * + * Note that the default behavior is effectively the opposite of the read case - + * in read unknown chunks are not stored by default, in write they are written + * by default. Also the behavior of PNG_HANDLE_CHUNK_IF_SAFE is very different + * - on write the safe-to-copy bit is checked, on read the critical bit is + * checked and on read if the chunk is critical an error will be raised. + * + * num_chunks: + * =========== + * If num_chunks is positive, then the "keep" parameter specifies the manner + * for handling only those chunks appearing in the chunk_list array, + * otherwise the chunk list array is ignored. + * + * If num_chunks is 0 the "keep" parameter specifies the default behavior for + * unknown chunks, as described above. + * + * If num_chunks is negative, then the "keep" parameter specifies the manner + * for handling all unknown chunks plus all chunks recognized by libpng + * except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to + * be processed by libpng. + */ +PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr, + int keep, png_const_bytep chunk_list, int num_chunks)); + +/* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned; + * the result is therefore true (non-zero) if special handling is required, + * false for the default handling. + */ +PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr, + png_const_bytep chunk_name)); +#endif + +#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED +PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_unknown_chunkp unknowns, + int num_unknowns)); + /* NOTE: prior to 1.6.0 this routine set the 'location' field of the added + * unknowns to the location currently stored in the png_struct. This is + * invariably the wrong value on write. To fix this call the following API + * for each chunk in the list with the correct location. If you know your + * code won't be compiled on earlier versions you can rely on + * png_set_unknown_chunks(write-ptr, png_get_unknown_chunks(read-ptr)) doing + * the correct thing. + */ + +PNG_EXPORT(175, void, png_set_unknown_chunk_location, + (png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location)); + +PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structrp png_ptr, + png_inforp info_ptr, png_unknown_chunkpp entries)); +#endif + +/* Png_free_data() will turn off the "valid" flag for anything it frees. + * If you need to turn it off for a chunk that your application has freed, + * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); + */ +PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr, + png_inforp info_ptr, int mask)); + +#ifdef PNG_INFO_IMAGE_SUPPORTED +/* The "params" pointer is currently not used and is for future expansion. */ +PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr, + int transforms, png_voidp params)); +PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr, + int transforms, png_voidp params)); +#endif + +PNG_EXPORT(180, png_const_charp, png_get_copyright, + (png_const_structrp png_ptr)); +PNG_EXPORT(181, png_const_charp, png_get_header_ver, + (png_const_structrp png_ptr)); +PNG_EXPORT(182, png_const_charp, png_get_header_version, + (png_const_structrp png_ptr)); +PNG_EXPORT(183, png_const_charp, png_get_libpng_ver, + (png_const_structrp png_ptr)); + +#ifdef PNG_MNG_FEATURES_SUPPORTED +PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr, + png_uint_32 mng_features_permitted)); +#endif + +/* For use in png_set_keep_unknown, added to version 1.2.6 */ +#define PNG_HANDLE_CHUNK_AS_DEFAULT 0 +#define PNG_HANDLE_CHUNK_NEVER 1 +#define PNG_HANDLE_CHUNK_IF_SAFE 2 +#define PNG_HANDLE_CHUNK_ALWAYS 3 +#define PNG_HANDLE_CHUNK_LAST 4 + +/* Strip the prepended error numbers ("#nnn ") from error and warning + * messages before passing them to the error or warning handler. + */ +#ifdef PNG_ERROR_NUMBERS_SUPPORTED +PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr, + png_uint_32 strip_mode)); +#endif + +/* Added in libpng-1.2.6 */ +#ifdef PNG_SET_USER_LIMITS_SUPPORTED +PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr, + png_uint_32 user_width_max, png_uint_32 user_height_max)); +PNG_EXPORT(187, png_uint_32, png_get_user_width_max, + (png_const_structrp png_ptr)); +PNG_EXPORT(188, png_uint_32, png_get_user_height_max, + (png_const_structrp png_ptr)); +/* Added in libpng-1.4.0 */ +PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr, + png_uint_32 user_chunk_cache_max)); +PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max, + (png_const_structrp png_ptr)); +/* Added in libpng-1.4.1 */ +PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr, + png_alloc_size_t user_chunk_cache_max)); +PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max, + (png_const_structrp png_ptr)); +#endif + +#if defined(PNG_INCH_CONVERSIONS_SUPPORTED) +PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +PNG_FP_EXPORT(196, float, png_get_x_offset_inches, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +#endif + +PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structrp png_ptr, + png_const_inforp info_ptr)) +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +#endif + +# ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, + int *unit_type)); +# endif /* PNG_pHYs_SUPPORTED */ +#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ + +/* Added in libpng-1.4.0 */ +#ifdef PNG_IO_STATE_SUPPORTED +PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr)); + +/* Removed from libpng 1.6; use png_get_io_chunk_type. */ +PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr), + PNG_DEPRECATED) + +PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type, + (png_const_structrp png_ptr)); + +/* The flags returned by png_get_io_state() are the following: */ +# define PNG_IO_NONE 0x0000 /* no I/O at this moment */ +# define PNG_IO_READING 0x0001 /* currently reading */ +# define PNG_IO_WRITING 0x0002 /* currently writing */ +# define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */ +# define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */ +# define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */ +# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ +# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ +# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ +#endif /* ?PNG_IO_STATE_SUPPORTED */ + +/* Interlace support. The following macros are always defined so that if + * libpng interlace handling is turned off the macros may be used to handle + * interlaced images within the application. + */ +#define PNG_INTERLACE_ADAM7_PASSES 7 + +/* Two macros to return the first row and first column of the original, + * full, image which appears in a given pass. 'pass' is in the range 0 + * to 6 and the result is in the range 0 to 7. + */ +#define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7) +#define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7) + +/* A macro to return the offset between pixels in the output row for a pair of + * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that + * follows. Note that ROW_OFFSET is the offset from one row to the next whereas + * COL_OFFSET is from one column to the next, within a row. + */ +#define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8) +#define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1)) + +/* Two macros to help evaluate the number of rows or columns in each + * pass. This is expressed as a shift - effectively log2 of the number or + * rows or columns in each 8x8 tile of the original image. + */ +#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3) +#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3) + +/* Hence two macros to determine the number of rows or columns in a given + * pass of an image given its height or width. In fact these macros may + * return non-zero even though the sub-image is empty, because the other + * dimension may be empty for a small image. + */ +#define PNG_PASS_ROWS(height, pass) (((height)+(((1<>PNG_PASS_ROW_SHIFT(pass)) +#define PNG_PASS_COLS(width, pass) (((width)+(((1<>PNG_PASS_COL_SHIFT(pass)) + +/* For the reader row callbacks (both progressive and sequential) it is + * necessary to find the row in the output image given a row in an interlaced + * image, so two more macros: + */ +#define PNG_ROW_FROM_PASS_ROW(y_in, pass) \ + (((y_in)<>(((7-(off))-(pass))<<2)) & 0xF) | \ + ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0)) + +#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \ + ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1) +#define PNG_COL_IN_INTERLACE_PASS(x, pass) \ + ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1) + +#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED +/* With these routines we avoid an integer divide, which will be slower on + * most machines. However, it does take more operations than the corresponding + * divide method, so it may be slower on a few RISC systems. There are two + * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. + * + * Note that the rounding factors are NOT supposed to be the same! 128 and + * 32768 are correct for the NODIV code; 127 and 32767 are correct for the + * standard method. + * + * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] + */ + + /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ + +# define png_composite(composite, fg, alpha, bg) \ + { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \ + * (png_uint_16)(alpha) \ + + (png_uint_16)(bg)*(png_uint_16)(255 \ + - (png_uint_16)(alpha)) + 128); \ + (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } + +# define png_composite_16(composite, fg, alpha, bg) \ + { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \ + * (png_uint_32)(alpha) \ + + (png_uint_32)(bg)*(65535 \ + - (png_uint_32)(alpha)) + 32768); \ + (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } + +#else /* Standard method using integer division */ + +# define png_composite(composite, fg, alpha, bg) \ + (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ + (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ + 127) / 255) + +# define png_composite_16(composite, fg, alpha, bg) \ + (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ + (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ + 32767) / 65535) +#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ + +#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf)); +PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf)); +PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf)); +#endif + +PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr, + png_const_bytep buf)); +/* No png_get_int_16 -- may be added if there's a real need for it. */ + +/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */ +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i)); +#endif +#ifdef PNG_SAVE_INT_32_SUPPORTED +PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i)); +#endif + +/* Place a 16-bit number into a buffer in PNG byte order. + * The parameter is declared unsigned int, not png_uint_16, + * just to avoid potential problems on pre-ANSI C compilers. + */ +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i)); +/* No png_save_int_16 -- may be added if there's a real need for it. */ +#endif + +#ifdef PNG_USE_READ_MACROS +/* Inline macros to do direct reads of bytes from the input buffer. + * The png_get_int_32() routine assumes we are using two's complement + * format for negative values, which is almost certainly true. + */ +# define PNG_get_uint_32(buf) \ + (((png_uint_32)(*(buf)) << 24) + \ + ((png_uint_32)(*((buf) + 1)) << 16) + \ + ((png_uint_32)(*((buf) + 2)) << 8) + \ + ((png_uint_32)(*((buf) + 3)))) + + /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the + * function) incorrectly returned a value of type png_uint_32. + */ +# define PNG_get_uint_16(buf) \ + ((png_uint_16) \ + (((unsigned int)(*(buf)) << 8) + \ + ((unsigned int)(*((buf) + 1))))) + +# define PNG_get_int_32(buf) \ + ((png_int_32)((*(buf) & 0x80) \ + ? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \ + : (png_int_32)png_get_uint_32(buf))) + + /* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h, + * but defining a macro name prefixed with PNG_PREFIX. + */ +# ifndef PNG_PREFIX +# define png_get_uint_32(buf) PNG_get_uint_32(buf) +# define png_get_uint_16(buf) PNG_get_uint_16(buf) +# define png_get_int_32(buf) PNG_get_int_32(buf) +# endif +#else +# ifdef PNG_PREFIX + /* No macros; revert to the (redefined) function */ +# define PNG_get_uint_32 (png_get_uint_32) +# define PNG_get_uint_16 (png_get_uint_16) +# define PNG_get_int_32 (png_get_int_32) +# endif +#endif + +/******************************************************************************* + * SIMPLIFIED API + ******************************************************************************* + * + * Please read the documentation in libpng-manual.txt (TODO: write said + * documentation) if you don't understand what follows. + * + * The simplified API hides the details of both libpng and the PNG file format + * itself. It allows PNG files to be read into a very limited number of + * in-memory bitmap formats or to be written from the same formats. If these + * formats do not accomodate your needs then you can, and should, use the more + * sophisticated APIs above - these support a wide variety of in-memory formats + * and a wide variety of sophisticated transformations to those formats as well + * as a wide variety of APIs to manipulate ancillary information. + * + * To read a PNG file using the simplified API: + * + * 1) Declare a 'png_image' structure (see below) on the stack and set the + * version field to PNG_IMAGE_VERSION. + * 2) Call the appropriate png_image_begin_read... function. + * 3) Set the png_image 'format' member to the required sample format. + * 4) Allocate a buffer for the image and, if required, the color-map. + * 5) Call png_image_finish_read to read the image and, if required, the + * color-map into your buffers. + * + * There are no restrictions on the format of the PNG input itself; all valid + * color types, bit depths, and interlace methods are acceptable, and the + * input image is transformed as necessary to the requested in-memory format + * during the png_image_finish_read() step. The only caveat is that if you + * request a color-mapped image from a PNG that is full-color or makes + * complex use of an alpha channel the transformation is extremely lossy and the + * result may look terrible. + * + * To write a PNG file using the simplified API: + * + * 1) Declare a 'png_image' structure on the stack and memset() it to all zero. + * 2) Initialize the members of the structure that describe the image, setting + * the 'format' member to the format of the image samples. + * 3) Call the appropriate png_image_write... function with a pointer to the + * image and, if necessary, the color-map to write the PNG data. + * + * png_image is a structure that describes the in-memory format of an image + * when it is being read or defines the in-memory format of an image that you + * need to write: + */ +#define PNG_IMAGE_VERSION 1 + +typedef struct png_control *png_controlp; +typedef struct +{ + png_controlp opaque; /* Initialize to NULL, free with png_image_free */ + png_uint_32 version; /* Set to PNG_IMAGE_VERSION */ + png_uint_32 width; /* Image width in pixels (columns) */ + png_uint_32 height; /* Image height in pixels (rows) */ + png_uint_32 format; /* Image format as defined below */ + png_uint_32 flags; /* A bit mask containing informational flags */ + png_uint_32 colormap_entries; + /* Number of entries in the color-map */ + + /* In the event of an error or warning the following field will be set to a + * non-zero value and the 'message' field will contain a '\0' terminated + * string with the libpng error or warning message. If both warnings and + * an error were encountered, only the error is recorded. If there + * are multiple warnings, only the first one is recorded. + * + * The upper 30 bits of this value are reserved, the low two bits contain + * a value as follows: + */ +# define PNG_IMAGE_WARNING 1 +# define PNG_IMAGE_ERROR 2 + /* + * The result is a two bit code such that a value more than 1 indicates + * a failure in the API just called: + * + * 0 - no warning or error + * 1 - warning + * 2 - error + * 3 - error preceded by warning + */ +# define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1) + + png_uint_32 warning_or_error; + + char message[64]; +} png_image, *png_imagep; + +/* The samples of the image have one to four channels whose components have + * original values in the range 0 to 1.0: + * + * 1: A single gray or luminance channel (G). + * 2: A gray/luminance channel and an alpha channel (GA). + * 3: Three red, green, blue color channels (RGB). + * 4: Three color channels and an alpha channel (RGBA). + * + * The components are encoded in one of two ways: + * + * a) As a small integer, value 0..255, contained in a single byte. For the + * alpha channel the original value is simply value/255. For the color or + * luminance channels the value is encoded according to the sRGB specification + * and matches the 8-bit format expected by typical display devices. + * + * The color/gray channels are not scaled (pre-multiplied) by the alpha + * channel and are suitable for passing to color management software. + * + * b) As a value in the range 0..65535, contained in a 2-byte integer. All + * channels can be converted to the original value by dividing by 65535; all + * channels are linear. Color channels use the RGB encoding (RGB end-points) of + * the sRGB specification. This encoding is identified by the + * PNG_FORMAT_FLAG_LINEAR flag below. + * + * When the simplified API needs to convert between sRGB and linear colorspaces, + * the actual sRGB transfer curve defined in the sRGB specification (see the + * article at http://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2 + * approximation used elsewhere in libpng. + * + * When an alpha channel is present it is expected to denote pixel coverage + * of the color or luminance channels and is returned as an associated alpha + * channel: the color/gray channels are scaled (pre-multiplied) by the alpha + * value. + * + * The samples are either contained directly in the image data, between 1 and 8 + * bytes per pixel according to the encoding, or are held in a color-map indexed + * by bytes in the image data. In the case of a color-map the color-map entries + * are individual samples, encoded as above, and the image data has one byte per + * pixel to select the relevant sample from the color-map. + */ + +/* PNG_FORMAT_* + * + * #defines to be used in png_image::format. Each #define identifies a + * particular layout of sample data and, if present, alpha values. There are + * separate defines for each of the two component encodings. + * + * A format is built up using single bit flag values. All combinations are + * valid. Formats can be built up from the flag values or you can use one of + * the predefined values below. When testing formats always use the FORMAT_FLAG + * macros to test for individual features - future versions of the library may + * add new flags. + * + * When reading or writing color-mapped images the format should be set to the + * format of the entries in the color-map then png_image_{read,write}_colormap + * called to read or write the color-map and set the format correctly for the + * image data. Do not set the PNG_FORMAT_FLAG_COLORMAP bit directly! + * + * NOTE: libpng can be built with particular features disabled, if you see + * compiler errors because the definition of one of the following flags has been + * compiled out it is because libpng does not have the required support. It is + * possible, however, for the libpng configuration to enable the format on just + * read or just write; in that case you may see an error at run time. You can + * guard against this by checking for the definition of the appropriate + * "_SUPPORTED" macro, one of: + * + * PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED + */ +#define PNG_FORMAT_FLAG_ALPHA 0x01U /* format with an alpha channel */ +#define PNG_FORMAT_FLAG_COLOR 0x02U /* color format: otherwise grayscale */ +#define PNG_FORMAT_FLAG_LINEAR 0x04U /* 2 byte channels else 1 byte */ +#define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */ + +#ifdef PNG_FORMAT_BGR_SUPPORTED +# define PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */ +#endif + +#ifdef PNG_FORMAT_AFIRST_SUPPORTED +# define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */ +#endif + +/* Commonly used formats have predefined macros. + * + * First the single byte (sRGB) formats: + */ +#define PNG_FORMAT_GRAY 0 +#define PNG_FORMAT_GA PNG_FORMAT_FLAG_ALPHA +#define PNG_FORMAT_AG (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST) +#define PNG_FORMAT_RGB PNG_FORMAT_FLAG_COLOR +#define PNG_FORMAT_BGR (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR) +#define PNG_FORMAT_RGBA (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA) +#define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST) +#define PNG_FORMAT_BGRA (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA) +#define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST) + +/* Then the linear 2-byte formats. When naming these "Y" is used to + * indicate a luminance (gray) channel. + */ +#define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR +#define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA) +#define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR) +#define PNG_FORMAT_LINEAR_RGB_ALPHA \ + (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA) + +/* With color-mapped formats the image data is one byte for each pixel, the byte + * is an index into the color-map which is formatted as above. To obtain a + * color-mapped format it is sufficient just to add the PNG_FOMAT_FLAG_COLORMAP + * to one of the above definitions, or you can use one of the definitions below. + */ +#define PNG_FORMAT_RGB_COLORMAP (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_BGR_COLORMAP (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP) + +/* PNG_IMAGE macros + * + * These are convenience macros to derive information from a png_image + * structure. The PNG_IMAGE_SAMPLE_ macros return values appropriate to the + * actual image sample values - either the entries in the color-map or the + * pixels in the image. The PNG_IMAGE_PIXEL_ macros return corresponding values + * for the pixels and will always return 1 for color-mapped formats. The + * remaining macros return information about the rows in the image and the + * complete image. + * + * NOTE: All the macros that take a png_image::format parameter are compile time + * constants if the format parameter is, itself, a constant. Therefore these + * macros can be used in array declarations and case labels where required. + * Similarly the macros are also pre-processor constants (sizeof is not used) so + * they can be used in #if tests. + * + * First the information about the samples. + */ +#define PNG_IMAGE_SAMPLE_CHANNELS(fmt)\ + (((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1) + /* Return the total number of channels in a given format: 1..4 */ + +#define PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)\ + ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1) + /* Return the size in bytes of a single component of a pixel or color-map + * entry (as appropriate) in the image: 1 or 2. + */ + +#define PNG_IMAGE_SAMPLE_SIZE(fmt)\ + (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)) + /* This is the size of the sample data for one sample. If the image is + * color-mapped it is the size of one color-map entry (and image pixels are + * one byte in size), otherwise it is the size of one image pixel. + */ + +#define PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt)\ + (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256) + /* The maximum size of the color-map required by the format expressed in a + * count of components. This can be used to compile-time allocate a + * color-map: + * + * png_uint_16 colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(linear_fmt)]; + * + * png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)]; + * + * Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro below to use the + * information from one of the png_image_begin_read_ APIs and dynamically + * allocate the required memory. + */ + +/* Corresponding information about the pixels */ +#define PNG_IMAGE_PIXEL_(test,fmt)\ + (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt)) + +#define PNG_IMAGE_PIXEL_CHANNELS(fmt)\ + PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt) + /* The number of separate channels (components) in a pixel; 1 for a + * color-mapped image. + */ + +#define PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)\ + PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt) + /* The size, in bytes, of each component in a pixel; 1 for a color-mapped + * image. + */ + +#define PNG_IMAGE_PIXEL_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt) + /* The size, in bytes, of a complete pixel; 1 for a color-mapped image. */ + +/* Information about the whole row, or whole image */ +#define PNG_IMAGE_ROW_STRIDE(image)\ + (PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width) + /* Return the total number of components in a single row of the image; this + * is the minimum 'row stride', the minimum count of components between each + * row. For a color-mapped image this is the minimum number of bytes in a + * row. + */ + +#define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\ + (PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride)) + /* Return the size, in bytes, of an image buffer given a png_image and a row + * stride - the number of components to leave space for in each row. + */ + +#define PNG_IMAGE_SIZE(image)\ + PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image)) + /* Return the size, in bytes, of the image in memory given just a png_image; + * the row stride is the minimum stride required for the image. + */ + +#define PNG_IMAGE_COLORMAP_SIZE(image)\ + (PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries) + /* Return the size, in bytes, of the color-map of this image. If the image + * format is not a color-map format this will return a size sufficient for + * 256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if + * you don't want to allocate a color-map in this case. + */ + +/* PNG_IMAGE_FLAG_* + * + * Flags containing additional information about the image are held in the + * 'flags' field of png_image. + */ +#define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01 + /* This indicates the the RGB values of the in-memory bitmap do not + * correspond to the red, green and blue end-points defined by sRGB. + */ + +#define PNG_IMAGE_FLAG_FAST 0x02 + /* On write emphasise speed over compression; the resultant PNG file will be + * larger but will be produced significantly faster, particular for large + * images. Do not use this option for images which will be distributed, only + * used it when producing intermediate files that will be read back in + * repeatedly. For a typical 24-bit image the option will double the read + * speed at the cost of increasing the image size by 25%, however for many + * more compressible images the PNG file can be 10 times larger with only a + * slight speed gain. + */ + +#define PNG_IMAGE_FLAG_16BIT_sRGB 0x04 + /* On read if the image is a 16-bit per component image and there is no gAMA + * or sRGB chunk assume that the components are sRGB encoded. Notice that + * images output by the simplified API always have gamma information; setting + * this flag only affects the interpretation of 16-bit images from an + * external source. It is recommended that the application expose this flag + * to the user; the user can normally easily recognize the difference between + * linear and sRGB encoding. This flag has no effect on write - the data + * passed to the write APIs must have the correct encoding (as defined + * above.) + * + * If the flag is not set (the default) input 16-bit per component data is + * assumed to be linear. + * + * NOTE: the flag can only be set after the png_image_begin_read_ call, + * because that call initializes the 'flags' field. + */ + +#ifdef PNG_SIMPLIFIED_READ_SUPPORTED +/* READ APIs + * --------- + * + * The png_image passed to the read APIs must have been initialized by setting + * the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.) + */ +#ifdef PNG_STDIO_SUPPORTED +PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image, + const char *file_name)); + /* The named file is opened for read and the image header is filled in + * from the PNG header in the file. + */ + +PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image, + FILE* file)); + /* The PNG header is read from the stdio FILE object. */ +#endif /* PNG_STDIO_SUPPORTED */ + +PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image, + png_const_voidp memory, png_size_t size)); + /* The PNG header is read from the given memory buffer. */ + +PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image, + png_const_colorp background, void *buffer, png_int_32 row_stride, + void *colormap)); + /* Finish reading the image into the supplied buffer and clean up the + * png_image structure. + * + * row_stride is the step, in byte or 2-byte units as appropriate, + * between adjacent rows. A positive stride indicates that the top-most row + * is first in the buffer - the normal top-down arrangement. A negative + * stride indicates that the bottom-most row is first in the buffer. + * + * background need only be supplied if an alpha channel must be removed from + * a png_byte format and the removal is to be done by compositing on a solid + * color; otherwise it may be NULL and any composition will be done directly + * onto the buffer. The value is an sRGB color to use for the background, + * for grayscale output the green channel is used. + * + * background must be supplied when an alpha channel must be removed from a + * single byte color-mapped output format, in other words if: + * + * 1) The original format from png_image_begin_read_from_* had + * PNG_FORMAT_FLAG_ALPHA set. + * 2) The format set by the application does not. + * 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and + * PNG_FORMAT_FLAG_LINEAR *not* set. + * + * For linear output removing the alpha channel is always done by compositing + * on black and background is ignored. + * + * colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set. It must + * be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE. + * image->colormap_entries will be updated to the actual number of entries + * written to the colormap; this may be less than the original value. + */ + +PNG_EXPORT(238, void, png_image_free, (png_imagep image)); + /* Free any data allocated by libpng in image->opaque, setting the pointer to + * NULL. May be called at any time after the structure is initialized. + */ +#endif /* PNG_SIMPLIFIED_READ_SUPPORTED */ + +#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED +#ifdef PNG_STDIO_SUPPORTED +/* WRITE APIS + * ---------- + * For write you must initialize a png_image structure to describe the image to + * be written. To do this use memset to set the whole structure to 0 then + * initialize fields describing your image. + * + * version: must be set to PNG_IMAGE_VERSION + * opaque: must be initialized to NULL + * width: image width in pixels + * height: image height in rows + * format: the format of the data (image and color-map) you wish to write + * flags: set to 0 unless one of the defined flags applies; set + * PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB for color format images where the RGB + * values do not correspond to the colors in sRGB. + * colormap_entries: set to the number of entries in the color-map (0 to 256) + */ +PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image, + const char *file, int convert_to_8bit, const void *buffer, + png_int_32 row_stride, const void *colormap)); + /* Write the image to the named file. */ + +PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file, + int convert_to_8_bit, const void *buffer, png_int_32 row_stride, + const void *colormap)); + /* Write the image to the given (FILE*). */ + +/* With both write APIs if image is in one of the linear formats with 16-bit + * data then setting convert_to_8_bit will cause the output to be an 8-bit PNG + * gamma encoded according to the sRGB specification, otherwise a 16-bit linear + * encoded PNG file is written. + * + * With color-mapped data formats the colormap parameter point to a color-map + * with at least image->colormap_entries encoded in the specified format. If + * the format is linear the written PNG color-map will be converted to sRGB + * regardless of the convert_to_8_bit flag. + * + * With all APIs row_stride is handled as in the read APIs - it is the spacing + * from one row to the next in component sized units (1 or 2 bytes) and if + * negative indicates a bottom-up row layout in the buffer. + * + * Note that the write API does not support interlacing or sub-8-bit pixels. + */ +#endif /* PNG_STDIO_SUPPORTED */ +#endif /* PNG_SIMPLIFIED_WRITE_SUPPORTED */ +/******************************************************************************* + * END OF SIMPLIFIED API + ******************************************************************************/ + +#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED +PNG_EXPORT(242, void, png_set_check_for_invalid_index, + (png_structrp png_ptr, int allowed)); +# ifdef PNG_GET_PALETTE_MAX_SUPPORTED +PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr, + png_const_infop info_ptr)); +# endif +#endif /* CHECK_FOR_INVALID_INDEX */ + +/******************************************************************************* + * IMPLEMENTATION OPTIONS + ******************************************************************************* + * + * Support for arbitrary implementation-specific optimizations. The API allows + * particular options to be turned on or off. 'Option' is the number of the + * option and 'onoff' is 0 (off) or non-0 (on). The value returned is given + * by the PNG_OPTION_ defines below. + * + * HARDWARE: normally hardware capabilites, such as the Intel SSE instructions, + * are detected at run time, however sometimes it may be impossible + * to do this in user mode, in which case it is necessary to discover + * the capabilities in an OS specific way. Such capabilities are + * listed here when libpng has support for them and must be turned + * ON by the application if present. + * + * SOFTWARE: sometimes software optimizations actually result in performance + * decrease on some architectures or systems, or with some sets of + * PNG images. 'Software' options allow such optimizations to be + * selected at run time. + */ +#ifdef PNG_SET_OPTION_SUPPORTED +#ifdef PNG_ARM_NEON_API_SUPPORTED +# define PNG_ARM_NEON 0 /* HARDWARE: ARM Neon SIMD instructions supported */ +#endif +#define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */ +#define PNG_OPTION_NEXT 4 /* Next option - numbers must be even */ + +/* Return values: NOTE: there are four values and 'off' is *not* zero */ +#define PNG_OPTION_UNSET 0 /* Unset - defaults to off */ +#define PNG_OPTION_INVALID 1 /* Option number out of range */ +#define PNG_OPTION_OFF 2 +#define PNG_OPTION_ON 3 + +PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option, + int onoff)); +#endif + +/******************************************************************************* + * END OF HARDWARE OPTIONS + ******************************************************************************/ + +/* Maintainer: Put new public prototypes here ^, in libpng.3, and project + * defs, scripts/pnglibconf.h, and scripts/pnglibconf.h.prebuilt + */ + +/* The last ordinal number (this is the *last* one already used; the next + * one to use is one more than this.) Maintainer, remember to add an entry to + * scripts/symbols.def as well. + */ +#ifdef PNG_EXPORT_LAST_ORDINAL + PNG_EXPORT_LAST_ORDINAL(244); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* PNG_VERSION_INFO_ONLY */ +/* Do not put anything past this line */ +#endif /* PNG_H */ diff --git a/extern/for_mingw/include/libpng16/pngconf.h b/extern/for_mingw/include/libpng16/pngconf.h new file mode 100644 index 0000000000..4bd807f271 --- /dev/null +++ b/extern/for_mingw/include/libpng16/pngconf.h @@ -0,0 +1,617 @@ + +/* pngconf.h - machine configurable file for libpng + * + * libpng version 1.6.6 - September 16, 2013 + * + * Copyright (c) 1998-2013 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h + * + */ + +/* Any machine specific code is near the front of this file, so if you + * are configuring libpng for a machine, you may want to read the section + * starting here down to where it starts to typedef png_color, png_text, + * and png_info. + */ + +#ifndef PNGCONF_H +#define PNGCONF_H + +/* To do: Do all of this in scripts/pnglibconf.dfa */ +#ifdef PNG_SAFE_LIMITS_SUPPORTED +# ifdef PNG_USER_WIDTH_MAX +# undef PNG_USER_WIDTH_MAX +# define PNG_USER_WIDTH_MAX 1000000L +# endif +# ifdef PNG_USER_HEIGHT_MAX +# undef PNG_USER_HEIGHT_MAX +# define PNG_USER_HEIGHT_MAX 1000000L +# endif +# ifdef PNG_USER_CHUNK_MALLOC_MAX +# undef PNG_USER_CHUNK_MALLOC_MAX +# define PNG_USER_CHUNK_MALLOC_MAX 4000000L +# endif +# ifdef PNG_USER_CHUNK_CACHE_MAX +# undef PNG_USER_CHUNK_CACHE_MAX +# define PNG_USER_CHUNK_CACHE_MAX 128 +# endif +#endif + +#ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */ + +/* From libpng 1.6.0 libpng requires an ANSI X3.159-1989 ("ISOC90") compliant C + * compiler for correct compilation. The following header files are required by + * the standard. If your compiler doesn't provide these header files, or they + * do not match the standard, you will need to provide/improve them. + */ +#include +#include + +/* Library header files. These header files are all defined by ISOC90; libpng + * expects conformant implementations, however, an ISOC90 conformant system need + * not provide these header files if the functionality cannot be implemented. + * In this case it will be necessary to disable the relevant parts of libpng in + * the build of pnglibconf.h. + * + * Prior to 1.6.0 string.h was included here; the API changes in 1.6.0 to not + * include this unnecessary header file. + */ + +#ifdef PNG_STDIO_SUPPORTED + /* Required for the definition of FILE: */ +# include +#endif + +#ifdef PNG_SETJMP_SUPPORTED + /* Required for the definition of jmp_buf and the declaration of longjmp: */ +# include +#endif + +#ifdef PNG_CONVERT_tIME_SUPPORTED + /* Required for struct tm: */ +# include +#endif + +#endif /* PNG_BUILDING_SYMBOL_TABLE */ + +/* Prior to 1.6.0 it was possible to turn off 'const' in declarations using + * PNG_NO_CONST; this is no longer supported except for data declarations which + * apparently still cause problems in 2011 on some compilers. + */ +#define PNG_CONST const /* backward compatibility only */ + +/* This controls optimization of the reading of 16 and 32 bit values + * from PNG files. It can be set on a per-app-file basis - it + * just changes whether a macro is used when the function is called. + * The library builder sets the default; if read functions are not + * built into the library the macro implementation is forced on. + */ +#ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED +# define PNG_USE_READ_MACROS +#endif +#if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS) +# if PNG_DEFAULT_READ_MACROS +# define PNG_USE_READ_MACROS +# endif +#endif + +/* COMPILER SPECIFIC OPTIONS. + * + * These options are provided so that a variety of difficult compilers + * can be used. Some are fixed at build time (e.g. PNG_API_RULE + * below) but still have compiler specific implementations, others + * may be changed on a per-file basis when compiling against libpng. + */ + +/* The PNGARG macro was used in versions of libpng prior to 1.6.0 to protect + * against legacy (pre ISOC90) compilers that did not understand function + * prototypes. It is not required for modern C compilers. + */ +#ifndef PNGARG +# define PNGARG(arglist) arglist +#endif + +/* Function calling conventions. + * ============================= + * Normally it is not necessary to specify to the compiler how to call + * a function - it just does it - however on x86 systems derived from + * Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems + * and some others) there are multiple ways to call a function and the + * default can be changed on the compiler command line. For this reason + * libpng specifies the calling convention of every exported function and + * every function called via a user supplied function pointer. This is + * done in this file by defining the following macros: + * + * PNGAPI Calling convention for exported functions. + * PNGCBAPI Calling convention for user provided (callback) functions. + * PNGCAPI Calling convention used by the ANSI-C library (required + * for longjmp callbacks and sometimes used internally to + * specify the calling convention for zlib). + * + * These macros should never be overridden. If it is necessary to + * change calling convention in a private build this can be done + * by setting PNG_API_RULE (which defaults to 0) to one of the values + * below to select the correct 'API' variants. + * + * PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout. + * This is correct in every known environment. + * PNG_API_RULE=1 Use the operating system convention for PNGAPI and + * the 'C' calling convention (from PNGCAPI) for + * callbacks (PNGCBAPI). This is no longer required + * in any known environment - if it has to be used + * please post an explanation of the problem to the + * libpng mailing list. + * + * These cases only differ if the operating system does not use the C + * calling convention, at present this just means the above cases + * (x86 DOS/Windows sytems) and, even then, this does not apply to + * Cygwin running on those systems. + * + * Note that the value must be defined in pnglibconf.h so that what + * the application uses to call the library matches the conventions + * set when building the library. + */ + +/* Symbol export + * ============= + * When building a shared library it is almost always necessary to tell + * the compiler which symbols to export. The png.h macro 'PNG_EXPORT' + * is used to mark the symbols. On some systems these symbols can be + * extracted at link time and need no special processing by the compiler, + * on other systems the symbols are flagged by the compiler and just + * the declaration requires a special tag applied (unfortunately) in a + * compiler dependent way. Some systems can do either. + * + * A small number of older systems also require a symbol from a DLL to + * be flagged to the program that calls it. This is a problem because + * we do not know in the header file included by application code that + * the symbol will come from a shared library, as opposed to a statically + * linked one. For this reason the application must tell us by setting + * the magic flag PNG_USE_DLL to turn on the special processing before + * it includes png.h. + * + * Four additional macros are used to make this happen: + * + * PNG_IMPEXP The magic (if any) to cause a symbol to be exported from + * the build or imported if PNG_USE_DLL is set - compiler + * and system specific. + * + * PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to + * 'type', compiler specific. + * + * PNG_DLL_EXPORT Set to the magic to use during a libpng build to + * make a symbol exported from the DLL. Not used in the + * public header files; see pngpriv.h for how it is used + * in the libpng build. + * + * PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come + * from a DLL - used to define PNG_IMPEXP when + * PNG_USE_DLL is set. + */ + +/* System specific discovery. + * ========================== + * This code is used at build time to find PNG_IMPEXP, the API settings + * and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL + * import processing is possible. On Windows systems it also sets + * compiler-specific macros to the values required to change the calling + * conventions of the various functions. + */ +#if defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\ + defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) + /* Windows system (DOS doesn't support DLLs). Includes builds under Cygwin or + * MinGW on any architecture currently supported by Windows. Also includes + * Watcom builds but these need special treatment because they are not + * compatible with GCC or Visual C because of different calling conventions. + */ +# if PNG_API_RULE == 2 + /* If this line results in an error, either because __watcall is not + * understood or because of a redefine just below you cannot use *this* + * build of the library with the compiler you are using. *This* build was + * build using Watcom and applications must also be built using Watcom! + */ +# define PNGCAPI __watcall +# endif + +# if defined(__GNUC__) || (defined(_MSC_VER) && (_MSC_VER >= 800)) +# define PNGCAPI __cdecl +# if PNG_API_RULE == 1 + /* If this line results in an error __stdcall is not understood and + * PNG_API_RULE should not have been set to '1'. + */ +# define PNGAPI __stdcall +# endif +# else + /* An older compiler, or one not detected (erroneously) above, + * if necessary override on the command line to get the correct + * variants for the compiler. + */ +# ifndef PNGCAPI +# define PNGCAPI _cdecl +# endif +# if PNG_API_RULE == 1 && !defined(PNGAPI) +# define PNGAPI _stdcall +# endif +# endif /* compiler/api */ + + /* NOTE: PNGCBAPI always defaults to PNGCAPI. */ + +# if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD) +# error "PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed" +# endif + +# if (defined(_MSC_VER) && _MSC_VER < 800) ||\ + (defined(__BORLANDC__) && __BORLANDC__ < 0x500) + /* older Borland and MSC + * compilers used '__export' and required this to be after + * the type. + */ +# ifndef PNG_EXPORT_TYPE +# define PNG_EXPORT_TYPE(type) type PNG_IMPEXP +# endif +# define PNG_DLL_EXPORT __export +# else /* newer compiler */ +# define PNG_DLL_EXPORT __declspec(dllexport) +# ifndef PNG_DLL_IMPORT +# define PNG_DLL_IMPORT __declspec(dllimport) +# endif +# endif /* compiler */ + +#else /* !Windows */ +# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) +# define PNGAPI _System +# else /* !Windows/x86 && !OS/2 */ + /* Use the defaults, or define PNG*API on the command line (but + * this will have to be done for every compile!) + */ +# endif /* other system, !OS/2 */ +#endif /* !Windows/x86 */ + +/* Now do all the defaulting . */ +#ifndef PNGCAPI +# define PNGCAPI +#endif +#ifndef PNGCBAPI +# define PNGCBAPI PNGCAPI +#endif +#ifndef PNGAPI +# define PNGAPI PNGCAPI +#endif + +/* PNG_IMPEXP may be set on the compilation system command line or (if not set) + * then in an internal header file when building the library, otherwise (when + * using the library) it is set here. + */ +#ifndef PNG_IMPEXP +# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT) + /* This forces use of a DLL, disallowing static linking */ +# define PNG_IMPEXP PNG_DLL_IMPORT +# endif + +# ifndef PNG_IMPEXP +# define PNG_IMPEXP +# endif +#endif + +/* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat + * 'attributes' as a storage class - the attributes go at the start of the + * function definition, and attributes are always appended regardless of the + * compiler. This considerably simplifies these macros but may cause problems + * if any compilers both need function attributes and fail to handle them as + * a storage class (this is unlikely.) + */ +#ifndef PNG_FUNCTION +# define PNG_FUNCTION(type, name, args, attributes) attributes type name args +#endif + +#ifndef PNG_EXPORT_TYPE +# define PNG_EXPORT_TYPE(type) PNG_IMPEXP type +#endif + + /* The ordinal value is only relevant when preprocessing png.h for symbol + * table entries, so we discard it here. See the .dfn files in the + * scripts directory. + */ +#ifndef PNG_EXPORTA + +# define PNG_EXPORTA(ordinal, type, name, args, attributes)\ + PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args), \ + extern attributes) +#endif + +/* ANSI-C (C90) does not permit a macro to be invoked with an empty argument, + * so make something non-empty to satisfy the requirement: + */ +#define PNG_EMPTY /*empty list*/ + +#define PNG_EXPORT(ordinal, type, name, args)\ + PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY) + +/* Use PNG_REMOVED to comment out a removed interface. */ +#ifndef PNG_REMOVED +# define PNG_REMOVED(ordinal, type, name, args, attributes) +#endif + +#ifndef PNG_CALLBACK +# define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args) +#endif + +/* Support for compiler specific function attributes. These are used + * so that where compiler support is available incorrect use of API + * functions in png.h will generate compiler warnings. + * + * Added at libpng-1.2.41. + */ + +#ifndef PNG_NO_PEDANTIC_WARNINGS +# ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED +# define PNG_PEDANTIC_WARNINGS_SUPPORTED +# endif +#endif + +#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED + /* Support for compiler specific function attributes. These are used + * so that where compiler support is available, incorrect use of API + * functions in png.h will generate compiler warnings. Added at libpng + * version 1.2.41. Disabling these removes the warnings but may also produce + * less efficient code. + */ +# if defined(__GNUC__) +# ifndef PNG_USE_RESULT +# define PNG_USE_RESULT __attribute__((__warn_unused_result__)) +# endif +# ifndef PNG_NORETURN +# define PNG_NORETURN __attribute__((__noreturn__)) +# endif +# if __GNUC__ >= 3 +# ifndef PNG_ALLOCATED +# define PNG_ALLOCATED __attribute__((__malloc__)) +# endif +# ifndef PNG_DEPRECATED +# define PNG_DEPRECATED __attribute__((__deprecated__)) +# endif +# ifndef PNG_PRIVATE +# if 0 /* Doesn't work so we use deprecated instead*/ +# define PNG_PRIVATE \ + __attribute__((warning("This function is not exported by libpng."))) +# else +# define PNG_PRIVATE \ + __attribute__((__deprecated__)) +# endif +# endif +# if ((__GNUC__ != 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1)) +# ifndef PNG_RESTRICT +# define PNG_RESTRICT __restrict +# endif +# endif /* __GNUC__ == 3.0 */ +# endif /* __GNUC__ >= 3 */ + +# elif defined(_MSC_VER) && (_MSC_VER >= 1300) +# ifndef PNG_USE_RESULT +# define PNG_USE_RESULT /* not supported */ +# endif +# ifndef PNG_NORETURN +# define PNG_NORETURN __declspec(noreturn) +# endif +# ifndef PNG_ALLOCATED +# if (_MSC_VER >= 1400) +# define PNG_ALLOCATED __declspec(restrict) +# endif +# endif +# ifndef PNG_DEPRECATED +# define PNG_DEPRECATED __declspec(deprecated) +# endif +# ifndef PNG_PRIVATE +# define PNG_PRIVATE __declspec(deprecated) +# endif +# ifndef PNG_RESTRICT +# if (_MSC_VER >= 1400) +# define PNG_RESTRICT __restrict +# endif +# endif + +# elif defined(__WATCOMC__) +# ifndef PNG_RESTRICT +# define PNG_RESTRICT __restrict +# endif +# endif /* _MSC_VER */ +#endif /* PNG_PEDANTIC_WARNINGS */ + +#ifndef PNG_DEPRECATED +# define PNG_DEPRECATED /* Use of this function is deprecated */ +#endif +#ifndef PNG_USE_RESULT +# define PNG_USE_RESULT /* The result of this function must be checked */ +#endif +#ifndef PNG_NORETURN +# define PNG_NORETURN /* This function does not return */ +#endif +#ifndef PNG_ALLOCATED +# define PNG_ALLOCATED /* The result of the function is new memory */ +#endif +#ifndef PNG_PRIVATE +# define PNG_PRIVATE /* This is a private libpng function */ +#endif +#ifndef PNG_RESTRICT +# define PNG_RESTRICT /* The C99 "restrict" feature */ +#endif +#ifndef PNG_FP_EXPORT /* A floating point API. */ +# ifdef PNG_FLOATING_POINT_SUPPORTED +# define PNG_FP_EXPORT(ordinal, type, name, args)\ + PNG_EXPORT(ordinal, type, name, args); +# else /* No floating point APIs */ +# define PNG_FP_EXPORT(ordinal, type, name, args) +# endif +#endif +#ifndef PNG_FIXED_EXPORT /* A fixed point API. */ +# ifdef PNG_FIXED_POINT_SUPPORTED +# define PNG_FIXED_EXPORT(ordinal, type, name, args)\ + PNG_EXPORT(ordinal, type, name, args); +# else /* No fixed point APIs */ +# define PNG_FIXED_EXPORT(ordinal, type, name, args) +# endif +#endif + +#ifndef PNG_BUILDING_SYMBOL_TABLE +/* Some typedefs to get us started. These should be safe on most of the common + * platforms. + * + * png_uint_32 and png_int_32 may, currently, be larger than required to hold a + * 32-bit value however this is not normally advisable. + * + * png_uint_16 and png_int_16 should always be two bytes in size - this is + * verified at library build time. + * + * png_byte must always be one byte in size. + * + * The checks below use constants from limits.h, as defined by the ISOC90 + * standard. + */ +#if CHAR_BIT == 8 && UCHAR_MAX == 255 + typedef unsigned char png_byte; +#else +# error "libpng requires 8 bit bytes" +#endif + +#if INT_MIN == -32768 && INT_MAX == 32767 + typedef int png_int_16; +#elif SHRT_MIN == -32768 && SHRT_MAX == 32767 + typedef short png_int_16; +#else +# error "libpng requires a signed 16 bit type" +#endif + +#if UINT_MAX == 65535 + typedef unsigned int png_uint_16; +#elif USHRT_MAX == 65535 + typedef unsigned short png_uint_16; +#else +# error "libpng requires an unsigned 16 bit type" +#endif + +#if INT_MIN < -2147483646 && INT_MAX > 2147483646 + typedef int png_int_32; +#elif LONG_MIN < -2147483646 && LONG_MAX > 2147483646 + typedef long int png_int_32; +#else +# error "libpng requires a signed 32 bit (or more) type" +#endif + +#if UINT_MAX > 4294967294 + typedef unsigned int png_uint_32; +#elif ULONG_MAX > 4294967294 + typedef unsigned long int png_uint_32; +#else +# error "libpng requires an unsigned 32 bit (or more) type" +#endif + +/* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however, + * requires an ISOC90 compiler and relies on consistent behavior of sizeof. + */ +typedef size_t png_size_t; +typedef ptrdiff_t png_ptrdiff_t; + +/* libpng needs to know the maximum value of 'size_t' and this controls the + * definition of png_alloc_size_t, below. This maximum value of size_t limits + * but does not control the maximum allocations the library makes - there is + * direct application control of this through png_set_user_limits(). + */ +#ifndef PNG_SMALL_SIZE_T + /* Compiler specific tests for systems where size_t is known to be less than + * 32 bits (some of these systems may no longer work because of the lack of + * 'far' support; see above.) + */ +# if (defined(__TURBOC__) && !defined(__FLAT__)) ||\ + (defined(_MSC_VER) && defined(MAXSEG_64K)) +# define PNG_SMALL_SIZE_T +# endif +#endif + +/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, and no + * smaller than png_uint_32. Casts from png_size_t or png_uint_32 to + * png_alloc_size_t are not necessary; in fact, it is recommended not to use + * them at all so that the compiler can complain when something turns out to be + * problematic. + * + * Casts in the other direction (from png_alloc_size_t to png_size_t or + * png_uint_32) should be explicitly applied; however, we do not expect to + * encounter practical situations that require such conversions. + * + * PNG_SMALL_SIZE_T must be defined if the maximum value of size_t is less than + * 4294967295 - i.e. less than the maximum value of png_uint_32. + */ +#ifdef PNG_SMALL_SIZE_T + typedef png_uint_32 png_alloc_size_t; +#else + typedef png_size_t png_alloc_size_t; +#endif + +/* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler + * implementations of Intel CPU specific support of user-mode segmented address + * spaces, where 16-bit pointers address more than 65536 bytes of memory using + * separate 'segment' registers. The implementation requires two different + * types of pointer (only one of which includes the segment value.) + * + * If required this support is available in version 1.2 of libpng and may be + * available in versions through 1.5, although the correctness of the code has + * not been verified recently. + */ + +/* Typedef for floating-point numbers that are converted to fixed-point with a + * multiple of 100,000, e.g., gamma + */ +typedef png_int_32 png_fixed_point; + +/* Add typedefs for pointers */ +typedef void * png_voidp; +typedef const void * png_const_voidp; +typedef png_byte * png_bytep; +typedef const png_byte * png_const_bytep; +typedef png_uint_32 * png_uint_32p; +typedef const png_uint_32 * png_const_uint_32p; +typedef png_int_32 * png_int_32p; +typedef const png_int_32 * png_const_int_32p; +typedef png_uint_16 * png_uint_16p; +typedef const png_uint_16 * png_const_uint_16p; +typedef png_int_16 * png_int_16p; +typedef const png_int_16 * png_const_int_16p; +typedef char * png_charp; +typedef const char * png_const_charp; +typedef png_fixed_point * png_fixed_point_p; +typedef const png_fixed_point * png_const_fixed_point_p; +typedef png_size_t * png_size_tp; +typedef const png_size_t * png_const_size_tp; + +#ifdef PNG_STDIO_SUPPORTED +typedef FILE * png_FILE_p; +#endif + +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double * png_doublep; +typedef const double * png_const_doublep; +#endif + +/* Pointers to pointers; i.e. arrays */ +typedef png_byte * * png_bytepp; +typedef png_uint_32 * * png_uint_32pp; +typedef png_int_32 * * png_int_32pp; +typedef png_uint_16 * * png_uint_16pp; +typedef png_int_16 * * png_int_16pp; +typedef const char * * png_const_charpp; +typedef char * * png_charpp; +typedef png_fixed_point * * png_fixed_point_pp; +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double * * png_doublepp; +#endif + +/* Pointers to pointers to pointers; i.e., pointer to array */ +typedef char * * * png_charppp; + +#endif /* PNG_BUILDING_SYMBOL_TABLE */ + +#endif /* PNGCONF_H */ diff --git a/extern/for_mingw/include/libpng16/pnglibconf.h b/extern/for_mingw/include/libpng16/pnglibconf.h new file mode 100644 index 0000000000..c1abc52f85 --- /dev/null +++ b/extern/for_mingw/include/libpng16/pnglibconf.h @@ -0,0 +1,209 @@ +/* pnglibconf.h - library build configuration */ + +/* libpng version 1.6.6 - September 16, 2013 */ + +/* Copyright (c) 1998-2012 Glenn Randers-Pehrson */ + +/* This code is released under the libpng license. */ +/* For conditions of distribution and use, see the disclaimer */ +/* and license in png.h */ + +/* pnglibconf.h */ +/* Machine generated file: DO NOT EDIT */ +/* Derived from: scripts/pnglibconf.dfa */ +#ifndef PNGLCONF_H +#define PNGLCONF_H +/* options */ +#define PNG_16BIT_SUPPORTED +#define PNG_ALIGNED_MEMORY_SUPPORTED +/*#undef PNG_ARM_NEON_API_SUPPORTED*/ +/*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/ +#define PNG_BENIGN_ERRORS_SUPPORTED +#define PNG_BENIGN_READ_ERRORS_SUPPORTED +/*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/ +#define PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED +#define PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED +#define PNG_COLORSPACE_SUPPORTED +#define PNG_CONSOLE_IO_SUPPORTED +#define PNG_CONVERT_tIME_SUPPORTED +#define PNG_EASY_ACCESS_SUPPORTED +/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/ +#define PNG_ERROR_TEXT_SUPPORTED +#define PNG_FIXED_POINT_SUPPORTED +#define PNG_FLOATING_ARITHMETIC_SUPPORTED +#define PNG_FLOATING_POINT_SUPPORTED +#define PNG_FORMAT_AFIRST_SUPPORTED +#define PNG_FORMAT_BGR_SUPPORTED +#define PNG_GAMMA_SUPPORTED +#define PNG_GET_PALETTE_MAX_SUPPORTED +#define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +#define PNG_INCH_CONVERSIONS_SUPPORTED +#define PNG_INFO_IMAGE_SUPPORTED +#define PNG_IO_STATE_SUPPORTED +#define PNG_MNG_FEATURES_SUPPORTED +#define PNG_POINTER_INDEXING_SUPPORTED +#define PNG_PROGRESSIVE_READ_SUPPORTED +#define PNG_READ_16BIT_SUPPORTED +#define PNG_READ_ALPHA_MODE_SUPPORTED +#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +#define PNG_READ_BACKGROUND_SUPPORTED +#define PNG_READ_BGR_SUPPORTED +#define PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED +#define PNG_READ_COMPOSITE_NODIV_SUPPORTED +#define PNG_READ_COMPRESSED_TEXT_SUPPORTED +#define PNG_READ_EXPAND_16_SUPPORTED +#define PNG_READ_EXPAND_SUPPORTED +#define PNG_READ_FILLER_SUPPORTED +#define PNG_READ_GAMMA_SUPPORTED +#define PNG_READ_GET_PALETTE_MAX_SUPPORTED +#define PNG_READ_GRAY_TO_RGB_SUPPORTED +#define PNG_READ_INTERLACING_SUPPORTED +#define PNG_READ_INT_FUNCTIONS_SUPPORTED +#define PNG_READ_INVERT_ALPHA_SUPPORTED +#define PNG_READ_INVERT_SUPPORTED +#define PNG_READ_OPT_PLTE_SUPPORTED +#define PNG_READ_PACKSWAP_SUPPORTED +#define PNG_READ_PACK_SUPPORTED +#define PNG_READ_QUANTIZE_SUPPORTED +#define PNG_READ_RGB_TO_GRAY_SUPPORTED +#define PNG_READ_SCALE_16_TO_8_SUPPORTED +#define PNG_READ_SHIFT_SUPPORTED +#define PNG_READ_STRIP_16_TO_8_SUPPORTED +#define PNG_READ_STRIP_ALPHA_SUPPORTED +#define PNG_READ_SUPPORTED +#define PNG_READ_SWAP_ALPHA_SUPPORTED +#define PNG_READ_SWAP_SUPPORTED +#define PNG_READ_TEXT_SUPPORTED +#define PNG_READ_TRANSFORMS_SUPPORTED +#define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_READ_USER_CHUNKS_SUPPORTED +#define PNG_READ_USER_TRANSFORM_SUPPORTED +#define PNG_READ_bKGD_SUPPORTED +#define PNG_READ_cHRM_SUPPORTED +#define PNG_READ_gAMA_SUPPORTED +#define PNG_READ_hIST_SUPPORTED +#define PNG_READ_iCCP_SUPPORTED +#define PNG_READ_iTXt_SUPPORTED +#define PNG_READ_oFFs_SUPPORTED +#define PNG_READ_pCAL_SUPPORTED +#define PNG_READ_pHYs_SUPPORTED +#define PNG_READ_sBIT_SUPPORTED +#define PNG_READ_sCAL_SUPPORTED +#define PNG_READ_sPLT_SUPPORTED +#define PNG_READ_sRGB_SUPPORTED +#define PNG_READ_tEXt_SUPPORTED +#define PNG_READ_tIME_SUPPORTED +#define PNG_READ_tRNS_SUPPORTED +#define PNG_READ_zTXt_SUPPORTED +/*#undef PNG_SAFE_LIMITS_SUPPORTED*/ +#define PNG_SAVE_INT_32_SUPPORTED +#define PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_SEQUENTIAL_READ_SUPPORTED +#define PNG_SETJMP_SUPPORTED +#define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED +#define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED +#define PNG_SET_OPTION_SUPPORTED +#define PNG_SET_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_SET_USER_LIMITS_SUPPORTED +#define PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED +#define PNG_SIMPLIFIED_READ_BGR_SUPPORTED +#define PNG_SIMPLIFIED_READ_SUPPORTED +#define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED +#define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED +#define PNG_SIMPLIFIED_WRITE_SUPPORTED +#define PNG_STDIO_SUPPORTED +#define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_TEXT_SUPPORTED +#define PNG_TIME_RFC1123_SUPPORTED +#define PNG_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_USER_CHUNKS_SUPPORTED +#define PNG_USER_LIMITS_SUPPORTED +#define PNG_USER_MEM_SUPPORTED +#define PNG_USER_TRANSFORM_INFO_SUPPORTED +#define PNG_USER_TRANSFORM_PTR_SUPPORTED +#define PNG_WARNINGS_SUPPORTED +#define PNG_WRITE_16BIT_SUPPORTED +#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +#define PNG_WRITE_BGR_SUPPORTED +#define PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED +#define PNG_WRITE_COMPRESSED_TEXT_SUPPORTED +#define PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED +#define PNG_WRITE_FILLER_SUPPORTED +#define PNG_WRITE_FILTER_SUPPORTED +#define PNG_WRITE_FLUSH_SUPPORTED +#define PNG_WRITE_GET_PALETTE_MAX_SUPPORTED +#define PNG_WRITE_INTERLACING_SUPPORTED +#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED +#define PNG_WRITE_INVERT_ALPHA_SUPPORTED +#define PNG_WRITE_INVERT_SUPPORTED +#define PNG_WRITE_OPTIMIZE_CMF_SUPPORTED +#define PNG_WRITE_PACKSWAP_SUPPORTED +#define PNG_WRITE_PACK_SUPPORTED +#define PNG_WRITE_SHIFT_SUPPORTED +#define PNG_WRITE_SUPPORTED +#define PNG_WRITE_SWAP_ALPHA_SUPPORTED +#define PNG_WRITE_SWAP_SUPPORTED +#define PNG_WRITE_TEXT_SUPPORTED +#define PNG_WRITE_TRANSFORMS_SUPPORTED +#define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_WRITE_USER_TRANSFORM_SUPPORTED +#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +#define PNG_WRITE_bKGD_SUPPORTED +#define PNG_WRITE_cHRM_SUPPORTED +#define PNG_WRITE_gAMA_SUPPORTED +#define PNG_WRITE_hIST_SUPPORTED +#define PNG_WRITE_iCCP_SUPPORTED +#define PNG_WRITE_iTXt_SUPPORTED +#define PNG_WRITE_oFFs_SUPPORTED +#define PNG_WRITE_pCAL_SUPPORTED +#define PNG_WRITE_pHYs_SUPPORTED +#define PNG_WRITE_sBIT_SUPPORTED +#define PNG_WRITE_sCAL_SUPPORTED +#define PNG_WRITE_sPLT_SUPPORTED +#define PNG_WRITE_sRGB_SUPPORTED +#define PNG_WRITE_tEXt_SUPPORTED +#define PNG_WRITE_tIME_SUPPORTED +#define PNG_WRITE_tRNS_SUPPORTED +#define PNG_WRITE_zTXt_SUPPORTED +#define PNG_bKGD_SUPPORTED +#define PNG_cHRM_SUPPORTED +#define PNG_gAMA_SUPPORTED +#define PNG_hIST_SUPPORTED +#define PNG_iCCP_SUPPORTED +#define PNG_iTXt_SUPPORTED +#define PNG_oFFs_SUPPORTED +#define PNG_pCAL_SUPPORTED +#define PNG_pHYs_SUPPORTED +#define PNG_sBIT_SUPPORTED +#define PNG_sCAL_SUPPORTED +#define PNG_sPLT_SUPPORTED +#define PNG_sRGB_SUPPORTED +#define PNG_tEXt_SUPPORTED +#define PNG_tIME_SUPPORTED +#define PNG_tRNS_SUPPORTED +#define PNG_zTXt_SUPPORTED +/* end of options */ +/* settings */ +#define PNG_API_RULE 0 +#define PNG_CALLOC_SUPPORTED +#define PNG_COST_SHIFT 3 +#define PNG_DEFAULT_READ_MACROS 1 +#define PNG_GAMMA_THRESHOLD_FIXED 5000 +#define PNG_IDAT_READ_SIZE PNG_ZBUF_SIZE +#define PNG_INFLATE_BUF_SIZE 1024 +#define PNG_MAX_GAMMA_8 11 +#define PNG_QUANTIZE_BLUE_BITS 5 +#define PNG_QUANTIZE_GREEN_BITS 5 +#define PNG_QUANTIZE_RED_BITS 5 +#define PNG_TEXT_Z_DEFAULT_COMPRESSION (-1) +#define PNG_TEXT_Z_DEFAULT_STRATEGY 0 +#define PNG_WEIGHT_SHIFT 8 +#define PNG_ZBUF_SIZE 8192 +#define PNG_ZLIB_VERNUM 0x1280 +#define PNG_Z_DEFAULT_COMPRESSION (-1) +#define PNG_Z_DEFAULT_NOFILTER_STRATEGY 0 +#define PNG_Z_DEFAULT_STRATEGY 1 +#define PNG_sCAL_PRECISION 5 +#define PNG_sRGB_PROFILE_CHECKS 2 +/* end of settings */ +#endif /* PNGLCONF_H */ diff --git a/extern/for_mingw/include/png.h b/extern/for_mingw/include/png.h new file mode 100644 index 0000000000..71c2ab6750 --- /dev/null +++ b/extern/for_mingw/include/png.h @@ -0,0 +1,3315 @@ + +/* png.h - header file for PNG reference library + * + * libpng version 1.6.6 - September 16, 2013 + * Copyright (c) 1998-2013 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * This code is released under the libpng license (See LICENSE, below) + * + * Authors and maintainers: + * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat + * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger + * libpng versions 0.97, January 1998, through 1.6.6 - September 16, 2013: Glenn + * See also "Contributing Authors", below. + * + * Note about libpng version numbers: + * + * Due to various miscommunications, unforeseen code incompatibilities + * and occasional factors outside the authors' control, version numbering + * on the library has not always been consistent and straightforward. + * The following table summarizes matters since version 0.89c, which was + * the first widely used release: + * + * source png.h png.h shared-lib + * version string int version + * ------- ------ ----- ---------- + * 0.89c "1.0 beta 3" 0.89 89 1.0.89 + * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] + * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] + * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] + * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] + * 0.97c 0.97 97 2.0.97 + * 0.98 0.98 98 2.0.98 + * 0.99 0.99 98 2.0.99 + * 0.99a-m 0.99 99 2.0.99 + * 1.00 1.00 100 2.1.0 [100 should be 10000] + * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] + * 1.0.1 png.h string is 10001 2.1.0 + * 1.0.1a-e identical to the 10002 from here on, the shared library + * 1.0.2 source version) 10002 is 2.V where V is the source code + * 1.0.2a-b 10003 version, except as noted. + * 1.0.3 10003 + * 1.0.3a-d 10004 + * 1.0.4 10004 + * 1.0.4a-f 10005 + * 1.0.5 (+ 2 patches) 10005 + * 1.0.5a-d 10006 + * 1.0.5e-r 10100 (not source compatible) + * 1.0.5s-v 10006 (not binary compatible) + * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) + * 1.0.6d-f 10007 (still binary incompatible) + * 1.0.6g 10007 + * 1.0.6h 10007 10.6h (testing xy.z so-numbering) + * 1.0.6i 10007 10.6i + * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) + * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) + * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) + * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) + * 1.0.7 1 10007 (still compatible) + * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 + * 1.0.8rc1 1 10008 2.1.0.8rc1 + * 1.0.8 1 10008 2.1.0.8 + * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 + * 1.0.9rc1 1 10009 2.1.0.9rc1 + * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 + * 1.0.9rc2 1 10009 2.1.0.9rc2 + * 1.0.9 1 10009 2.1.0.9 + * 1.0.10beta1 1 10010 2.1.0.10beta1 + * 1.0.10rc1 1 10010 2.1.0.10rc1 + * 1.0.10 1 10010 2.1.0.10 + * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 + * 1.0.11rc1 1 10011 2.1.0.11rc1 + * 1.0.11 1 10011 2.1.0.11 + * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 + * 1.0.12rc1 2 10012 2.1.0.12rc1 + * 1.0.12 2 10012 2.1.0.12 + * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) + * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 + * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 + * 1.2.0rc1 3 10200 3.1.2.0rc1 + * 1.2.0 3 10200 3.1.2.0 + * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 + * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 + * 1.2.1 3 10201 3.1.2.1 + * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 + * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 + * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 + * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 + * 1.0.13 10 10013 10.so.0.1.0.13 + * 1.2.2 12 10202 12.so.0.1.2.2 + * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 + * 1.2.3 12 10203 12.so.0.1.2.3 + * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 + * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 + * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 + * 1.0.14 10 10014 10.so.0.1.0.14 + * 1.2.4 13 10204 12.so.0.1.2.4 + * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 + * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 + * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 + * 1.0.15 10 10015 10.so.0.1.0.15 + * 1.2.5 13 10205 12.so.0.1.2.5 + * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 + * 1.0.16 10 10016 10.so.0.1.0.16 + * 1.2.6 13 10206 12.so.0.1.2.6 + * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 + * 1.0.17rc1 10 10017 12.so.0.1.0.17rc1 + * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 + * 1.0.17 10 10017 12.so.0.1.0.17 + * 1.2.7 13 10207 12.so.0.1.2.7 + * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 + * 1.0.18rc1-5 10 10018 12.so.0.1.0.18rc1-5 + * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 + * 1.0.18 10 10018 12.so.0.1.0.18 + * 1.2.8 13 10208 12.so.0.1.2.8 + * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 + * 1.2.9beta4-11 13 10209 12.so.0.9[.0] + * 1.2.9rc1 13 10209 12.so.0.9[.0] + * 1.2.9 13 10209 12.so.0.9[.0] + * 1.2.10beta1-7 13 10210 12.so.0.10[.0] + * 1.2.10rc1-2 13 10210 12.so.0.10[.0] + * 1.2.10 13 10210 12.so.0.10[.0] + * 1.4.0beta1-5 14 10400 14.so.0.0[.0] + * 1.2.11beta1-4 13 10211 12.so.0.11[.0] + * 1.4.0beta7-8 14 10400 14.so.0.0[.0] + * 1.2.11 13 10211 12.so.0.11[.0] + * 1.2.12 13 10212 12.so.0.12[.0] + * 1.4.0beta9-14 14 10400 14.so.0.0[.0] + * 1.2.13 13 10213 12.so.0.13[.0] + * 1.4.0beta15-36 14 10400 14.so.0.0[.0] + * 1.4.0beta37-87 14 10400 14.so.14.0[.0] + * 1.4.0rc01 14 10400 14.so.14.0[.0] + * 1.4.0beta88-109 14 10400 14.so.14.0[.0] + * 1.4.0rc02-08 14 10400 14.so.14.0[.0] + * 1.4.0 14 10400 14.so.14.0[.0] + * 1.4.1beta01-03 14 10401 14.so.14.1[.0] + * 1.4.1rc01 14 10401 14.so.14.1[.0] + * 1.4.1beta04-12 14 10401 14.so.14.1[.0] + * 1.4.1 14 10401 14.so.14.1[.0] + * 1.4.2 14 10402 14.so.14.2[.0] + * 1.4.3 14 10403 14.so.14.3[.0] + * 1.4.4 14 10404 14.so.14.4[.0] + * 1.5.0beta01-58 15 10500 15.so.15.0[.0] + * 1.5.0rc01-07 15 10500 15.so.15.0[.0] + * 1.5.0 15 10500 15.so.15.0[.0] + * 1.5.1beta01-11 15 10501 15.so.15.1[.0] + * 1.5.1rc01-02 15 10501 15.so.15.1[.0] + * 1.5.1 15 10501 15.so.15.1[.0] + * 1.5.2beta01-03 15 10502 15.so.15.2[.0] + * 1.5.2rc01-03 15 10502 15.so.15.2[.0] + * 1.5.2 15 10502 15.so.15.2[.0] + * 1.5.3beta01-10 15 10503 15.so.15.3[.0] + * 1.5.3rc01-02 15 10503 15.so.15.3[.0] + * 1.5.3beta11 15 10503 15.so.15.3[.0] + * 1.5.3 [omitted] + * 1.5.4beta01-08 15 10504 15.so.15.4[.0] + * 1.5.4rc01 15 10504 15.so.15.4[.0] + * 1.5.4 15 10504 15.so.15.4[.0] + * 1.5.5beta01-08 15 10505 15.so.15.5[.0] + * 1.5.5rc01 15 10505 15.so.15.5[.0] + * 1.5.5 15 10505 15.so.15.5[.0] + * 1.5.6beta01-07 15 10506 15.so.15.6[.0] + * 1.5.6rc01-03 15 10506 15.so.15.6[.0] + * 1.5.6 15 10506 15.so.15.6[.0] + * 1.5.7beta01-05 15 10507 15.so.15.7[.0] + * 1.5.7rc01-03 15 10507 15.so.15.7[.0] + * 1.5.7 15 10507 15.so.15.7[.0] + * 1.6.0beta01-40 16 10600 16.so.16.0[.0] + * 1.6.0rc01-08 16 10600 16.so.16.0[.0] + * 1.6.0 16 10600 16.so.16.0[.0] + * 1.6.1beta01-09 16 10601 16.so.16.1[.0] + * 1.6.1rc01 16 10601 16.so.16.1[.0] + * 1.6.1 16 10601 16.so.16.1[.0] + * 1.6.2beta01 16 10602 16.so.16.2[.0] + * 1.6.2rc01-06 16 10602 16.so.16.2[.0] + * 1.6.2 16 10602 16.so.16.2[.0] + * 1.6.3beta01-11 16 10603 16.so.16.3[.0] + * 1.6.3rc01 16 10603 16.so.16.3[.0] + * 1.6.3 16 10603 16.so.16.3[.0] + * 1.6.4beta01-02 16 10604 16.so.16.4[.0] + * 1.6.4rc01 16 10604 16.so.16.4[.0] + * 1.6.4 16 10604 16.so.16.4[.0] + * 1.6.5 16 10605 16.so.16.5[.0] + * 1.6.6 16 10606 16.so.16.6[.0] + * + * Henceforth the source version will match the shared-library major + * and minor numbers; the shared-library major version number will be + * used for changes in backward compatibility, as it is intended. The + * PNG_LIBPNG_VER macro, which is not used within libpng but is available + * for applications, is an unsigned integer of the form xyyzz corresponding + * to the source version x.y.z (leading zeros in y and z). Beta versions + * were given the previous public release number plus a letter, until + * version 1.0.6j; from then on they were given the upcoming public + * release number plus "betaNN" or "rcNN". + * + * Binary incompatibility exists only when applications make direct access + * to the info_ptr or png_ptr members through png.h, and the compiled + * application is loaded with a different version of the library. + * + * DLLNUM will change each time there are forward or backward changes + * in binary compatibility (e.g., when a new feature is added). + * + * See libpng-manual.txt or libpng.3 for more information. The PNG + * specification is available as a W3C Recommendation and as an ISO + * Specification, defines should NOT be changed. + */ +#define PNG_INFO_gAMA 0x0001 +#define PNG_INFO_sBIT 0x0002 +#define PNG_INFO_cHRM 0x0004 +#define PNG_INFO_PLTE 0x0008 +#define PNG_INFO_tRNS 0x0010 +#define PNG_INFO_bKGD 0x0020 +#define PNG_INFO_hIST 0x0040 +#define PNG_INFO_pHYs 0x0080 +#define PNG_INFO_oFFs 0x0100 +#define PNG_INFO_tIME 0x0200 +#define PNG_INFO_pCAL 0x0400 +#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ +#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ +#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ +#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ +#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */ + +/* This is used for the transformation routines, as some of them + * change these values for the row. It also should enable using + * the routines for other purposes. + */ +typedef struct png_row_info_struct +{ + png_uint_32 width; /* width of row */ + png_size_t rowbytes; /* number of bytes in row */ + png_byte color_type; /* color type of row */ + png_byte bit_depth; /* bit depth of row */ + png_byte channels; /* number of channels (1, 2, 3, or 4) */ + png_byte pixel_depth; /* bits per pixel (depth * channels) */ +} png_row_info; + +typedef png_row_info * png_row_infop; +typedef png_row_info * * 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. Note that the 'write' function must not + * modify the buffer it is passed. The 'read' function, on the other hand, is + * expected to return the read data in the buffer. + */ +typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp)); +typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t)); +typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp)); +typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32, + int)); +typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32, + int)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop)); +typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop)); + +/* The following callback receives png_uint_32 row_number, int pass for the + * png_bytep data of the row. When transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep, + png_uint_32, int)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop, + png_bytep)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp, + png_unknown_chunkp)); +#endif +#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +/* not used anywhere */ +/* typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); */ +#endif + +#ifdef PNG_SETJMP_SUPPORTED +/* This must match the function definition in , and the application + * must include this before png.h to obtain the definition of jmp_buf. The + * function is required to be PNG_NORETURN, but this is not checked. If the + * function does return the application will crash via an abort() or similar + * system level call. + * + * If you get a warning here while building the library you may need to make + * changes to ensure that pnglibconf.h records the calling convention used by + * your compiler. This may be very difficult - try using a different compiler + * to build the library! + */ +PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef); +#endif + +/* Transform masks for the high-level interface */ +#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ +#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ +#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ +#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ +#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ +#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ +#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ +#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ +#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ +#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ +#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ +#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ +#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */ +/* Added to libpng-1.2.34 */ +#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER +#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ +/* Added to libpng-1.4.0 */ +#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ +/* Added to libpng-1.5.4 */ +#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */ +#define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */ + +/* Flags for MNG supported features */ +#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 +#define PNG_FLAG_MNG_FILTER_64 0x04 +#define PNG_ALL_MNG_FEATURES 0x05 + +/* NOTE: prior to 1.5 these functions had no 'API' style declaration, + * this allowed the zlib default functions to be used on Windows + * platforms. In 1.5 the zlib default malloc (which just calls malloc and + * ignores the first argument) should be completely compatible with the + * following. + */ +typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp, + png_alloc_size_t)); +typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp)); + +/* Section 3: exported functions + * Here are the function definitions most commonly used. This is not + * the place to find out how to use libpng. See libpng-manual.txt for the + * full explanation, see example.c for the summary. This just provides + * a simple one line description of the use of each function. + * + * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in + * pngconf.h and in the *.dfn files in the scripts directory. + * + * PNG_EXPORT(ordinal, type, name, (args)); + * + * ordinal: ordinal that is used while building + * *.def files. The ordinal value is only + * relevant when preprocessing png.h with + * the *.dfn files for building symbol table + * entries, and are removed by pngconf.h. + * type: return type of the function + * name: function name + * args: function arguments, with types + * + * When we wish to append attributes to a function prototype we use + * the PNG_EXPORTA() macro instead. + * + * PNG_EXPORTA(ordinal, type, name, (args), attributes); + * + * ordinal, type, name, and args: same as in PNG_EXPORT(). + * attributes: function attributes + */ + +/* Returns the version number of the library */ +PNG_EXPORT(1, png_uint_32, png_access_version_number, (void)); + +/* Tell lib we have already handled the first magic bytes. + * Handling more than 8 bytes from the beginning of the file is an error. + */ +PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes)); + +/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a + * PNG file. Returns zero if the supplied bytes match the 8-byte PNG + * signature, and non-zero otherwise. Having num_to_check == 0 or + * start > 7 will always fail (ie return non-zero). + */ +PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start, + png_size_t num_to_check)); + +/* Simple signature checking function. This is the same as calling + * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). + */ +#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n)) + +/* Allocate and initialize png_ptr struct for reading, and any other memory. */ +PNG_EXPORTA(4, png_structp, png_create_read_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn), + PNG_ALLOCATED); + +/* Allocate and initialize png_ptr struct for writing, and any other memory */ +PNG_EXPORTA(5, png_structp, png_create_write_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn), + PNG_ALLOCATED); + +PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size, + (png_const_structrp png_ptr)); + +PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr, + png_size_t size)); + +/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp + * match up. + */ +#ifdef PNG_SETJMP_SUPPORTED +/* This function returns the jmp_buf built in to *png_ptr. It must be + * supplied with an appropriate 'longjmp' function to use on that jmp_buf + * unless the default error function is overridden in which case NULL is + * acceptable. The size of the jmp_buf is checked against the actual size + * allocated by the library - the call will return NULL on a mismatch + * indicating an ABI mismatch. + */ +PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr, + png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)); +# define png_jmpbuf(png_ptr) \ + (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf)))) +#else +# define png_jmpbuf(png_ptr) \ + (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) +#endif +/* This function should be used by libpng applications in place of + * longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it + * will use it; otherwise it will call PNG_ABORT(). This function was + * added in libpng-1.5.0. + */ +PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val), + PNG_NORETURN); + +#ifdef PNG_READ_SUPPORTED +/* Reset the compression stream */ +PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED); +#endif + +/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ +#ifdef PNG_USER_MEM_SUPPORTED +PNG_EXPORTA(11, png_structp, png_create_read_struct_2, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), + PNG_ALLOCATED); +PNG_EXPORTA(12, png_structp, png_create_write_struct_2, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), + PNG_ALLOCATED); +#endif + +/* Write the PNG file signature. */ +PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr)); + +/* Write a PNG chunk - size, type, (optional) data, CRC. */ +PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep + chunk_name, png_const_bytep data, png_size_t length)); + +/* Write the start of a PNG chunk - length and chunk name. */ +PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr, + png_const_bytep chunk_name, png_uint_32 length)); + +/* Write the data of a PNG chunk started with png_write_chunk_start(). */ +PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr, + png_const_bytep data, png_size_t length)); + +/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr)); + +/* Allocate and initialize the info structure */ +PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr), + PNG_ALLOCATED); + +/* DEPRECATED: this function allowed init structures to be created using the + * default allocation method (typically malloc). Use is deprecated in 1.6.0 and + * the API will be removed in the future. + */ +PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr, + png_size_t png_info_struct_size), PNG_DEPRECATED); + +/* Writes all the PNG information before the image. */ +PNG_EXPORT(20, void, png_write_info_before_PLTE, + (png_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(21, void, png_write_info, + (png_structrp png_ptr, png_const_inforp info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the information before the actual image data. */ +PNG_EXPORT(22, void, png_read_info, + (png_structrp png_ptr, png_inforp info_ptr)); +#endif + +#ifdef PNG_TIME_RFC1123_SUPPORTED + /* Convert to a US string format: there is no localization support in this + * routine. The original implementation used a 29 character buffer in + * png_struct, this will be removed in future versions. + */ +#if PNG_LIBPNG_VER < 10700 +/* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */ +PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr, + png_const_timep ptime),PNG_DEPRECATED); +#endif +PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29], + png_const_timep ptime)); +#endif + +#ifdef PNG_CONVERT_tIME_SUPPORTED +/* Convert from a struct tm to png_time */ +PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime, + const struct tm * ttime)); + +/* Convert from time_t to png_time. Uses gmtime() */ +PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime)); +#endif /* PNG_CONVERT_tIME_SUPPORTED */ + +#ifdef PNG_READ_EXPAND_SUPPORTED +/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ +PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr)); +PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr)); +PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr)); +PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_EXPAND_16_SUPPORTED +/* Expand to 16-bit channels, forces conversion of palette to RGB and expansion + * of a tRNS chunk if present. + */ +PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +/* Use blue, green, red order for pixels. */ +PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED +/* Expand the grayscale to 24-bit RGB if necessary. */ +PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED +/* Reduce RGB to grayscale. */ +#define PNG_ERROR_ACTION_NONE 1 +#define PNG_ERROR_ACTION_WARN 2 +#define PNG_ERROR_ACTION_ERROR 3 +#define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/ + +PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr, + int error_action, double red, double green)) +PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structrp png_ptr, + int error_action, png_fixed_point red, png_fixed_point green)) + +PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structrp + png_ptr)); +#endif + +#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED +PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth, + png_colorp palette)); +#endif + +#ifdef PNG_READ_ALPHA_MODE_SUPPORTED +/* How the alpha channel is interpreted - this affects how the color channels of + * a PNG file are returned when an alpha channel, or tRNS chunk in a palette + * file, is present. + * + * This has no effect on the way pixels are written into a PNG output + * datastream. The color samples in a PNG datastream are never premultiplied + * with the alpha samples. + * + * The default is to return data according to the PNG specification: the alpha + * channel is a linear measure of the contribution of the pixel to the + * corresponding composited pixel. The gamma encoded color channels must be + * scaled according to the contribution and to do this it is necessary to undo + * the encoding, scale the color values, perform the composition and reencode + * the values. This is the 'PNG' mode. + * + * The alternative is to 'associate' the alpha with the color information by + * storing color channel values that have been scaled by the alpha. The + * advantage is that the color channels can be resampled (the image can be + * scaled) in this form. The disadvantage is that normal practice is to store + * linear, not (gamma) encoded, values and this requires 16-bit channels for + * still images rather than the 8-bit channels that are just about sufficient if + * gamma encoding is used. In addition all non-transparent pixel values, + * including completely opaque ones, must be gamma encoded to produce the final + * image. This is the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' mode (the + * latter being the two common names for associated alpha color channels.) + * + * Since it is not necessary to perform arithmetic on opaque color values so + * long as they are not to be resampled and are in the final color space it is + * possible to optimize the handling of alpha by storing the opaque pixels in + * the PNG format (adjusted for the output color space) while storing partially + * opaque pixels in the standard, linear, format. The accuracy required for + * standard alpha composition is relatively low, because the pixels are + * isolated, therefore typically the accuracy loss in storing 8-bit linear + * values is acceptable. (This is not true if the alpha channel is used to + * simulate transparency over large areas - use 16 bits or the PNG mode in + * this case!) This is the 'OPTIMIZED' mode. For this mode a pixel is + * treated as opaque only if the alpha value is equal to the maximum value. + * + * The final choice is to gamma encode the alpha channel as well. This is + * broken because, in practice, no implementation that uses this choice + * correctly undoes the encoding before handling alpha composition. Use this + * choice only if other serious errors in the software or hardware you use + * mandate it; the typical serious error is for dark halos to appear around + * opaque areas of the composited PNG image because of arithmetic overflow. + * + * The API function png_set_alpha_mode specifies which of these choices to use + * with an enumerated 'mode' value and the gamma of the required output: + */ +#define PNG_ALPHA_PNG 0 /* according to the PNG standard */ +#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */ +#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */ +#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */ +#define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */ +#define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */ + +PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structrp png_ptr, int mode, + double output_gamma)) +PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr, + int mode, png_fixed_point output_gamma)) +#endif + +#if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED) +/* The output_gamma value is a screen gamma in libpng terminology: it expresses + * how to decode the output values, not how they are encoded. The values used + * correspond to the normal numbers used to describe the overall gamma of a + * computer display system; for example 2.2 for an sRGB conformant system. The + * values are scaled by 100000 in the _fixed version of the API (so 220000 for + * sRGB.) + * + * The inverse of the value is always used to provide a default for the PNG file + * encoding if it has no gAMA chunk and if png_set_gamma() has not been called + * to override the PNG gamma information. + * + * When the ALPHA_OPTIMIZED mode is selected the output gamma is used to encode + * opaque pixels however pixels with lower alpha values are not encoded, + * regardless of the output gamma setting. + * + * When the standard Porter Duff handling is requested with mode 1 the output + * encoding is set to be linear and the output_gamma value is only relevant + * as a default for input data that has no gamma information. The linear output + * encoding will be overridden if png_set_gamma() is called - the results may be + * highly unexpected! + * + * The following numbers are derived from the sRGB standard and the research + * behind it. sRGB is defined to be approximated by a PNG gAMA chunk value of + * 0.45455 (1/2.2) for PNG. The value implicitly includes any viewing + * correction required to take account of any differences in the color + * environment of the original scene and the intended display environment; the + * value expresses how to *decode* the image for display, not how the original + * data was *encoded*. + * + * sRGB provides a peg for the PNG standard by defining a viewing environment. + * sRGB itself, and earlier TV standards, actually use a more complex transform + * (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is + * limited to simple power laws.) By saying that an image for direct display on + * an sRGB conformant system should be stored with a gAMA chunk value of 45455 + * (11.3.3.2 and 11.3.3.5 of the ISO PNG specification) the PNG specification + * makes it possible to derive values for other display systems and + * environments. + * + * The Mac value is deduced from the sRGB based on an assumption that the actual + * extra viewing correction used in early Mac display systems was implemented as + * a power 1.45 lookup table. + * + * Any system where a programmable lookup table is used or where the behavior of + * the final display device characteristics can be changed requires system + * specific code to obtain the current characteristic. However this can be + * difficult and most PNG gamma correction only requires an approximate value. + * + * By default, if png_set_alpha_mode() is not called, libpng assumes that all + * values are unencoded, linear, values and that the output device also has a + * linear characteristic. This is only very rarely correct - it is invariably + * better to call png_set_alpha_mode() with PNG_DEFAULT_sRGB than rely on the + * default if you don't know what the right answer is! + * + * The special value PNG_GAMMA_MAC_18 indicates an older Mac system (pre Mac OS + * 10.6) which used a correction table to implement a somewhat lower gamma on an + * otherwise sRGB system. + * + * Both these values are reserved (not simple gamma values) in order to allow + * more precise correction internally in the future. + * + * NOTE: the following values can be passed to either the fixed or floating + * point APIs, but the floating point API will also accept floating point + * values. + */ +#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */ +#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */ +#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */ +#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */ +#endif + +/* The following are examples of calls to png_set_alpha_mode to achieve the + * required overall gamma correction and, where necessary, alpha + * premultiplication. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * This is the default libpng handling of the alpha channel - it is not + * pre-multiplied into the color components. In addition the call states + * that the output is for a sRGB system and causes all PNG files without gAMA + * chunks to be assumed to be encoded using sRGB. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * In this case the output is assumed to be something like an sRGB conformant + * display preceeded by a power-law lookup table of power 1.45. This is how + * early Mac systems behaved. + * + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR); + * This is the classic Jim Blinn approach and will work in academic + * environments where everything is done by the book. It has the shortcoming + * of assuming that input PNG data with no gamma information is linear - this + * is unlikely to be correct unless the PNG files where generated locally. + * Most of the time the output precision will be so low as to show + * significant banding in dark areas of the image. + * + * png_set_expand_16(pp); + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB); + * This is a somewhat more realistic Jim Blinn inspired approach. PNG files + * are assumed to have the sRGB encoding if not marked with a gamma value and + * the output is always 16 bits per component. This permits accurate scaling + * and processing of the data. If you know that your input PNG files were + * generated locally you might need to replace PNG_DEFAULT_sRGB with the + * correct value for your system. + * + * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB); + * If you just need to composite the PNG image onto an existing background + * and if you control the code that does this you can use the optimization + * setting. In this case you just copy completely opaque pixels to the + * output. For pixels that are not completely transparent (you just skip + * those) you do the composition math using png_composite or png_composite_16 + * below then encode the resultant 8-bit or 16-bit values to match the output + * encoding. + * + * Other cases + * If neither the PNG nor the standard linear encoding work for you because + * of the software or hardware you use then you have a big problem. The PNG + * case will probably result in halos around the image. The linear encoding + * will probably result in a washed out, too bright, image (it's actually too + * contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably + * substantially reduce the halos. Alternatively try: + * + * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB); + * This option will also reduce the halos, but there will be slight dark + * halos round the opaque parts of the image where the background is light. + * In the OPTIMIZED mode the halos will be light halos where the background + * is dark. Take your pick - the halos are unavoidable unless you can get + * your hardware/software fixed! (The OPTIMIZED approach is slightly + * faster.) + * + * When the default gamma of PNG files doesn't match the output gamma. + * If you have PNG files with no gamma information png_set_alpha_mode allows + * you to provide a default gamma, but it also sets the ouput gamma to the + * matching value. If you know your PNG files have a gamma that doesn't + * match the output you can take advantage of the fact that + * png_set_alpha_mode always sets the output gamma but only sets the PNG + * default if it is not already set: + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * The first call sets both the default and the output gamma values, the + * second call overrides the output gamma without changing the default. This + * is easier than achieving the same effect with png_set_gamma. You must use + * PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will + * fire if more than one call to png_set_alpha_mode and png_set_background is + * made in the same read operation, however multiple calls with PNG_ALPHA_PNG + * are ignored. + */ + +#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED +PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ +PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler, + int flags)); +/* The values of the PNG_FILLER_ defines should NOT be changed */ +# define PNG_FILLER_BEFORE 0 +# define PNG_FILLER_AFTER 1 +/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ +PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr, + png_uint_32 filler, int flags)); +#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +/* Swap bytes in 16-bit depth files. */ +PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) +/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ +PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ + defined(PNG_WRITE_PACKSWAP_SUPPORTED) +/* Swap packing order of pixels in bytes. */ +PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +/* Converts files to legal bit depths. */ +PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p + true_bits)); +#endif + +#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ + defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* Have the code handle the interlacing. Returns the number of passes. + * MUST be called before png_read_update_info or png_start_read_image, + * otherwise it will not have the desired effect. Note that it is still + * necessary to call png_read_row or png_read_rows png_get_image_height + * times for each pass. +*/ +PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +/* Invert monochrome files */ +PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_BACKGROUND_SUPPORTED +/* Handle alpha and tRNS by replacing with a background color. Prior to + * libpng-1.5.4 this API must not be called before the PNG file header has been + * read. Doing so will result in unexpected behavior and possible warnings or + * errors if the PNG file contains a bKGD chunk. + */ +PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, double background_gamma)) +PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structrp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, png_fixed_point background_gamma)) +#endif +#ifdef PNG_READ_BACKGROUND_SUPPORTED +# define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +# define PNG_BACKGROUND_GAMMA_SCREEN 1 +# define PNG_BACKGROUND_GAMMA_FILE 2 +# define PNG_BACKGROUND_GAMMA_UNIQUE 3 +#endif + +#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED +/* Scale a 16-bit depth file down to 8-bit, accurately. */ +PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED +#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */ +/* Strip the second byte of information from a 16-bit depth file. */ +PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_QUANTIZE_SUPPORTED +/* Turn on quantizing, and reduce the palette to the number of colors + * available. + */ +PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr, + png_colorp palette, int num_palette, int maximum_colors, + png_const_uint_16p histogram, int full_quantize)); +#endif + +#ifdef PNG_READ_GAMMA_SUPPORTED +/* The threshold on gamma processing is configurable but hard-wired into the + * library. The following is the floating point variant. + */ +#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001) + +/* Handle gamma correction. Screen_gamma=(display_exponent). + * NOTE: this API simply sets the screen and file gamma values. It will + * therefore override the value for gamma in a PNG file if it is called after + * the file header has been read - use with care - call before reading the PNG + * file for best results! + * + * These routines accept the same gamma values as png_set_alpha_mode (described + * above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either + * API (floating point or fixed.) Notice, however, that the 'file_gamma' value + * is the inverse of a 'screen gamma' value. + */ +PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr, + double screen_gamma, double override_file_gamma)) +PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structrp png_ptr, + png_fixed_point screen_gamma, png_fixed_point override_file_gamma)) +#endif + +#ifdef PNG_WRITE_FLUSH_SUPPORTED +/* Set how many lines between output flushes - 0 for no flushing */ +PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows)); +/* Flush the current PNG output buffer */ +PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr)); +#endif + +/* Optional update palette with requested transformations */ +PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr)); + +/* Optional call to update the users info structure */ +PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr, + png_inforp info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read one or more rows of image data. */ +PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row, + png_bytepp display_row, png_uint_32 num_rows)); +#endif + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read a row of data. */ +PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row, + png_bytep display_row)); +#endif + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the whole image into memory at once. */ +PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image)); +#endif + +/* Write a row of image data */ +PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr, + png_const_bytep row)); + +/* Write a few rows of image data: (*row) is not written; however, the type + * is declared as writeable to maintain compatibility with previous versions + * of libpng and to allow the 'display_row' array from read_rows to be passed + * unchanged to write_rows. + */ +PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row, + png_uint_32 num_rows)); + +/* Write the image data */ +PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image)); + +/* Write the end of the PNG file. */ +PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr, + png_inforp info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the end of the PNG file. */ +PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr)); +#endif + +/* Free any memory associated with the png_info_struct */ +PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr, + png_infopp info_ptr_ptr)); + +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); + +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr)); + +/* Set the libpng method of handling chunk CRC errors */ +PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action, + int ancil_action)); + +/* Values for png_set_crc_action() say how to handle CRC errors in + * ancillary and critical chunks, and whether to use the data contained + * therein. Note that it is impossible to "discard" data in a critical + * chunk. For versions prior to 0.90, the action was always error/quit, + * whereas in version 0.90 and later, the action for CRC errors in ancillary + * chunks is warn/discard. These values should NOT be changed. + * + * value action:critical action:ancillary + */ +#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ +#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ +#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ +#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ +#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ +#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ + +/* These functions give the user control over the scan-line filtering in + * libpng and the compression methods used by zlib. These functions are + * mainly useful for testing, as the defaults should work with most users. + * Those users who are tight on memory or want faster performance at the + * expense of compression can modify them. See the compression library + * header file (zlib.h) for an explination of the compression functions. + */ + +/* Set the filtering method(s) used by libpng. Currently, the only valid + * value for "method" is 0. + */ +PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method, + int filters)); + +/* Flags for png_set_filter() to say which filters to use. The flags + * are chosen so that they don't conflict with real filter types + * below, in case they are supplied instead of the #defined constants. + * These values should NOT be changed. + */ +#define PNG_NO_FILTERS 0x00 +#define PNG_FILTER_NONE 0x08 +#define PNG_FILTER_SUB 0x10 +#define PNG_FILTER_UP 0x20 +#define PNG_FILTER_AVG 0x40 +#define PNG_FILTER_PAETH 0x80 +#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ + PNG_FILTER_AVG | PNG_FILTER_PAETH) + +/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. + * These defines should NOT be changed. + */ +#define PNG_FILTER_VALUE_NONE 0 +#define PNG_FILTER_VALUE_SUB 1 +#define PNG_FILTER_VALUE_UP 2 +#define PNG_FILTER_VALUE_AVG 3 +#define PNG_FILTER_VALUE_PAETH 4 +#define PNG_FILTER_VALUE_LAST 5 + +#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* EXPERIMENTAL */ +/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ + * defines, either the default (minimum-sum-of-absolute-differences), or + * the experimental method (weighted-minimum-sum-of-absolute-differences). + * + * Weights are factors >= 1.0, indicating how important it is to keep the + * filter type consistent between rows. Larger numbers mean the current + * filter is that many times as likely to be the same as the "num_weights" + * previous filters. This is cumulative for each previous row with a weight. + * There needs to be "num_weights" values in "filter_weights", or it can be + * NULL if the weights aren't being specified. Weights have no influence on + * the selection of the first row filter. Well chosen weights can (in theory) + * improve the compression for a given image. + * + * Costs are factors >= 1.0 indicating the relative decoding costs of a + * filter type. Higher costs indicate more decoding expense, and are + * therefore less likely to be selected over a filter with lower computational + * costs. There needs to be a value in "filter_costs" for each valid filter + * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't + * setting the costs. Costs try to improve the speed of decompression without + * unduly increasing the compressed image size. + * + * A negative weight or cost indicates the default value is to be used, and + * values in the range [0.0, 1.0) indicate the value is to remain unchanged. + * The default values for both weights and costs are currently 1.0, but may + * change if good general weighting/cost heuristics can be found. If both + * the weights and costs are set to 1.0, this degenerates the WEIGHTED method + * to the UNWEIGHTED method, but with added encoding time/computation. + */ +PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr, + int heuristic_method, int num_weights, png_const_doublep filter_weights, + png_const_doublep filter_costs)) +PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed, + (png_structrp png_ptr, int heuristic_method, int num_weights, + png_const_fixed_point_p filter_weights, + png_const_fixed_point_p filter_costs)) +#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ + +/* Heuristic used for row filter selection. These defines should NOT be + * changed. + */ +#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ +#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ +#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ +#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ + +#ifdef PNG_WRITE_SUPPORTED +/* Set the library compression level. Currently, valid values range from + * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 + * (0 - no compression, 9 - "maximal" compression). Note that tests have + * shown that zlib compression levels 3-6 usually perform as well as level 9 + * for PNG images, and do considerably fewer caclulations. In the future, + * these values may not correspond directly to the zlib compression levels. + */ +PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr, + int level)); + +PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr, + int mem_level)); + +PNG_EXPORT(71, void, png_set_compression_strategy, (png_structrp png_ptr, + int strategy)); + +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr, + int window_bits)); + +PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr, + int method)); +#endif + +#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED +/* Also set zlib parameters for compressing non-IDAT chunks */ +PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr, + int level)); + +PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr, + int mem_level)); + +PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr, + int strategy)); + +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(225, void, png_set_text_compression_window_bits, + (png_structrp png_ptr, int window_bits)); + +PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr, + int method)); +#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ + +/* These next functions are called for input/output, memory, and error + * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, + * and call standard C I/O routines such as fread(), fwrite(), and + * fprintf(). These functions can be made to use other I/O routines + * at run time for those applications that need to handle I/O in a + * different manner by calling png_set_???_fn(). See libpng-manual.txt for + * more information. + */ + +#ifdef PNG_STDIO_SUPPORTED +/* Initialize the input/output for the PNG file to the default functions. */ +PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp)); +#endif + +/* Replace the (error and abort), and warning functions with user + * supplied functions. If no messages are to be printed you must still + * write and use replacement functions. The replacement error_fn should + * still do a longjmp to the last setjmp location if you are using this + * method of error handling. If error_fn or warning_fn is NULL, the + * default function will be used. + */ + +PNG_EXPORT(75, void, png_set_error_fn, (png_structrp png_ptr, + png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); + +/* Return the user pointer associated with the error functions */ +PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr)); + +/* Replace the default data output functions with a user supplied one(s). + * If buffered output is not used, then output_flush_fn can be set to NULL. + * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time + * output_flush_fn will be ignored (and thus can be NULL). + * It is probably a mistake to use NULL for output_flush_fn if + * write_data_fn is not also NULL unless you have built libpng with + * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's + * default flush function, which uses the standard *FILE structure, will + * be used. + */ +PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr, + png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); + +/* Replace the default data input function with a user supplied one. */ +PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr, + png_rw_ptr read_data_fn)); + +/* Return the user pointer associated with the I/O functions */ +PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr)); + +PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr, + png_read_status_ptr read_row_fn)); + +PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr, + png_write_status_ptr write_row_fn)); + +#ifdef PNG_USER_MEM_SUPPORTED +/* Replace the default memory allocation functions with user supplied one(s). */ +PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +/* Return the user pointer associated with the memory functions */ +PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr)); +#endif + +#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr, + png_user_transform_ptr read_user_transform_fn)); +#endif + +#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr, + png_user_transform_ptr write_user_transform_fn)); +#endif + +#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED +PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr, + png_voidp user_transform_ptr, int user_transform_depth, + int user_transform_channels)); +/* Return the user pointer associated with the user transform functions */ +PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr, + (png_const_structrp png_ptr)); +#endif + +#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED +/* Return information about the row currently being processed. Note that these + * APIs do not fail but will return unexpected results if called outside a user + * transform callback. Also note that when transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp)); +PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp)); +#endif + +#ifdef PNG_READ_USER_CHUNKS_SUPPORTED +/* This callback is called only for *unknown* chunks. If + * PNG_HANDLE_AS_UNKNOWN_SUPPORTED is set then it is possible to set known + * chunks to be treated as unknown, however in this case the callback must do + * any processing required by the chunk (e.g. by calling the appropriate + * png_set_ APIs.) + * + * There is no write support - on write, by default, all the chunks in the + * 'unknown' list are written in the specified position. + * + * The integer return from the callback function is interpreted thus: + * + * negative: An error occured, png_chunk_error will be called. + * zero: The chunk was not handled, the chunk will be saved. A critical + * chunk will cause an error at this point unless it is to be saved. + * positive: The chunk was handled, libpng will ignore/discard it. + * + * See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about + * how this behavior will change in libpng 1.7 + */ +PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr, + png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr)); +#endif + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +/* Sets the function callbacks for the push reader, and a pointer to a + * user-defined structure available to the callback functions. + */ +PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr, + png_voidp progressive_ptr, png_progressive_info_ptr info_fn, + png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)); + +/* Returns the user pointer associated with the push read functions */ +PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, + (png_const_structrp png_ptr)); + +/* Function to be called when data becomes available */ +PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr, + png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size)); + +/* A function which may be called *only* within png_process_data to stop the + * processing of any more data. The function returns the number of bytes + * remaining, excluding any that libpng has cached internally. A subsequent + * call to png_process_data must supply these bytes again. If the argument + * 'save' is set to true the routine will first save all the pending data and + * will always return 0. + */ +PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save)); + +/* A function which may be called *only* outside (after) a call to + * png_process_data. It returns the number of bytes of data to skip in the + * input. Normally it will return 0, but if it returns a non-zero value the + * application must skip than number of bytes of input data and pass the + * following data to the next call to png_process_data. + */ +PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp)); + +#ifdef PNG_READ_INTERLACING_SUPPORTED +/* Function that combines rows. 'new_row' is a flag that should come from + * the callback and be non-NULL if anything needs to be done; the library + * stores its own version of the new data internally and ignores the passed + * in value. + */ +PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr, + png_bytep old_row, png_const_bytep new_row)); +#endif /* PNG_READ_INTERLACING_SUPPORTED */ +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); +/* Added at libpng version 1.4.0 */ +PNG_EXPORTA(95, png_voidp, png_calloc, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); + +/* Added at libpng version 1.2.4 */ +PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); + +/* Frees a pointer allocated by png_malloc() */ +PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr)); + +/* Free data that was allocated internally */ +PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_32 free_me, int num)); + +/* Reassign responsibility for freeing existing data, whether allocated + * by libpng or by the application; this works on the png_info structure passed + * in, it does not change the state for other png_info structures. + * + * It is unlikely that this function works correctly as of 1.6.0 and using it + * may result either in memory leaks or double free of allocated data. + */ +PNG_EXPORTA(99, void, png_data_freer, (png_const_structrp png_ptr, + png_inforp info_ptr, int freer, png_uint_32 mask), PNG_DEPRECATED); + +/* 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 +#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_FREE_UNKN 0x0200 +#endif +/* PNG_FREE_LIST 0x0400 removed in 1.6.0 because it is ignored */ +#define PNG_FREE_PLTE 0x1000 +#define PNG_FREE_TRNS 0x2000 +#define PNG_FREE_TEXT 0x4000 +#define PNG_FREE_ALL 0x7fff +#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ + +#ifdef PNG_USER_MEM_SUPPORTED +PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED); +PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr, + png_voidp ptr), PNG_DEPRECATED); +#endif + +#ifdef PNG_ERROR_TEXT_SUPPORTED +/* Fatal error in PNG image of libpng - can't continue */ +PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr, + png_const_charp error_message), PNG_NORETURN); + +/* The same, but the chunk name is prepended to the error string. */ +PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr, + png_const_charp error_message), PNG_NORETURN); + +#else +/* Fatal error in PNG image of libpng - can't continue */ +PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN); +#endif + +#ifdef PNG_WARNINGS_SUPPORTED +/* Non-fatal error in libpng. Can continue, but may have a problem. */ +PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr, + png_const_charp warning_message)); + +/* Non-fatal error in libpng, chunk name is prepended to message. */ +PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr, + png_const_charp warning_message)); +#endif + +#ifdef PNG_BENIGN_ERRORS_SUPPORTED +/* Benign error in libpng. Can continue, but may have a problem. + * User can choose whether to handle as a fatal error or as a warning. */ +PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr, + png_const_charp warning_message)); + +#ifdef PNG_READ_SUPPORTED +/* Same, chunk name is prepended to message (only during read) */ +PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr, + png_const_charp warning_message)); +#endif + +PNG_EXPORT(109, void, png_set_benign_errors, + (png_structrp png_ptr, int allowed)); +#else +# ifdef PNG_ALLOW_BENIGN_ERRORS +# define png_benign_error png_warning +# define png_chunk_benign_error png_chunk_warning +# else +# define png_benign_error png_error +# define png_chunk_benign_error png_chunk_error +# endif +#endif + +/* The png_set_ functions are for storing values in the png_info_struct. + * Similarly, the png_get_ calls are used to read values from the + * png_info_struct, either storing the parameters in the passed variables, or + * setting pointers into the png_info_struct where the data is stored. The + * png_get_ functions return a non-zero value if the data was available + * in info_ptr, or return zero and do not change any of the parameters if the + * data was not available. + * + * These functions should be used instead of directly accessing png_info + * to avoid problems with future changes in the size and internal layout of + * png_info_struct. + */ +/* Returns "flag" if chunk data is valid in info_ptr. */ +PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 flag)); + +/* Returns number of bytes needed to hold a transformed row. */ +PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +#ifdef PNG_INFO_IMAGE_SUPPORTED +/* Returns row_pointers, which is an array of pointers to scanlines that was + * returned from png_read_png(). + */ +PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Set row_pointers, which is an array of pointers to scanlines for use + * by png_write_png(). + */ +PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr, + png_inforp info_ptr, png_bytepp row_pointers)); +#endif + +/* Returns number of color channels in image. */ +PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +#ifdef PNG_EASY_ACCESS_SUPPORTED +/* Returns image width in pixels. */ +PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image height in pixels. */ +PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image bit_depth. */ +PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image color_type. */ +PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image filter_type. */ +PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image interlace_type. */ +PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image compression_type. */ +PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image resolution in pixels per meter, from pHYs chunk data. */ +PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +/* Returns pixel aspect ratio, computed from pHYs chunk data. */ +PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) + +/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(128, png_int_32, png_get_x_offset_microns, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +#endif /* PNG_EASY_ACCESS_SUPPORTED */ + +#ifdef PNG_READ_SUPPORTED +/* Returns pointer to signature string read from PNG header */ +PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); +#endif + +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr, + png_inforp info_ptr, png_color_16p *background)); +#endif + +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_color_16p background)); +#endif + +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structrp png_ptr, + png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x, + double *red_y, double *green_x, double *green_y, double *blue_x, + double *blue_y)) +PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_const_structrp png_ptr, + png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z, + double *green_X, double *green_Y, double *green_Z, double *blue_X, + double *blue_Y, double *blue_Z)) +PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, + png_fixed_point *int_white_x, png_fixed_point *int_white_y, + png_fixed_point *int_red_x, png_fixed_point *int_red_y, + png_fixed_point *int_green_x, png_fixed_point *int_green_y, + png_fixed_point *int_blue_x, png_fixed_point *int_blue_y)) +PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, + png_fixed_point *int_red_X, png_fixed_point *int_red_Y, + png_fixed_point *int_red_Z, png_fixed_point *int_green_X, + png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, + png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, + png_fixed_point *int_blue_Z)) +#endif + +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr, + png_inforp info_ptr, + double white_x, double white_y, double red_x, double red_y, double green_x, + double green_y, double blue_x, double blue_y)) +PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_const_structrp png_ptr, + png_inforp info_ptr, double red_X, double red_Y, double red_Z, + double green_X, double green_Y, double green_Z, double blue_X, + double blue_Y, double blue_Z)) +PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, png_fixed_point int_white_x, + png_fixed_point int_white_y, png_fixed_point int_red_x, + png_fixed_point int_red_y, png_fixed_point int_green_x, + png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)) +PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, + png_fixed_point int_red_Z, png_fixed_point int_green_X, + png_fixed_point int_green_Y, png_fixed_point int_green_Z, + png_fixed_point int_blue_X, png_fixed_point int_blue_Y, + png_fixed_point int_blue_Z)) +#endif + +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, (png_const_structrp png_ptr, + png_const_inforp info_ptr, double *file_gamma)) +PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, + png_fixed_point *int_file_gamma)) +#endif + +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr, + png_inforp info_ptr, double file_gamma)) +PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, png_fixed_point int_file_gamma)) +#endif + +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_16p *hist)); +#endif + +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_uint_16p hist)); +#endif + +PNG_EXPORT(143, png_uint_32, png_get_IHDR, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height, + int *bit_depth, int *color_type, int *interlace_method, + int *compression_method, int *filter_method)); + +PNG_EXPORT(144, void, png_set_IHDR, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, + int color_type, int interlace_method, int compression_method, + int filter_method)); + +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, + int *unit_type)); +#endif + +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr, + png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y, + int unit_type)); +#endif + +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr, + png_inforp info_ptr, png_charp *purpose, png_int_32 *X0, + png_int_32 *X1, int *type, int *nparams, png_charp *units, + png_charpp *params)); +#endif + +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1, + int type, int nparams, png_const_charp units, png_charpp params)); +#endif + +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, + int *unit_type)); +#endif + +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +#endif + +PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr, + png_inforp info_ptr, png_colorp *palette, int *num_palette)); + +PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr, + png_inforp info_ptr, png_const_colorp palette, int num_palette)); + +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_color_8p *sig_bit)); +#endif + +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_color_8p sig_bit)); +#endif + +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr, + png_const_inforp info_ptr, int *file_srgb_intent)); +#endif + +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr, + png_inforp info_ptr, int srgb_intent)); +PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr, + png_inforp info_ptr, int srgb_intent)); +#endif + +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr, + png_inforp info_ptr, png_charpp name, int *compression_type, + png_bytepp profile, png_uint_32 *proflen)); +#endif + +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_charp name, int compression_type, + png_const_bytep profile, png_uint_32 proflen)); +#endif + +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_sPLT_tpp entries)); +#endif + +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_sPLT_tp entries, int nentries)); +#endif + +#ifdef PNG_TEXT_SUPPORTED +/* png_get_text also returns the number of text chunks in *num_text */ +PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr, + png_inforp info_ptr, png_textp *text_ptr, int *num_text)); +#endif + +/* Note while png_set_text() will accept a structure whose text, + * language, and translated keywords are NULL pointers, the structure + * returned by png_get_text will always contain regular + * zero-terminated C strings. They might be empty strings but + * they will never be NULL pointers. + */ + +#ifdef PNG_TEXT_SUPPORTED +PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_textp text_ptr, int num_text)); +#endif + +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr, + png_inforp info_ptr, png_timep *mod_time)); +#endif + +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_timep mod_time)); +#endif + +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr, + png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans, + png_color_16p *trans_color)); +#endif + +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr, + png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans, + png_const_color_16p trans_color)); +#endif + +#ifdef PNG_sCAL_SUPPORTED +PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr, + png_const_inforp info_ptr, int *unit, double *width, double *height)) +#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \ + defined(PNG_FLOATING_POINT_SUPPORTED) +/* NOTE: this API is currently implemented using floating point arithmetic, + * consequently it can only be used on systems with floating point support. + * In any case the range of values supported by png_fixed_point is small and it + * is highly recommended that png_get_sCAL_s be used instead. + */ +PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, + png_fixed_point *width, png_fixed_point *height)) +#endif +PNG_EXPORT(169, png_uint_32, png_get_sCAL_s, + (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, + png_charpp swidth, png_charpp sheight)); + +PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr, + png_inforp info_ptr, int unit, double width, double height)) +PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, int unit, png_fixed_point width, + png_fixed_point height)) +PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr, + png_inforp info_ptr, int unit, + png_const_charp swidth, png_const_charp sheight)); +#endif /* PNG_sCAL_SUPPORTED */ + +#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED +/* Provide the default handling for all unknown chunks or, optionally, for + * specific unknown chunks. + * + * NOTE: prior to 1.6.0 the handling specified for particular chunks on read was + * ignored and the default was used, the per-chunk setting only had an effect on + * write. If you wish to have chunk-specific handling on read in code that must + * work on earlier versions you must use a user chunk callback to specify the + * desired handling (keep or discard.) + * + * The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below. The + * parameter is interpreted as follows: + * + * READ: + * PNG_HANDLE_CHUNK_AS_DEFAULT: + * Known chunks: do normal libpng processing, do not keep the chunk (but + * see the comments below about PNG_HANDLE_AS_UNKNOWN_SUPPORTED) + * Unknown chunks: for a specific chunk use the global default, when used + * as the default discard the chunk data. + * PNG_HANDLE_CHUNK_NEVER: + * Discard the chunk data. + * PNG_HANDLE_CHUNK_IF_SAFE: + * Keep the chunk data if the chunk is not critical else raise a chunk + * error. + * PNG_HANDLE_CHUNK_ALWAYS: + * Keep the chunk data. + * + * If the chunk data is saved it can be retrieved using png_get_unknown_chunks, + * below. Notice that specifying "AS_DEFAULT" as a global default is equivalent + * to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks + * it simply resets the behavior to the libpng default. + * + * INTERACTION WTIH USER CHUNK CALLBACKS: + * The per-chunk handling is always used when there is a png_user_chunk_ptr + * callback and the callback returns 0; the chunk is then always stored *unless* + * it is critical and the per-chunk setting is other than ALWAYS. Notice that + * the global default is *not* used in this case. (In effect the per-chunk + * value is incremented to at least IF_SAFE.) + * + * IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and + * per-chunk defaults will be honored. If you want to preserve the current + * behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE + * as the default - if you don't do this libpng 1.6 will issue a warning. + * + * If you want unhandled unknown chunks to be discarded in libpng 1.6 and + * earlier simply return '1' (handled). + * + * PNG_HANDLE_AS_UNKNOWN_SUPPORTED: + * If this is *not* set known chunks will always be handled by libpng and + * will never be stored in the unknown chunk list. Known chunks listed to + * png_set_keep_unknown_chunks will have no effect. If it is set then known + * chunks listed with a keep other than AS_DEFAULT will *never* be processed + * by libpng, in addition critical chunks must either be processed by the + * callback or saved. + * + * The IHDR and IEND chunks must not be listed. Because this turns off the + * default handling for chunks that would otherwise be recognized the + * behavior of libpng transformations may well become incorrect! + * + * WRITE: + * When writing chunks the options only apply to the chunks specified by + * png_set_unknown_chunks (below), libpng will *always* write known chunks + * required by png_set_ calls and will always write the core critical chunks + * (as required for PLTE). + * + * Each chunk in the png_set_unknown_chunks list is looked up in the + * png_set_keep_unknown_chunks list to find the keep setting, this is then + * interpreted as follows: + * + * PNG_HANDLE_CHUNK_AS_DEFAULT: + * Write safe-to-copy chunks and write other chunks if the global + * default is set to _ALWAYS, otherwise don't write this chunk. + * PNG_HANDLE_CHUNK_NEVER: + * Do not write the chunk. + * PNG_HANDLE_CHUNK_IF_SAFE: + * Write the chunk if it is safe-to-copy, otherwise do not write it. + * PNG_HANDLE_CHUNK_ALWAYS: + * Write the chunk. + * + * Note that the default behavior is effectively the opposite of the read case - + * in read unknown chunks are not stored by default, in write they are written + * by default. Also the behavior of PNG_HANDLE_CHUNK_IF_SAFE is very different + * - on write the safe-to-copy bit is checked, on read the critical bit is + * checked and on read if the chunk is critical an error will be raised. + * + * num_chunks: + * =========== + * If num_chunks is positive, then the "keep" parameter specifies the manner + * for handling only those chunks appearing in the chunk_list array, + * otherwise the chunk list array is ignored. + * + * If num_chunks is 0 the "keep" parameter specifies the default behavior for + * unknown chunks, as described above. + * + * If num_chunks is negative, then the "keep" parameter specifies the manner + * for handling all unknown chunks plus all chunks recognized by libpng + * except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to + * be processed by libpng. + */ +PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr, + int keep, png_const_bytep chunk_list, int num_chunks)); + +/* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned; + * the result is therefore true (non-zero) if special handling is required, + * false for the default handling. + */ +PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr, + png_const_bytep chunk_name)); +#endif + +#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED +PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_unknown_chunkp unknowns, + int num_unknowns)); + /* NOTE: prior to 1.6.0 this routine set the 'location' field of the added + * unknowns to the location currently stored in the png_struct. This is + * invariably the wrong value on write. To fix this call the following API + * for each chunk in the list with the correct location. If you know your + * code won't be compiled on earlier versions you can rely on + * png_set_unknown_chunks(write-ptr, png_get_unknown_chunks(read-ptr)) doing + * the correct thing. + */ + +PNG_EXPORT(175, void, png_set_unknown_chunk_location, + (png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location)); + +PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structrp png_ptr, + png_inforp info_ptr, png_unknown_chunkpp entries)); +#endif + +/* Png_free_data() will turn off the "valid" flag for anything it frees. + * If you need to turn it off for a chunk that your application has freed, + * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); + */ +PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr, + png_inforp info_ptr, int mask)); + +#ifdef PNG_INFO_IMAGE_SUPPORTED +/* The "params" pointer is currently not used and is for future expansion. */ +PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr, + int transforms, png_voidp params)); +PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr, + int transforms, png_voidp params)); +#endif + +PNG_EXPORT(180, png_const_charp, png_get_copyright, + (png_const_structrp png_ptr)); +PNG_EXPORT(181, png_const_charp, png_get_header_ver, + (png_const_structrp png_ptr)); +PNG_EXPORT(182, png_const_charp, png_get_header_version, + (png_const_structrp png_ptr)); +PNG_EXPORT(183, png_const_charp, png_get_libpng_ver, + (png_const_structrp png_ptr)); + +#ifdef PNG_MNG_FEATURES_SUPPORTED +PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr, + png_uint_32 mng_features_permitted)); +#endif + +/* For use in png_set_keep_unknown, added to version 1.2.6 */ +#define PNG_HANDLE_CHUNK_AS_DEFAULT 0 +#define PNG_HANDLE_CHUNK_NEVER 1 +#define PNG_HANDLE_CHUNK_IF_SAFE 2 +#define PNG_HANDLE_CHUNK_ALWAYS 3 +#define PNG_HANDLE_CHUNK_LAST 4 + +/* Strip the prepended error numbers ("#nnn ") from error and warning + * messages before passing them to the error or warning handler. + */ +#ifdef PNG_ERROR_NUMBERS_SUPPORTED +PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr, + png_uint_32 strip_mode)); +#endif + +/* Added in libpng-1.2.6 */ +#ifdef PNG_SET_USER_LIMITS_SUPPORTED +PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr, + png_uint_32 user_width_max, png_uint_32 user_height_max)); +PNG_EXPORT(187, png_uint_32, png_get_user_width_max, + (png_const_structrp png_ptr)); +PNG_EXPORT(188, png_uint_32, png_get_user_height_max, + (png_const_structrp png_ptr)); +/* Added in libpng-1.4.0 */ +PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr, + png_uint_32 user_chunk_cache_max)); +PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max, + (png_const_structrp png_ptr)); +/* Added in libpng-1.4.1 */ +PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr, + png_alloc_size_t user_chunk_cache_max)); +PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max, + (png_const_structrp png_ptr)); +#endif + +#if defined(PNG_INCH_CONVERSIONS_SUPPORTED) +PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +PNG_FP_EXPORT(196, float, png_get_x_offset_inches, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +#endif + +PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structrp png_ptr, + png_const_inforp info_ptr)) +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +#endif + +# ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, + int *unit_type)); +# endif /* PNG_pHYs_SUPPORTED */ +#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ + +/* Added in libpng-1.4.0 */ +#ifdef PNG_IO_STATE_SUPPORTED +PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr)); + +/* Removed from libpng 1.6; use png_get_io_chunk_type. */ +PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr), + PNG_DEPRECATED) + +PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type, + (png_const_structrp png_ptr)); + +/* The flags returned by png_get_io_state() are the following: */ +# define PNG_IO_NONE 0x0000 /* no I/O at this moment */ +# define PNG_IO_READING 0x0001 /* currently reading */ +# define PNG_IO_WRITING 0x0002 /* currently writing */ +# define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */ +# define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */ +# define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */ +# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ +# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ +# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ +#endif /* ?PNG_IO_STATE_SUPPORTED */ + +/* Interlace support. The following macros are always defined so that if + * libpng interlace handling is turned off the macros may be used to handle + * interlaced images within the application. + */ +#define PNG_INTERLACE_ADAM7_PASSES 7 + +/* Two macros to return the first row and first column of the original, + * full, image which appears in a given pass. 'pass' is in the range 0 + * to 6 and the result is in the range 0 to 7. + */ +#define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7) +#define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7) + +/* A macro to return the offset between pixels in the output row for a pair of + * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that + * follows. Note that ROW_OFFSET is the offset from one row to the next whereas + * COL_OFFSET is from one column to the next, within a row. + */ +#define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8) +#define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1)) + +/* Two macros to help evaluate the number of rows or columns in each + * pass. This is expressed as a shift - effectively log2 of the number or + * rows or columns in each 8x8 tile of the original image. + */ +#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3) +#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3) + +/* Hence two macros to determine the number of rows or columns in a given + * pass of an image given its height or width. In fact these macros may + * return non-zero even though the sub-image is empty, because the other + * dimension may be empty for a small image. + */ +#define PNG_PASS_ROWS(height, pass) (((height)+(((1<>PNG_PASS_ROW_SHIFT(pass)) +#define PNG_PASS_COLS(width, pass) (((width)+(((1<>PNG_PASS_COL_SHIFT(pass)) + +/* For the reader row callbacks (both progressive and sequential) it is + * necessary to find the row in the output image given a row in an interlaced + * image, so two more macros: + */ +#define PNG_ROW_FROM_PASS_ROW(y_in, pass) \ + (((y_in)<>(((7-(off))-(pass))<<2)) & 0xF) | \ + ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0)) + +#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \ + ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1) +#define PNG_COL_IN_INTERLACE_PASS(x, pass) \ + ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1) + +#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED +/* With these routines we avoid an integer divide, which will be slower on + * most machines. However, it does take more operations than the corresponding + * divide method, so it may be slower on a few RISC systems. There are two + * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. + * + * Note that the rounding factors are NOT supposed to be the same! 128 and + * 32768 are correct for the NODIV code; 127 and 32767 are correct for the + * standard method. + * + * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] + */ + + /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ + +# define png_composite(composite, fg, alpha, bg) \ + { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \ + * (png_uint_16)(alpha) \ + + (png_uint_16)(bg)*(png_uint_16)(255 \ + - (png_uint_16)(alpha)) + 128); \ + (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } + +# define png_composite_16(composite, fg, alpha, bg) \ + { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \ + * (png_uint_32)(alpha) \ + + (png_uint_32)(bg)*(65535 \ + - (png_uint_32)(alpha)) + 32768); \ + (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } + +#else /* Standard method using integer division */ + +# define png_composite(composite, fg, alpha, bg) \ + (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ + (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ + 127) / 255) + +# define png_composite_16(composite, fg, alpha, bg) \ + (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ + (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ + 32767) / 65535) +#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ + +#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf)); +PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf)); +PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf)); +#endif + +PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr, + png_const_bytep buf)); +/* No png_get_int_16 -- may be added if there's a real need for it. */ + +/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */ +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i)); +#endif +#ifdef PNG_SAVE_INT_32_SUPPORTED +PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i)); +#endif + +/* Place a 16-bit number into a buffer in PNG byte order. + * The parameter is declared unsigned int, not png_uint_16, + * just to avoid potential problems on pre-ANSI C compilers. + */ +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i)); +/* No png_save_int_16 -- may be added if there's a real need for it. */ +#endif + +#ifdef PNG_USE_READ_MACROS +/* Inline macros to do direct reads of bytes from the input buffer. + * The png_get_int_32() routine assumes we are using two's complement + * format for negative values, which is almost certainly true. + */ +# define PNG_get_uint_32(buf) \ + (((png_uint_32)(*(buf)) << 24) + \ + ((png_uint_32)(*((buf) + 1)) << 16) + \ + ((png_uint_32)(*((buf) + 2)) << 8) + \ + ((png_uint_32)(*((buf) + 3)))) + + /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the + * function) incorrectly returned a value of type png_uint_32. + */ +# define PNG_get_uint_16(buf) \ + ((png_uint_16) \ + (((unsigned int)(*(buf)) << 8) + \ + ((unsigned int)(*((buf) + 1))))) + +# define PNG_get_int_32(buf) \ + ((png_int_32)((*(buf) & 0x80) \ + ? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \ + : (png_int_32)png_get_uint_32(buf))) + + /* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h, + * but defining a macro name prefixed with PNG_PREFIX. + */ +# ifndef PNG_PREFIX +# define png_get_uint_32(buf) PNG_get_uint_32(buf) +# define png_get_uint_16(buf) PNG_get_uint_16(buf) +# define png_get_int_32(buf) PNG_get_int_32(buf) +# endif +#else +# ifdef PNG_PREFIX + /* No macros; revert to the (redefined) function */ +# define PNG_get_uint_32 (png_get_uint_32) +# define PNG_get_uint_16 (png_get_uint_16) +# define PNG_get_int_32 (png_get_int_32) +# endif +#endif + +/******************************************************************************* + * SIMPLIFIED API + ******************************************************************************* + * + * Please read the documentation in libpng-manual.txt (TODO: write said + * documentation) if you don't understand what follows. + * + * The simplified API hides the details of both libpng and the PNG file format + * itself. It allows PNG files to be read into a very limited number of + * in-memory bitmap formats or to be written from the same formats. If these + * formats do not accomodate your needs then you can, and should, use the more + * sophisticated APIs above - these support a wide variety of in-memory formats + * and a wide variety of sophisticated transformations to those formats as well + * as a wide variety of APIs to manipulate ancillary information. + * + * To read a PNG file using the simplified API: + * + * 1) Declare a 'png_image' structure (see below) on the stack and set the + * version field to PNG_IMAGE_VERSION. + * 2) Call the appropriate png_image_begin_read... function. + * 3) Set the png_image 'format' member to the required sample format. + * 4) Allocate a buffer for the image and, if required, the color-map. + * 5) Call png_image_finish_read to read the image and, if required, the + * color-map into your buffers. + * + * There are no restrictions on the format of the PNG input itself; all valid + * color types, bit depths, and interlace methods are acceptable, and the + * input image is transformed as necessary to the requested in-memory format + * during the png_image_finish_read() step. The only caveat is that if you + * request a color-mapped image from a PNG that is full-color or makes + * complex use of an alpha channel the transformation is extremely lossy and the + * result may look terrible. + * + * To write a PNG file using the simplified API: + * + * 1) Declare a 'png_image' structure on the stack and memset() it to all zero. + * 2) Initialize the members of the structure that describe the image, setting + * the 'format' member to the format of the image samples. + * 3) Call the appropriate png_image_write... function with a pointer to the + * image and, if necessary, the color-map to write the PNG data. + * + * png_image is a structure that describes the in-memory format of an image + * when it is being read or defines the in-memory format of an image that you + * need to write: + */ +#define PNG_IMAGE_VERSION 1 + +typedef struct png_control *png_controlp; +typedef struct +{ + png_controlp opaque; /* Initialize to NULL, free with png_image_free */ + png_uint_32 version; /* Set to PNG_IMAGE_VERSION */ + png_uint_32 width; /* Image width in pixels (columns) */ + png_uint_32 height; /* Image height in pixels (rows) */ + png_uint_32 format; /* Image format as defined below */ + png_uint_32 flags; /* A bit mask containing informational flags */ + png_uint_32 colormap_entries; + /* Number of entries in the color-map */ + + /* In the event of an error or warning the following field will be set to a + * non-zero value and the 'message' field will contain a '\0' terminated + * string with the libpng error or warning message. If both warnings and + * an error were encountered, only the error is recorded. If there + * are multiple warnings, only the first one is recorded. + * + * The upper 30 bits of this value are reserved, the low two bits contain + * a value as follows: + */ +# define PNG_IMAGE_WARNING 1 +# define PNG_IMAGE_ERROR 2 + /* + * The result is a two bit code such that a value more than 1 indicates + * a failure in the API just called: + * + * 0 - no warning or error + * 1 - warning + * 2 - error + * 3 - error preceded by warning + */ +# define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1) + + png_uint_32 warning_or_error; + + char message[64]; +} png_image, *png_imagep; + +/* The samples of the image have one to four channels whose components have + * original values in the range 0 to 1.0: + * + * 1: A single gray or luminance channel (G). + * 2: A gray/luminance channel and an alpha channel (GA). + * 3: Three red, green, blue color channels (RGB). + * 4: Three color channels and an alpha channel (RGBA). + * + * The components are encoded in one of two ways: + * + * a) As a small integer, value 0..255, contained in a single byte. For the + * alpha channel the original value is simply value/255. For the color or + * luminance channels the value is encoded according to the sRGB specification + * and matches the 8-bit format expected by typical display devices. + * + * The color/gray channels are not scaled (pre-multiplied) by the alpha + * channel and are suitable for passing to color management software. + * + * b) As a value in the range 0..65535, contained in a 2-byte integer. All + * channels can be converted to the original value by dividing by 65535; all + * channels are linear. Color channels use the RGB encoding (RGB end-points) of + * the sRGB specification. This encoding is identified by the + * PNG_FORMAT_FLAG_LINEAR flag below. + * + * When the simplified API needs to convert between sRGB and linear colorspaces, + * the actual sRGB transfer curve defined in the sRGB specification (see the + * article at http://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2 + * approximation used elsewhere in libpng. + * + * When an alpha channel is present it is expected to denote pixel coverage + * of the color or luminance channels and is returned as an associated alpha + * channel: the color/gray channels are scaled (pre-multiplied) by the alpha + * value. + * + * The samples are either contained directly in the image data, between 1 and 8 + * bytes per pixel according to the encoding, or are held in a color-map indexed + * by bytes in the image data. In the case of a color-map the color-map entries + * are individual samples, encoded as above, and the image data has one byte per + * pixel to select the relevant sample from the color-map. + */ + +/* PNG_FORMAT_* + * + * #defines to be used in png_image::format. Each #define identifies a + * particular layout of sample data and, if present, alpha values. There are + * separate defines for each of the two component encodings. + * + * A format is built up using single bit flag values. All combinations are + * valid. Formats can be built up from the flag values or you can use one of + * the predefined values below. When testing formats always use the FORMAT_FLAG + * macros to test for individual features - future versions of the library may + * add new flags. + * + * When reading or writing color-mapped images the format should be set to the + * format of the entries in the color-map then png_image_{read,write}_colormap + * called to read or write the color-map and set the format correctly for the + * image data. Do not set the PNG_FORMAT_FLAG_COLORMAP bit directly! + * + * NOTE: libpng can be built with particular features disabled, if you see + * compiler errors because the definition of one of the following flags has been + * compiled out it is because libpng does not have the required support. It is + * possible, however, for the libpng configuration to enable the format on just + * read or just write; in that case you may see an error at run time. You can + * guard against this by checking for the definition of the appropriate + * "_SUPPORTED" macro, one of: + * + * PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED + */ +#define PNG_FORMAT_FLAG_ALPHA 0x01U /* format with an alpha channel */ +#define PNG_FORMAT_FLAG_COLOR 0x02U /* color format: otherwise grayscale */ +#define PNG_FORMAT_FLAG_LINEAR 0x04U /* 2 byte channels else 1 byte */ +#define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */ + +#ifdef PNG_FORMAT_BGR_SUPPORTED +# define PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */ +#endif + +#ifdef PNG_FORMAT_AFIRST_SUPPORTED +# define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */ +#endif + +/* Commonly used formats have predefined macros. + * + * First the single byte (sRGB) formats: + */ +#define PNG_FORMAT_GRAY 0 +#define PNG_FORMAT_GA PNG_FORMAT_FLAG_ALPHA +#define PNG_FORMAT_AG (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST) +#define PNG_FORMAT_RGB PNG_FORMAT_FLAG_COLOR +#define PNG_FORMAT_BGR (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR) +#define PNG_FORMAT_RGBA (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA) +#define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST) +#define PNG_FORMAT_BGRA (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA) +#define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST) + +/* Then the linear 2-byte formats. When naming these "Y" is used to + * indicate a luminance (gray) channel. + */ +#define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR +#define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA) +#define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR) +#define PNG_FORMAT_LINEAR_RGB_ALPHA \ + (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA) + +/* With color-mapped formats the image data is one byte for each pixel, the byte + * is an index into the color-map which is formatted as above. To obtain a + * color-mapped format it is sufficient just to add the PNG_FOMAT_FLAG_COLORMAP + * to one of the above definitions, or you can use one of the definitions below. + */ +#define PNG_FORMAT_RGB_COLORMAP (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_BGR_COLORMAP (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP) + +/* PNG_IMAGE macros + * + * These are convenience macros to derive information from a png_image + * structure. The PNG_IMAGE_SAMPLE_ macros return values appropriate to the + * actual image sample values - either the entries in the color-map or the + * pixels in the image. The PNG_IMAGE_PIXEL_ macros return corresponding values + * for the pixels and will always return 1 for color-mapped formats. The + * remaining macros return information about the rows in the image and the + * complete image. + * + * NOTE: All the macros that take a png_image::format parameter are compile time + * constants if the format parameter is, itself, a constant. Therefore these + * macros can be used in array declarations and case labels where required. + * Similarly the macros are also pre-processor constants (sizeof is not used) so + * they can be used in #if tests. + * + * First the information about the samples. + */ +#define PNG_IMAGE_SAMPLE_CHANNELS(fmt)\ + (((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1) + /* Return the total number of channels in a given format: 1..4 */ + +#define PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)\ + ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1) + /* Return the size in bytes of a single component of a pixel or color-map + * entry (as appropriate) in the image: 1 or 2. + */ + +#define PNG_IMAGE_SAMPLE_SIZE(fmt)\ + (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)) + /* This is the size of the sample data for one sample. If the image is + * color-mapped it is the size of one color-map entry (and image pixels are + * one byte in size), otherwise it is the size of one image pixel. + */ + +#define PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt)\ + (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256) + /* The maximum size of the color-map required by the format expressed in a + * count of components. This can be used to compile-time allocate a + * color-map: + * + * png_uint_16 colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(linear_fmt)]; + * + * png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)]; + * + * Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro below to use the + * information from one of the png_image_begin_read_ APIs and dynamically + * allocate the required memory. + */ + +/* Corresponding information about the pixels */ +#define PNG_IMAGE_PIXEL_(test,fmt)\ + (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt)) + +#define PNG_IMAGE_PIXEL_CHANNELS(fmt)\ + PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt) + /* The number of separate channels (components) in a pixel; 1 for a + * color-mapped image. + */ + +#define PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)\ + PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt) + /* The size, in bytes, of each component in a pixel; 1 for a color-mapped + * image. + */ + +#define PNG_IMAGE_PIXEL_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt) + /* The size, in bytes, of a complete pixel; 1 for a color-mapped image. */ + +/* Information about the whole row, or whole image */ +#define PNG_IMAGE_ROW_STRIDE(image)\ + (PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width) + /* Return the total number of components in a single row of the image; this + * is the minimum 'row stride', the minimum count of components between each + * row. For a color-mapped image this is the minimum number of bytes in a + * row. + */ + +#define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\ + (PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride)) + /* Return the size, in bytes, of an image buffer given a png_image and a row + * stride - the number of components to leave space for in each row. + */ + +#define PNG_IMAGE_SIZE(image)\ + PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image)) + /* Return the size, in bytes, of the image in memory given just a png_image; + * the row stride is the minimum stride required for the image. + */ + +#define PNG_IMAGE_COLORMAP_SIZE(image)\ + (PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries) + /* Return the size, in bytes, of the color-map of this image. If the image + * format is not a color-map format this will return a size sufficient for + * 256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if + * you don't want to allocate a color-map in this case. + */ + +/* PNG_IMAGE_FLAG_* + * + * Flags containing additional information about the image are held in the + * 'flags' field of png_image. + */ +#define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01 + /* This indicates the the RGB values of the in-memory bitmap do not + * correspond to the red, green and blue end-points defined by sRGB. + */ + +#define PNG_IMAGE_FLAG_FAST 0x02 + /* On write emphasise speed over compression; the resultant PNG file will be + * larger but will be produced significantly faster, particular for large + * images. Do not use this option for images which will be distributed, only + * used it when producing intermediate files that will be read back in + * repeatedly. For a typical 24-bit image the option will double the read + * speed at the cost of increasing the image size by 25%, however for many + * more compressible images the PNG file can be 10 times larger with only a + * slight speed gain. + */ + +#define PNG_IMAGE_FLAG_16BIT_sRGB 0x04 + /* On read if the image is a 16-bit per component image and there is no gAMA + * or sRGB chunk assume that the components are sRGB encoded. Notice that + * images output by the simplified API always have gamma information; setting + * this flag only affects the interpretation of 16-bit images from an + * external source. It is recommended that the application expose this flag + * to the user; the user can normally easily recognize the difference between + * linear and sRGB encoding. This flag has no effect on write - the data + * passed to the write APIs must have the correct encoding (as defined + * above.) + * + * If the flag is not set (the default) input 16-bit per component data is + * assumed to be linear. + * + * NOTE: the flag can only be set after the png_image_begin_read_ call, + * because that call initializes the 'flags' field. + */ + +#ifdef PNG_SIMPLIFIED_READ_SUPPORTED +/* READ APIs + * --------- + * + * The png_image passed to the read APIs must have been initialized by setting + * the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.) + */ +#ifdef PNG_STDIO_SUPPORTED +PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image, + const char *file_name)); + /* The named file is opened for read and the image header is filled in + * from the PNG header in the file. + */ + +PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image, + FILE* file)); + /* The PNG header is read from the stdio FILE object. */ +#endif /* PNG_STDIO_SUPPORTED */ + +PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image, + png_const_voidp memory, png_size_t size)); + /* The PNG header is read from the given memory buffer. */ + +PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image, + png_const_colorp background, void *buffer, png_int_32 row_stride, + void *colormap)); + /* Finish reading the image into the supplied buffer and clean up the + * png_image structure. + * + * row_stride is the step, in byte or 2-byte units as appropriate, + * between adjacent rows. A positive stride indicates that the top-most row + * is first in the buffer - the normal top-down arrangement. A negative + * stride indicates that the bottom-most row is first in the buffer. + * + * background need only be supplied if an alpha channel must be removed from + * a png_byte format and the removal is to be done by compositing on a solid + * color; otherwise it may be NULL and any composition will be done directly + * onto the buffer. The value is an sRGB color to use for the background, + * for grayscale output the green channel is used. + * + * background must be supplied when an alpha channel must be removed from a + * single byte color-mapped output format, in other words if: + * + * 1) The original format from png_image_begin_read_from_* had + * PNG_FORMAT_FLAG_ALPHA set. + * 2) The format set by the application does not. + * 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and + * PNG_FORMAT_FLAG_LINEAR *not* set. + * + * For linear output removing the alpha channel is always done by compositing + * on black and background is ignored. + * + * colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set. It must + * be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE. + * image->colormap_entries will be updated to the actual number of entries + * written to the colormap; this may be less than the original value. + */ + +PNG_EXPORT(238, void, png_image_free, (png_imagep image)); + /* Free any data allocated by libpng in image->opaque, setting the pointer to + * NULL. May be called at any time after the structure is initialized. + */ +#endif /* PNG_SIMPLIFIED_READ_SUPPORTED */ + +#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED +#ifdef PNG_STDIO_SUPPORTED +/* WRITE APIS + * ---------- + * For write you must initialize a png_image structure to describe the image to + * be written. To do this use memset to set the whole structure to 0 then + * initialize fields describing your image. + * + * version: must be set to PNG_IMAGE_VERSION + * opaque: must be initialized to NULL + * width: image width in pixels + * height: image height in rows + * format: the format of the data (image and color-map) you wish to write + * flags: set to 0 unless one of the defined flags applies; set + * PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB for color format images where the RGB + * values do not correspond to the colors in sRGB. + * colormap_entries: set to the number of entries in the color-map (0 to 256) + */ +PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image, + const char *file, int convert_to_8bit, const void *buffer, + png_int_32 row_stride, const void *colormap)); + /* Write the image to the named file. */ + +PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file, + int convert_to_8_bit, const void *buffer, png_int_32 row_stride, + const void *colormap)); + /* Write the image to the given (FILE*). */ + +/* With both write APIs if image is in one of the linear formats with 16-bit + * data then setting convert_to_8_bit will cause the output to be an 8-bit PNG + * gamma encoded according to the sRGB specification, otherwise a 16-bit linear + * encoded PNG file is written. + * + * With color-mapped data formats the colormap parameter point to a color-map + * with at least image->colormap_entries encoded in the specified format. If + * the format is linear the written PNG color-map will be converted to sRGB + * regardless of the convert_to_8_bit flag. + * + * With all APIs row_stride is handled as in the read APIs - it is the spacing + * from one row to the next in component sized units (1 or 2 bytes) and if + * negative indicates a bottom-up row layout in the buffer. + * + * Note that the write API does not support interlacing or sub-8-bit pixels. + */ +#endif /* PNG_STDIO_SUPPORTED */ +#endif /* PNG_SIMPLIFIED_WRITE_SUPPORTED */ +/******************************************************************************* + * END OF SIMPLIFIED API + ******************************************************************************/ + +#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED +PNG_EXPORT(242, void, png_set_check_for_invalid_index, + (png_structrp png_ptr, int allowed)); +# ifdef PNG_GET_PALETTE_MAX_SUPPORTED +PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr, + png_const_infop info_ptr)); +# endif +#endif /* CHECK_FOR_INVALID_INDEX */ + +/******************************************************************************* + * IMPLEMENTATION OPTIONS + ******************************************************************************* + * + * Support for arbitrary implementation-specific optimizations. The API allows + * particular options to be turned on or off. 'Option' is the number of the + * option and 'onoff' is 0 (off) or non-0 (on). The value returned is given + * by the PNG_OPTION_ defines below. + * + * HARDWARE: normally hardware capabilites, such as the Intel SSE instructions, + * are detected at run time, however sometimes it may be impossible + * to do this in user mode, in which case it is necessary to discover + * the capabilities in an OS specific way. Such capabilities are + * listed here when libpng has support for them and must be turned + * ON by the application if present. + * + * SOFTWARE: sometimes software optimizations actually result in performance + * decrease on some architectures or systems, or with some sets of + * PNG images. 'Software' options allow such optimizations to be + * selected at run time. + */ +#ifdef PNG_SET_OPTION_SUPPORTED +#ifdef PNG_ARM_NEON_API_SUPPORTED +# define PNG_ARM_NEON 0 /* HARDWARE: ARM Neon SIMD instructions supported */ +#endif +#define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */ +#define PNG_OPTION_NEXT 4 /* Next option - numbers must be even */ + +/* Return values: NOTE: there are four values and 'off' is *not* zero */ +#define PNG_OPTION_UNSET 0 /* Unset - defaults to off */ +#define PNG_OPTION_INVALID 1 /* Option number out of range */ +#define PNG_OPTION_OFF 2 +#define PNG_OPTION_ON 3 + +PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option, + int onoff)); +#endif + +/******************************************************************************* + * END OF HARDWARE OPTIONS + ******************************************************************************/ + +/* Maintainer: Put new public prototypes here ^, in libpng.3, and project + * defs, scripts/pnglibconf.h, and scripts/pnglibconf.h.prebuilt + */ + +/* The last ordinal number (this is the *last* one already used; the next + * one to use is one more than this.) Maintainer, remember to add an entry to + * scripts/symbols.def as well. + */ +#ifdef PNG_EXPORT_LAST_ORDINAL + PNG_EXPORT_LAST_ORDINAL(244); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* PNG_VERSION_INFO_ONLY */ +/* Do not put anything past this line */ +#endif /* PNG_H */ diff --git a/extern/for_mingw/include/pngconf.h b/extern/for_mingw/include/pngconf.h new file mode 100644 index 0000000000..4bd807f271 --- /dev/null +++ b/extern/for_mingw/include/pngconf.h @@ -0,0 +1,617 @@ + +/* pngconf.h - machine configurable file for libpng + * + * libpng version 1.6.6 - September 16, 2013 + * + * Copyright (c) 1998-2013 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h + * + */ + +/* Any machine specific code is near the front of this file, so if you + * are configuring libpng for a machine, you may want to read the section + * starting here down to where it starts to typedef png_color, png_text, + * and png_info. + */ + +#ifndef PNGCONF_H +#define PNGCONF_H + +/* To do: Do all of this in scripts/pnglibconf.dfa */ +#ifdef PNG_SAFE_LIMITS_SUPPORTED +# ifdef PNG_USER_WIDTH_MAX +# undef PNG_USER_WIDTH_MAX +# define PNG_USER_WIDTH_MAX 1000000L +# endif +# ifdef PNG_USER_HEIGHT_MAX +# undef PNG_USER_HEIGHT_MAX +# define PNG_USER_HEIGHT_MAX 1000000L +# endif +# ifdef PNG_USER_CHUNK_MALLOC_MAX +# undef PNG_USER_CHUNK_MALLOC_MAX +# define PNG_USER_CHUNK_MALLOC_MAX 4000000L +# endif +# ifdef PNG_USER_CHUNK_CACHE_MAX +# undef PNG_USER_CHUNK_CACHE_MAX +# define PNG_USER_CHUNK_CACHE_MAX 128 +# endif +#endif + +#ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */ + +/* From libpng 1.6.0 libpng requires an ANSI X3.159-1989 ("ISOC90") compliant C + * compiler for correct compilation. The following header files are required by + * the standard. If your compiler doesn't provide these header files, or they + * do not match the standard, you will need to provide/improve them. + */ +#include +#include + +/* Library header files. These header files are all defined by ISOC90; libpng + * expects conformant implementations, however, an ISOC90 conformant system need + * not provide these header files if the functionality cannot be implemented. + * In this case it will be necessary to disable the relevant parts of libpng in + * the build of pnglibconf.h. + * + * Prior to 1.6.0 string.h was included here; the API changes in 1.6.0 to not + * include this unnecessary header file. + */ + +#ifdef PNG_STDIO_SUPPORTED + /* Required for the definition of FILE: */ +# include +#endif + +#ifdef PNG_SETJMP_SUPPORTED + /* Required for the definition of jmp_buf and the declaration of longjmp: */ +# include +#endif + +#ifdef PNG_CONVERT_tIME_SUPPORTED + /* Required for struct tm: */ +# include +#endif + +#endif /* PNG_BUILDING_SYMBOL_TABLE */ + +/* Prior to 1.6.0 it was possible to turn off 'const' in declarations using + * PNG_NO_CONST; this is no longer supported except for data declarations which + * apparently still cause problems in 2011 on some compilers. + */ +#define PNG_CONST const /* backward compatibility only */ + +/* This controls optimization of the reading of 16 and 32 bit values + * from PNG files. It can be set on a per-app-file basis - it + * just changes whether a macro is used when the function is called. + * The library builder sets the default; if read functions are not + * built into the library the macro implementation is forced on. + */ +#ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED +# define PNG_USE_READ_MACROS +#endif +#if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS) +# if PNG_DEFAULT_READ_MACROS +# define PNG_USE_READ_MACROS +# endif +#endif + +/* COMPILER SPECIFIC OPTIONS. + * + * These options are provided so that a variety of difficult compilers + * can be used. Some are fixed at build time (e.g. PNG_API_RULE + * below) but still have compiler specific implementations, others + * may be changed on a per-file basis when compiling against libpng. + */ + +/* The PNGARG macro was used in versions of libpng prior to 1.6.0 to protect + * against legacy (pre ISOC90) compilers that did not understand function + * prototypes. It is not required for modern C compilers. + */ +#ifndef PNGARG +# define PNGARG(arglist) arglist +#endif + +/* Function calling conventions. + * ============================= + * Normally it is not necessary to specify to the compiler how to call + * a function - it just does it - however on x86 systems derived from + * Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems + * and some others) there are multiple ways to call a function and the + * default can be changed on the compiler command line. For this reason + * libpng specifies the calling convention of every exported function and + * every function called via a user supplied function pointer. This is + * done in this file by defining the following macros: + * + * PNGAPI Calling convention for exported functions. + * PNGCBAPI Calling convention for user provided (callback) functions. + * PNGCAPI Calling convention used by the ANSI-C library (required + * for longjmp callbacks and sometimes used internally to + * specify the calling convention for zlib). + * + * These macros should never be overridden. If it is necessary to + * change calling convention in a private build this can be done + * by setting PNG_API_RULE (which defaults to 0) to one of the values + * below to select the correct 'API' variants. + * + * PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout. + * This is correct in every known environment. + * PNG_API_RULE=1 Use the operating system convention for PNGAPI and + * the 'C' calling convention (from PNGCAPI) for + * callbacks (PNGCBAPI). This is no longer required + * in any known environment - if it has to be used + * please post an explanation of the problem to the + * libpng mailing list. + * + * These cases only differ if the operating system does not use the C + * calling convention, at present this just means the above cases + * (x86 DOS/Windows sytems) and, even then, this does not apply to + * Cygwin running on those systems. + * + * Note that the value must be defined in pnglibconf.h so that what + * the application uses to call the library matches the conventions + * set when building the library. + */ + +/* Symbol export + * ============= + * When building a shared library it is almost always necessary to tell + * the compiler which symbols to export. The png.h macro 'PNG_EXPORT' + * is used to mark the symbols. On some systems these symbols can be + * extracted at link time and need no special processing by the compiler, + * on other systems the symbols are flagged by the compiler and just + * the declaration requires a special tag applied (unfortunately) in a + * compiler dependent way. Some systems can do either. + * + * A small number of older systems also require a symbol from a DLL to + * be flagged to the program that calls it. This is a problem because + * we do not know in the header file included by application code that + * the symbol will come from a shared library, as opposed to a statically + * linked one. For this reason the application must tell us by setting + * the magic flag PNG_USE_DLL to turn on the special processing before + * it includes png.h. + * + * Four additional macros are used to make this happen: + * + * PNG_IMPEXP The magic (if any) to cause a symbol to be exported from + * the build or imported if PNG_USE_DLL is set - compiler + * and system specific. + * + * PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to + * 'type', compiler specific. + * + * PNG_DLL_EXPORT Set to the magic to use during a libpng build to + * make a symbol exported from the DLL. Not used in the + * public header files; see pngpriv.h for how it is used + * in the libpng build. + * + * PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come + * from a DLL - used to define PNG_IMPEXP when + * PNG_USE_DLL is set. + */ + +/* System specific discovery. + * ========================== + * This code is used at build time to find PNG_IMPEXP, the API settings + * and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL + * import processing is possible. On Windows systems it also sets + * compiler-specific macros to the values required to change the calling + * conventions of the various functions. + */ +#if defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\ + defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) + /* Windows system (DOS doesn't support DLLs). Includes builds under Cygwin or + * MinGW on any architecture currently supported by Windows. Also includes + * Watcom builds but these need special treatment because they are not + * compatible with GCC or Visual C because of different calling conventions. + */ +# if PNG_API_RULE == 2 + /* If this line results in an error, either because __watcall is not + * understood or because of a redefine just below you cannot use *this* + * build of the library with the compiler you are using. *This* build was + * build using Watcom and applications must also be built using Watcom! + */ +# define PNGCAPI __watcall +# endif + +# if defined(__GNUC__) || (defined(_MSC_VER) && (_MSC_VER >= 800)) +# define PNGCAPI __cdecl +# if PNG_API_RULE == 1 + /* If this line results in an error __stdcall is not understood and + * PNG_API_RULE should not have been set to '1'. + */ +# define PNGAPI __stdcall +# endif +# else + /* An older compiler, or one not detected (erroneously) above, + * if necessary override on the command line to get the correct + * variants for the compiler. + */ +# ifndef PNGCAPI +# define PNGCAPI _cdecl +# endif +# if PNG_API_RULE == 1 && !defined(PNGAPI) +# define PNGAPI _stdcall +# endif +# endif /* compiler/api */ + + /* NOTE: PNGCBAPI always defaults to PNGCAPI. */ + +# if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD) +# error "PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed" +# endif + +# if (defined(_MSC_VER) && _MSC_VER < 800) ||\ + (defined(__BORLANDC__) && __BORLANDC__ < 0x500) + /* older Borland and MSC + * compilers used '__export' and required this to be after + * the type. + */ +# ifndef PNG_EXPORT_TYPE +# define PNG_EXPORT_TYPE(type) type PNG_IMPEXP +# endif +# define PNG_DLL_EXPORT __export +# else /* newer compiler */ +# define PNG_DLL_EXPORT __declspec(dllexport) +# ifndef PNG_DLL_IMPORT +# define PNG_DLL_IMPORT __declspec(dllimport) +# endif +# endif /* compiler */ + +#else /* !Windows */ +# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) +# define PNGAPI _System +# else /* !Windows/x86 && !OS/2 */ + /* Use the defaults, or define PNG*API on the command line (but + * this will have to be done for every compile!) + */ +# endif /* other system, !OS/2 */ +#endif /* !Windows/x86 */ + +/* Now do all the defaulting . */ +#ifndef PNGCAPI +# define PNGCAPI +#endif +#ifndef PNGCBAPI +# define PNGCBAPI PNGCAPI +#endif +#ifndef PNGAPI +# define PNGAPI PNGCAPI +#endif + +/* PNG_IMPEXP may be set on the compilation system command line or (if not set) + * then in an internal header file when building the library, otherwise (when + * using the library) it is set here. + */ +#ifndef PNG_IMPEXP +# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT) + /* This forces use of a DLL, disallowing static linking */ +# define PNG_IMPEXP PNG_DLL_IMPORT +# endif + +# ifndef PNG_IMPEXP +# define PNG_IMPEXP +# endif +#endif + +/* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat + * 'attributes' as a storage class - the attributes go at the start of the + * function definition, and attributes are always appended regardless of the + * compiler. This considerably simplifies these macros but may cause problems + * if any compilers both need function attributes and fail to handle them as + * a storage class (this is unlikely.) + */ +#ifndef PNG_FUNCTION +# define PNG_FUNCTION(type, name, args, attributes) attributes type name args +#endif + +#ifndef PNG_EXPORT_TYPE +# define PNG_EXPORT_TYPE(type) PNG_IMPEXP type +#endif + + /* The ordinal value is only relevant when preprocessing png.h for symbol + * table entries, so we discard it here. See the .dfn files in the + * scripts directory. + */ +#ifndef PNG_EXPORTA + +# define PNG_EXPORTA(ordinal, type, name, args, attributes)\ + PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args), \ + extern attributes) +#endif + +/* ANSI-C (C90) does not permit a macro to be invoked with an empty argument, + * so make something non-empty to satisfy the requirement: + */ +#define PNG_EMPTY /*empty list*/ + +#define PNG_EXPORT(ordinal, type, name, args)\ + PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY) + +/* Use PNG_REMOVED to comment out a removed interface. */ +#ifndef PNG_REMOVED +# define PNG_REMOVED(ordinal, type, name, args, attributes) +#endif + +#ifndef PNG_CALLBACK +# define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args) +#endif + +/* Support for compiler specific function attributes. These are used + * so that where compiler support is available incorrect use of API + * functions in png.h will generate compiler warnings. + * + * Added at libpng-1.2.41. + */ + +#ifndef PNG_NO_PEDANTIC_WARNINGS +# ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED +# define PNG_PEDANTIC_WARNINGS_SUPPORTED +# endif +#endif + +#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED + /* Support for compiler specific function attributes. These are used + * so that where compiler support is available, incorrect use of API + * functions in png.h will generate compiler warnings. Added at libpng + * version 1.2.41. Disabling these removes the warnings but may also produce + * less efficient code. + */ +# if defined(__GNUC__) +# ifndef PNG_USE_RESULT +# define PNG_USE_RESULT __attribute__((__warn_unused_result__)) +# endif +# ifndef PNG_NORETURN +# define PNG_NORETURN __attribute__((__noreturn__)) +# endif +# if __GNUC__ >= 3 +# ifndef PNG_ALLOCATED +# define PNG_ALLOCATED __attribute__((__malloc__)) +# endif +# ifndef PNG_DEPRECATED +# define PNG_DEPRECATED __attribute__((__deprecated__)) +# endif +# ifndef PNG_PRIVATE +# if 0 /* Doesn't work so we use deprecated instead*/ +# define PNG_PRIVATE \ + __attribute__((warning("This function is not exported by libpng."))) +# else +# define PNG_PRIVATE \ + __attribute__((__deprecated__)) +# endif +# endif +# if ((__GNUC__ != 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1)) +# ifndef PNG_RESTRICT +# define PNG_RESTRICT __restrict +# endif +# endif /* __GNUC__ == 3.0 */ +# endif /* __GNUC__ >= 3 */ + +# elif defined(_MSC_VER) && (_MSC_VER >= 1300) +# ifndef PNG_USE_RESULT +# define PNG_USE_RESULT /* not supported */ +# endif +# ifndef PNG_NORETURN +# define PNG_NORETURN __declspec(noreturn) +# endif +# ifndef PNG_ALLOCATED +# if (_MSC_VER >= 1400) +# define PNG_ALLOCATED __declspec(restrict) +# endif +# endif +# ifndef PNG_DEPRECATED +# define PNG_DEPRECATED __declspec(deprecated) +# endif +# ifndef PNG_PRIVATE +# define PNG_PRIVATE __declspec(deprecated) +# endif +# ifndef PNG_RESTRICT +# if (_MSC_VER >= 1400) +# define PNG_RESTRICT __restrict +# endif +# endif + +# elif defined(__WATCOMC__) +# ifndef PNG_RESTRICT +# define PNG_RESTRICT __restrict +# endif +# endif /* _MSC_VER */ +#endif /* PNG_PEDANTIC_WARNINGS */ + +#ifndef PNG_DEPRECATED +# define PNG_DEPRECATED /* Use of this function is deprecated */ +#endif +#ifndef PNG_USE_RESULT +# define PNG_USE_RESULT /* The result of this function must be checked */ +#endif +#ifndef PNG_NORETURN +# define PNG_NORETURN /* This function does not return */ +#endif +#ifndef PNG_ALLOCATED +# define PNG_ALLOCATED /* The result of the function is new memory */ +#endif +#ifndef PNG_PRIVATE +# define PNG_PRIVATE /* This is a private libpng function */ +#endif +#ifndef PNG_RESTRICT +# define PNG_RESTRICT /* The C99 "restrict" feature */ +#endif +#ifndef PNG_FP_EXPORT /* A floating point API. */ +# ifdef PNG_FLOATING_POINT_SUPPORTED +# define PNG_FP_EXPORT(ordinal, type, name, args)\ + PNG_EXPORT(ordinal, type, name, args); +# else /* No floating point APIs */ +# define PNG_FP_EXPORT(ordinal, type, name, args) +# endif +#endif +#ifndef PNG_FIXED_EXPORT /* A fixed point API. */ +# ifdef PNG_FIXED_POINT_SUPPORTED +# define PNG_FIXED_EXPORT(ordinal, type, name, args)\ + PNG_EXPORT(ordinal, type, name, args); +# else /* No fixed point APIs */ +# define PNG_FIXED_EXPORT(ordinal, type, name, args) +# endif +#endif + +#ifndef PNG_BUILDING_SYMBOL_TABLE +/* Some typedefs to get us started. These should be safe on most of the common + * platforms. + * + * png_uint_32 and png_int_32 may, currently, be larger than required to hold a + * 32-bit value however this is not normally advisable. + * + * png_uint_16 and png_int_16 should always be two bytes in size - this is + * verified at library build time. + * + * png_byte must always be one byte in size. + * + * The checks below use constants from limits.h, as defined by the ISOC90 + * standard. + */ +#if CHAR_BIT == 8 && UCHAR_MAX == 255 + typedef unsigned char png_byte; +#else +# error "libpng requires 8 bit bytes" +#endif + +#if INT_MIN == -32768 && INT_MAX == 32767 + typedef int png_int_16; +#elif SHRT_MIN == -32768 && SHRT_MAX == 32767 + typedef short png_int_16; +#else +# error "libpng requires a signed 16 bit type" +#endif + +#if UINT_MAX == 65535 + typedef unsigned int png_uint_16; +#elif USHRT_MAX == 65535 + typedef unsigned short png_uint_16; +#else +# error "libpng requires an unsigned 16 bit type" +#endif + +#if INT_MIN < -2147483646 && INT_MAX > 2147483646 + typedef int png_int_32; +#elif LONG_MIN < -2147483646 && LONG_MAX > 2147483646 + typedef long int png_int_32; +#else +# error "libpng requires a signed 32 bit (or more) type" +#endif + +#if UINT_MAX > 4294967294 + typedef unsigned int png_uint_32; +#elif ULONG_MAX > 4294967294 + typedef unsigned long int png_uint_32; +#else +# error "libpng requires an unsigned 32 bit (or more) type" +#endif + +/* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however, + * requires an ISOC90 compiler and relies on consistent behavior of sizeof. + */ +typedef size_t png_size_t; +typedef ptrdiff_t png_ptrdiff_t; + +/* libpng needs to know the maximum value of 'size_t' and this controls the + * definition of png_alloc_size_t, below. This maximum value of size_t limits + * but does not control the maximum allocations the library makes - there is + * direct application control of this through png_set_user_limits(). + */ +#ifndef PNG_SMALL_SIZE_T + /* Compiler specific tests for systems where size_t is known to be less than + * 32 bits (some of these systems may no longer work because of the lack of + * 'far' support; see above.) + */ +# if (defined(__TURBOC__) && !defined(__FLAT__)) ||\ + (defined(_MSC_VER) && defined(MAXSEG_64K)) +# define PNG_SMALL_SIZE_T +# endif +#endif + +/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, and no + * smaller than png_uint_32. Casts from png_size_t or png_uint_32 to + * png_alloc_size_t are not necessary; in fact, it is recommended not to use + * them at all so that the compiler can complain when something turns out to be + * problematic. + * + * Casts in the other direction (from png_alloc_size_t to png_size_t or + * png_uint_32) should be explicitly applied; however, we do not expect to + * encounter practical situations that require such conversions. + * + * PNG_SMALL_SIZE_T must be defined if the maximum value of size_t is less than + * 4294967295 - i.e. less than the maximum value of png_uint_32. + */ +#ifdef PNG_SMALL_SIZE_T + typedef png_uint_32 png_alloc_size_t; +#else + typedef png_size_t png_alloc_size_t; +#endif + +/* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler + * implementations of Intel CPU specific support of user-mode segmented address + * spaces, where 16-bit pointers address more than 65536 bytes of memory using + * separate 'segment' registers. The implementation requires two different + * types of pointer (only one of which includes the segment value.) + * + * If required this support is available in version 1.2 of libpng and may be + * available in versions through 1.5, although the correctness of the code has + * not been verified recently. + */ + +/* Typedef for floating-point numbers that are converted to fixed-point with a + * multiple of 100,000, e.g., gamma + */ +typedef png_int_32 png_fixed_point; + +/* Add typedefs for pointers */ +typedef void * png_voidp; +typedef const void * png_const_voidp; +typedef png_byte * png_bytep; +typedef const png_byte * png_const_bytep; +typedef png_uint_32 * png_uint_32p; +typedef const png_uint_32 * png_const_uint_32p; +typedef png_int_32 * png_int_32p; +typedef const png_int_32 * png_const_int_32p; +typedef png_uint_16 * png_uint_16p; +typedef const png_uint_16 * png_const_uint_16p; +typedef png_int_16 * png_int_16p; +typedef const png_int_16 * png_const_int_16p; +typedef char * png_charp; +typedef const char * png_const_charp; +typedef png_fixed_point * png_fixed_point_p; +typedef const png_fixed_point * png_const_fixed_point_p; +typedef png_size_t * png_size_tp; +typedef const png_size_t * png_const_size_tp; + +#ifdef PNG_STDIO_SUPPORTED +typedef FILE * png_FILE_p; +#endif + +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double * png_doublep; +typedef const double * png_const_doublep; +#endif + +/* Pointers to pointers; i.e. arrays */ +typedef png_byte * * png_bytepp; +typedef png_uint_32 * * png_uint_32pp; +typedef png_int_32 * * png_int_32pp; +typedef png_uint_16 * * png_uint_16pp; +typedef png_int_16 * * png_int_16pp; +typedef const char * * png_const_charpp; +typedef char * * png_charpp; +typedef png_fixed_point * * png_fixed_point_pp; +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double * * png_doublepp; +#endif + +/* Pointers to pointers to pointers; i.e., pointer to array */ +typedef char * * * png_charppp; + +#endif /* PNG_BUILDING_SYMBOL_TABLE */ + +#endif /* PNGCONF_H */ diff --git a/extern/for_mingw/include/pnglibconf.h b/extern/for_mingw/include/pnglibconf.h new file mode 100644 index 0000000000..c1abc52f85 --- /dev/null +++ b/extern/for_mingw/include/pnglibconf.h @@ -0,0 +1,209 @@ +/* pnglibconf.h - library build configuration */ + +/* libpng version 1.6.6 - September 16, 2013 */ + +/* Copyright (c) 1998-2012 Glenn Randers-Pehrson */ + +/* This code is released under the libpng license. */ +/* For conditions of distribution and use, see the disclaimer */ +/* and license in png.h */ + +/* pnglibconf.h */ +/* Machine generated file: DO NOT EDIT */ +/* Derived from: scripts/pnglibconf.dfa */ +#ifndef PNGLCONF_H +#define PNGLCONF_H +/* options */ +#define PNG_16BIT_SUPPORTED +#define PNG_ALIGNED_MEMORY_SUPPORTED +/*#undef PNG_ARM_NEON_API_SUPPORTED*/ +/*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/ +#define PNG_BENIGN_ERRORS_SUPPORTED +#define PNG_BENIGN_READ_ERRORS_SUPPORTED +/*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/ +#define PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED +#define PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED +#define PNG_COLORSPACE_SUPPORTED +#define PNG_CONSOLE_IO_SUPPORTED +#define PNG_CONVERT_tIME_SUPPORTED +#define PNG_EASY_ACCESS_SUPPORTED +/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/ +#define PNG_ERROR_TEXT_SUPPORTED +#define PNG_FIXED_POINT_SUPPORTED +#define PNG_FLOATING_ARITHMETIC_SUPPORTED +#define PNG_FLOATING_POINT_SUPPORTED +#define PNG_FORMAT_AFIRST_SUPPORTED +#define PNG_FORMAT_BGR_SUPPORTED +#define PNG_GAMMA_SUPPORTED +#define PNG_GET_PALETTE_MAX_SUPPORTED +#define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +#define PNG_INCH_CONVERSIONS_SUPPORTED +#define PNG_INFO_IMAGE_SUPPORTED +#define PNG_IO_STATE_SUPPORTED +#define PNG_MNG_FEATURES_SUPPORTED +#define PNG_POINTER_INDEXING_SUPPORTED +#define PNG_PROGRESSIVE_READ_SUPPORTED +#define PNG_READ_16BIT_SUPPORTED +#define PNG_READ_ALPHA_MODE_SUPPORTED +#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +#define PNG_READ_BACKGROUND_SUPPORTED +#define PNG_READ_BGR_SUPPORTED +#define PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED +#define PNG_READ_COMPOSITE_NODIV_SUPPORTED +#define PNG_READ_COMPRESSED_TEXT_SUPPORTED +#define PNG_READ_EXPAND_16_SUPPORTED +#define PNG_READ_EXPAND_SUPPORTED +#define PNG_READ_FILLER_SUPPORTED +#define PNG_READ_GAMMA_SUPPORTED +#define PNG_READ_GET_PALETTE_MAX_SUPPORTED +#define PNG_READ_GRAY_TO_RGB_SUPPORTED +#define PNG_READ_INTERLACING_SUPPORTED +#define PNG_READ_INT_FUNCTIONS_SUPPORTED +#define PNG_READ_INVERT_ALPHA_SUPPORTED +#define PNG_READ_INVERT_SUPPORTED +#define PNG_READ_OPT_PLTE_SUPPORTED +#define PNG_READ_PACKSWAP_SUPPORTED +#define PNG_READ_PACK_SUPPORTED +#define PNG_READ_QUANTIZE_SUPPORTED +#define PNG_READ_RGB_TO_GRAY_SUPPORTED +#define PNG_READ_SCALE_16_TO_8_SUPPORTED +#define PNG_READ_SHIFT_SUPPORTED +#define PNG_READ_STRIP_16_TO_8_SUPPORTED +#define PNG_READ_STRIP_ALPHA_SUPPORTED +#define PNG_READ_SUPPORTED +#define PNG_READ_SWAP_ALPHA_SUPPORTED +#define PNG_READ_SWAP_SUPPORTED +#define PNG_READ_TEXT_SUPPORTED +#define PNG_READ_TRANSFORMS_SUPPORTED +#define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_READ_USER_CHUNKS_SUPPORTED +#define PNG_READ_USER_TRANSFORM_SUPPORTED +#define PNG_READ_bKGD_SUPPORTED +#define PNG_READ_cHRM_SUPPORTED +#define PNG_READ_gAMA_SUPPORTED +#define PNG_READ_hIST_SUPPORTED +#define PNG_READ_iCCP_SUPPORTED +#define PNG_READ_iTXt_SUPPORTED +#define PNG_READ_oFFs_SUPPORTED +#define PNG_READ_pCAL_SUPPORTED +#define PNG_READ_pHYs_SUPPORTED +#define PNG_READ_sBIT_SUPPORTED +#define PNG_READ_sCAL_SUPPORTED +#define PNG_READ_sPLT_SUPPORTED +#define PNG_READ_sRGB_SUPPORTED +#define PNG_READ_tEXt_SUPPORTED +#define PNG_READ_tIME_SUPPORTED +#define PNG_READ_tRNS_SUPPORTED +#define PNG_READ_zTXt_SUPPORTED +/*#undef PNG_SAFE_LIMITS_SUPPORTED*/ +#define PNG_SAVE_INT_32_SUPPORTED +#define PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_SEQUENTIAL_READ_SUPPORTED +#define PNG_SETJMP_SUPPORTED +#define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED +#define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED +#define PNG_SET_OPTION_SUPPORTED +#define PNG_SET_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_SET_USER_LIMITS_SUPPORTED +#define PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED +#define PNG_SIMPLIFIED_READ_BGR_SUPPORTED +#define PNG_SIMPLIFIED_READ_SUPPORTED +#define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED +#define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED +#define PNG_SIMPLIFIED_WRITE_SUPPORTED +#define PNG_STDIO_SUPPORTED +#define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_TEXT_SUPPORTED +#define PNG_TIME_RFC1123_SUPPORTED +#define PNG_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_USER_CHUNKS_SUPPORTED +#define PNG_USER_LIMITS_SUPPORTED +#define PNG_USER_MEM_SUPPORTED +#define PNG_USER_TRANSFORM_INFO_SUPPORTED +#define PNG_USER_TRANSFORM_PTR_SUPPORTED +#define PNG_WARNINGS_SUPPORTED +#define PNG_WRITE_16BIT_SUPPORTED +#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +#define PNG_WRITE_BGR_SUPPORTED +#define PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED +#define PNG_WRITE_COMPRESSED_TEXT_SUPPORTED +#define PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED +#define PNG_WRITE_FILLER_SUPPORTED +#define PNG_WRITE_FILTER_SUPPORTED +#define PNG_WRITE_FLUSH_SUPPORTED +#define PNG_WRITE_GET_PALETTE_MAX_SUPPORTED +#define PNG_WRITE_INTERLACING_SUPPORTED +#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED +#define PNG_WRITE_INVERT_ALPHA_SUPPORTED +#define PNG_WRITE_INVERT_SUPPORTED +#define PNG_WRITE_OPTIMIZE_CMF_SUPPORTED +#define PNG_WRITE_PACKSWAP_SUPPORTED +#define PNG_WRITE_PACK_SUPPORTED +#define PNG_WRITE_SHIFT_SUPPORTED +#define PNG_WRITE_SUPPORTED +#define PNG_WRITE_SWAP_ALPHA_SUPPORTED +#define PNG_WRITE_SWAP_SUPPORTED +#define PNG_WRITE_TEXT_SUPPORTED +#define PNG_WRITE_TRANSFORMS_SUPPORTED +#define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_WRITE_USER_TRANSFORM_SUPPORTED +#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +#define PNG_WRITE_bKGD_SUPPORTED +#define PNG_WRITE_cHRM_SUPPORTED +#define PNG_WRITE_gAMA_SUPPORTED +#define PNG_WRITE_hIST_SUPPORTED +#define PNG_WRITE_iCCP_SUPPORTED +#define PNG_WRITE_iTXt_SUPPORTED +#define PNG_WRITE_oFFs_SUPPORTED +#define PNG_WRITE_pCAL_SUPPORTED +#define PNG_WRITE_pHYs_SUPPORTED +#define PNG_WRITE_sBIT_SUPPORTED +#define PNG_WRITE_sCAL_SUPPORTED +#define PNG_WRITE_sPLT_SUPPORTED +#define PNG_WRITE_sRGB_SUPPORTED +#define PNG_WRITE_tEXt_SUPPORTED +#define PNG_WRITE_tIME_SUPPORTED +#define PNG_WRITE_tRNS_SUPPORTED +#define PNG_WRITE_zTXt_SUPPORTED +#define PNG_bKGD_SUPPORTED +#define PNG_cHRM_SUPPORTED +#define PNG_gAMA_SUPPORTED +#define PNG_hIST_SUPPORTED +#define PNG_iCCP_SUPPORTED +#define PNG_iTXt_SUPPORTED +#define PNG_oFFs_SUPPORTED +#define PNG_pCAL_SUPPORTED +#define PNG_pHYs_SUPPORTED +#define PNG_sBIT_SUPPORTED +#define PNG_sCAL_SUPPORTED +#define PNG_sPLT_SUPPORTED +#define PNG_sRGB_SUPPORTED +#define PNG_tEXt_SUPPORTED +#define PNG_tIME_SUPPORTED +#define PNG_tRNS_SUPPORTED +#define PNG_zTXt_SUPPORTED +/* end of options */ +/* settings */ +#define PNG_API_RULE 0 +#define PNG_CALLOC_SUPPORTED +#define PNG_COST_SHIFT 3 +#define PNG_DEFAULT_READ_MACROS 1 +#define PNG_GAMMA_THRESHOLD_FIXED 5000 +#define PNG_IDAT_READ_SIZE PNG_ZBUF_SIZE +#define PNG_INFLATE_BUF_SIZE 1024 +#define PNG_MAX_GAMMA_8 11 +#define PNG_QUANTIZE_BLUE_BITS 5 +#define PNG_QUANTIZE_GREEN_BITS 5 +#define PNG_QUANTIZE_RED_BITS 5 +#define PNG_TEXT_Z_DEFAULT_COMPRESSION (-1) +#define PNG_TEXT_Z_DEFAULT_STRATEGY 0 +#define PNG_WEIGHT_SHIFT 8 +#define PNG_ZBUF_SIZE 8192 +#define PNG_ZLIB_VERNUM 0x1280 +#define PNG_Z_DEFAULT_COMPRESSION (-1) +#define PNG_Z_DEFAULT_NOFILTER_STRATEGY 0 +#define PNG_Z_DEFAULT_STRATEGY 1 +#define PNG_sCAL_PRECISION 5 +#define PNG_sRGB_PROFILE_CHECKS 2 +/* end of settings */ +#endif /* PNGLCONF_H */ diff --git a/extern/for_mingw/include/zconf.h b/extern/for_mingw/include/zconf.h new file mode 100644 index 0000000000..9987a77553 --- /dev/null +++ b/extern/for_mingw/include/zconf.h @@ -0,0 +1,511 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2013 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. + * Even better than compiling with -DZ_PREFIX would be to use configure to set + * this permanently in zconf.h using "./configure --zprefix". + */ +#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +# define Z_PREFIX_SET + +/* all linked symbols */ +# define _dist_code z__dist_code +# define _length_code z__length_code +# define _tr_align z__tr_align +# define _tr_flush_bits z__tr_flush_bits +# define _tr_flush_block z__tr_flush_block +# define _tr_init z__tr_init +# define _tr_stored_block z__tr_stored_block +# define _tr_tally z__tr_tally +# define adler32 z_adler32 +# define adler32_combine z_adler32_combine +# define adler32_combine64 z_adler32_combine64 +# ifndef Z_SOLO +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# endif +# define crc32 z_crc32 +# define crc32_combine z_crc32_combine +# define crc32_combine64 z_crc32_combine64 +# define deflate z_deflate +# define deflateBound z_deflateBound +# define deflateCopy z_deflateCopy +# define deflateEnd z_deflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateInit_ z_deflateInit_ +# define deflateParams z_deflateParams +# define deflatePending z_deflatePending +# define deflatePrime z_deflatePrime +# define deflateReset z_deflateReset +# define deflateResetKeep z_deflateResetKeep +# define deflateSetDictionary z_deflateSetDictionary +# define deflateSetHeader z_deflateSetHeader +# define deflateTune z_deflateTune +# define deflate_copyright z_deflate_copyright +# define get_crc_table z_get_crc_table +# ifndef Z_SOLO +# define gz_error z_gz_error +# define gz_intmax z_gz_intmax +# define gz_strwinerror z_gz_strwinerror +# define gzbuffer z_gzbuffer +# define gzclearerr z_gzclearerr +# define gzclose z_gzclose +# define gzclose_r z_gzclose_r +# define gzclose_w z_gzclose_w +# define gzdirect z_gzdirect +# define gzdopen z_gzdopen +# define gzeof z_gzeof +# define gzerror z_gzerror +# define gzflush z_gzflush +# define gzgetc z_gzgetc +# define gzgetc_ z_gzgetc_ +# define gzgets z_gzgets +# define gzoffset z_gzoffset +# define gzoffset64 z_gzoffset64 +# define gzopen z_gzopen +# define gzopen64 z_gzopen64 +# ifdef _WIN32 +# define gzopen_w z_gzopen_w +# endif +# define gzprintf z_gzprintf +# define gzvprintf z_gzvprintf +# define gzputc z_gzputc +# define gzputs z_gzputs +# define gzread z_gzread +# define gzrewind z_gzrewind +# define gzseek z_gzseek +# define gzseek64 z_gzseek64 +# define gzsetparams z_gzsetparams +# define gztell z_gztell +# define gztell64 z_gztell64 +# define gzungetc z_gzungetc +# define gzwrite z_gzwrite +# endif +# define inflate z_inflate +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define inflateBackInit_ z_inflateBackInit_ +# define inflateCopy z_inflateCopy +# define inflateEnd z_inflateEnd +# define inflateGetHeader z_inflateGetHeader +# define inflateInit2_ z_inflateInit2_ +# define inflateInit_ z_inflateInit_ +# define inflateMark z_inflateMark +# define inflatePrime z_inflatePrime +# define inflateReset z_inflateReset +# define inflateReset2 z_inflateReset2 +# define inflateSetDictionary z_inflateSetDictionary +# define inflateGetDictionary z_inflateGetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateUndermine z_inflateUndermine +# define inflateResetKeep z_inflateResetKeep +# define inflate_copyright z_inflate_copyright +# define inflate_fast z_inflate_fast +# define inflate_table z_inflate_table +# ifndef Z_SOLO +# define uncompress z_uncompress +# endif +# define zError z_zError +# ifndef Z_SOLO +# define zcalloc z_zcalloc +# define zcfree z_zcfree +# endif +# define zlibCompileFlags z_zlibCompileFlags +# define zlibVersion z_zlibVersion + +/* all zlib typedefs in zlib.h and zconf.h */ +# define Byte z_Byte +# define Bytef z_Bytef +# define alloc_func z_alloc_func +# define charf z_charf +# define free_func z_free_func +# ifndef Z_SOLO +# define gzFile z_gzFile +# endif +# define gz_header z_gz_header +# define gz_headerp z_gz_headerp +# define in_func z_in_func +# define intf z_intf +# define out_func z_out_func +# define uInt z_uInt +# define uIntf z_uIntf +# define uLong z_uLong +# define uLongf z_uLongf +# define voidp z_voidp +# define voidpc z_voidpc +# define voidpf z_voidpf + +/* all zlib structs in zlib.h and zconf.h */ +# define gz_header_s z_gz_header_s +# define internal_state z_internal_state + +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +#if defined(ZLIB_CONST) && !defined(z_const) +# define z_const const +#else +# define z_const +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +#ifndef Z_ARG /* function prototypes for stdarg */ +# if defined(STDC) || defined(Z_HAVE_STDARG_H) +# define Z_ARG(args) args +# else +# define Z_ARG(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) +# include +# if (UINT_MAX == 0xffffffffUL) +# define Z_U4 unsigned +# elif (ULONG_MAX == 0xffffffffUL) +# define Z_U4 unsigned long +# elif (USHRT_MAX == 0xffffffffUL) +# define Z_U4 unsigned short +# endif +#endif + +#ifdef Z_U4 + typedef Z_U4 z_crc_t; +#else + typedef unsigned long z_crc_t; +#endif + +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_UNISTD_H +#endif + +#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_STDARG_H +#endif + +#ifdef STDC +# ifndef Z_SOLO +# include /* for off_t */ +# endif +#endif + +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +# include /* for va_list */ +# endif +#endif + +#ifdef _WIN32 +# ifndef Z_SOLO +# include /* for wchar_t */ +# endif +#endif + +/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and + * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even + * though the former does not conform to the LFS document), but considering + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as + * equivalently requesting no 64-bit operations + */ +#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 +# undef _LARGEFILE64_SOURCE +#endif + +#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) +# define Z_HAVE_UNISTD_H +#endif +#ifndef Z_SOLO +# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif +#endif + +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 +#endif + +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) +# define Z_LARGE64 +#endif + +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 +#endif + +#if !defined(SEEK_SET) && !defined(Z_SOLO) +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif + +#ifndef z_off_t +# define z_off_t long +#endif + +#if !defined(_WIN32) && defined(Z_LARGE64) +# define z_off64_t off64_t +#else +# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) +# define z_off64_t __int64 +# else +# define z_off64_t z_off_t +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) + #pragma map(deflateInit_,"DEIN") + #pragma map(deflateInit2_,"DEIN2") + #pragma map(deflateEnd,"DEEND") + #pragma map(deflateBound,"DEBND") + #pragma map(inflateInit_,"ININ") + #pragma map(inflateInit2_,"ININ2") + #pragma map(inflateEnd,"INEND") + #pragma map(inflateSync,"INSY") + #pragma map(inflateSetDictionary,"INSEDI") + #pragma map(compressBound,"CMBND") + #pragma map(inflate_table,"INTABL") + #pragma map(inflate_fast,"INFA") + #pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/extern/for_mingw/include/zlib.h b/extern/for_mingw/include/zlib.h new file mode 100644 index 0000000000..3e0c7672ac --- /dev/null +++ b/extern/for_mingw/include/zlib.h @@ -0,0 +1,1768 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.8, April 28th, 2013 + + Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 + (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.8" +#define ZLIB_VERNUM 0x1280 +#define ZLIB_VER_MAJOR 1 +#define ZLIB_VER_MINOR 2 +#define ZLIB_VER_REVISION 8 +#define ZLIB_VER_SUBREVISION 0 + +/* + 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, + or can be done by repeated calls of the compression function. In the latter + case, the application must provide more input and/or consume the output + (providing more output space) before each call. + + The compressed data format used by default by the in-memory functions is + the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped + around a deflate stream, which is itself documented in RFC 1951. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio using the functions that start + with "gz". The gzip format is different from the zlib format. gzip is a + gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. + + This library can optionally read and write gzip streams in memory as well. + + The zlib format was designed to be compact and fast for use in memory + and on communications channels. The gzip format was designed for single- + file compression on file systems, has a larger header than zlib to maintain + directory information, and uses a different, slower check method than zlib. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never crash + even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + z_const Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total number 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 number of bytes output so far */ + + z_const char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: binary or text */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + The application must update next_in and avail_in when avail_in has dropped + to zero. It must update next_out and avail_out when avail_out has dropped + to zero. The application must initialize zalloc, zfree and opaque before + calling the init function. All other fields are set by the compression + library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this if + the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers + returned by zalloc for objects of exactly 65536 bytes *must* have their + offset normalized to zero. The default allocation function provided by this + library ensures this (see zutil.c). To reduce memory requirements and avoid + any allocation of 64K objects, at the expense of compression ratio, compile + the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or progress + reports. After compression, total_in holds the total size of the + uncompressed data and may be saved for use in the decompressor (particularly + if the decompressor wants to decompress everything in a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +#define Z_TREES 6 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 +/* Possible values of the data_type field (though see inflate()) */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is not + compatible with the zlib.h header file used by the application. This check + is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. If + zalloc and zfree are set to Z_NULL, deflateInit updates them to use default + allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at all + (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION + requests a default compromise between speed and compression (currently + equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if level is not a valid compression level, or + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). msg is set to null + if there is no error message. deflateInit does not perform any compression: + this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). Some + output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming more + output, and updating avail_in or avail_out accordingly; avail_out should + never be zero before the call. The application can consume the compressed + output when it wants, for example when the output buffer is full (avail_out + == 0), or after each call of deflate(). If deflate returns Z_OK and with + zero avail_out, it must be called again after making room in the output + buffer because there might be more output pending. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumulate before producing output, in order to + maximize compression. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In + particular avail_in is zero after the call if enough output space has been + provided before the call.) Flushing may degrade compression for some + compression algorithms and so it should be used only when necessary. This + completes the current deflate block and follows it with an empty stored block + that is three bits plus filler bits to the next byte, followed by four bytes + (00 00 ff ff). + + If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the + output buffer, but the output is not aligned to a byte boundary. All of the + input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. + This completes the current deflate block and follows it with an empty fixed + codes block that is 10 bits long. This assures that enough bytes are output + in order for the decompressor to finish the block before the empty fixed code + block. + + If flush is set to Z_BLOCK, a deflate block is completed and emitted, as + for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to + seven bits of the current block are held to be written as the next byte after + the next deflate block is completed. In this case, the decompressor may not + be provided enough bits at this point in order to complete decompression of + the data provided so far to the compressor. It may need to wait for the next + block to be emitted. This is for advanced applications that need to control + the emission of deflate blocks. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that + avail_out is greater than six to avoid repeated flush markers due to + avail_out == 0 on return. + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there was + enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the stream + are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least the + value returned by deflateBound (see below). Then deflate is guaranteed to + return Z_STREAM_END. If not enough output space is provided, deflate will + not return Z_STREAM_END, and it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered + binary. This field is only for information purposes and does not affect the + compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not + fatal, and deflate() can be called again with more input and more output + space to continue compressing. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any pending + output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, msg + may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the + exact value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit() does not process any header information -- that is deferred + until inflate() is called. +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing will + resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there is + no more input data or no more space in the output buffer (see below about + the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming more + output, and updating the next_* and avail_* values accordingly. The + application can consume the uncompressed output when it wants, for example + when the output buffer is full (avail_out == 0), or after each call of + inflate(). If inflate returns Z_OK and with zero avail_out, it must be + called again after making room in the output buffer because there might be + more output pending. + + The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, + Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much + output as possible to the output buffer. Z_BLOCK requests that inflate() + stop if and when it gets to the next deflate block boundary. When decoding + the zlib or gzip format, this will cause inflate() to return immediately + after the header and before the first block. When doing a raw inflate, + inflate() will go ahead and process the first block, and will return when it + gets to the end of that block, or when it runs out of data. + + The Z_BLOCK option assists in appending to or combining deflate streams. + Also to assist in this, on return inflate() will set strm->data_type to the + number of unused bits in the last byte taken from strm->next_in, plus 64 if + inflate() is currently decoding the last block in the deflate stream, plus + 128 if inflate() returned immediately after decoding an end-of-block code or + decoding the complete header up to just before the first byte of the deflate + stream. The end-of-block will not be indicated until all of the uncompressed + data from that block has been written to strm->next_out. The number of + unused bits may in general be greater than seven, except when bit 7 of + data_type is set, in which case the number of unused bits will be less than + eight. data_type is set as noted here every time inflate() returns for all + flush options, and so can be used to determine the amount of currently + consumed input in bits. + + The Z_TREES option behaves as Z_BLOCK does, but it also returns when the + end of each deflate block header is reached, before any actual data in that + block is decoded. This allows the caller to determine the length of the + deflate block header for later use in random access within a deflate block. + 256 is added to the value of strm->data_type when inflate() returns + immediately after reaching the end of the deflate block header. + + 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 of the uncompressed data for the + operation to complete. (The size of the uncompressed data may have been + saved by the compressor for this purpose.) The use of Z_FINISH is not + required to perform an inflation in one step. However it may be used to + inform inflate that a faster approach can be used for the single inflate() + call. Z_FINISH also informs inflate to not maintain a sliding window if the + stream completes, which reduces inflate's memory footprint. If the stream + does not complete, either because not all of the stream is provided or not + enough output space is provided, then a sliding window will be allocated and + inflate() can be called again to continue the operation as if Z_NO_FLUSH had + been used. + + In this implementation, inflate() always flushes as much output as + possible to the output buffer, and always uses the faster approach on the + first call. So the effects of the flush parameter in this implementation are + on the return value of inflate() as noted below, when inflate() returns early + when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of + memory for a sliding window when Z_FINISH is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary + below), inflate sets strm->adler to the Adler-32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the Adler-32 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() can decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically, if requested when + initializing with inflateInit2(). Any information contained in the gzip + header is not retained, so applications that need that information should + instead use raw inflate, see inflateInit2() below, or inflateBack() and + perform their own processing of the gzip header and trailer. When processing + gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output + producted so far. The CRC-32 is checked against the gzip trailer. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect check + value), Z_STREAM_ERROR if the stream structure was inconsistent (for example + next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory, + Z_BUF_ERROR if no progress is possible or if there was not enough room in the + output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and + inflate() can be called again with more input and more output space to + continue decompressing. If Z_DATA_ERROR is returned, the application may + then call inflateSync() to look for a good compression block if a partial + recovery of the data is desired. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any pending + output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by the + caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + windowBits can also be -8..-15 for raw deflate. In this case, -windowBits + determines the window size. deflate() will then generate raw deflate data + with no zlib header or trailer, and will not compute an adler32 check value. + + windowBits can also be greater than 15 for optional gzip encoding. Add + 16 to windowBits to write a simple gzip header and trailer around the + compressed data instead of a zlib wrapper. The gzip header will have no + file name, no extra data, no comment, no modification time (set to zero), no + header crc, and the operating system will be set to 255 (unknown). If a + gzip stream is being written, strm->adler is a crc32 instead of an adler32. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but is + slow and reduces compression ratio; memLevel=9 uses maximum memory for + optimal speed. The default value is 8. See zconf.h for total memory usage + as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match), or Z_RLE to limit match distances to one (run-length + encoding). Filtered data consists mostly of small values with a somewhat + random distribution. In this case, the compression algorithm is tuned to + compress them better. The effect of Z_FILTERED is to force more Huffman + coding and less string matching; it is somewhat intermediate between + Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as + fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The + strategy parameter only affects the compression ratio but not the + correctness of the compressed output even if it is not set appropriately. + Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler + decoder for special applications. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid + method), or 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. 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. When using the zlib format, this + function must be called immediately after deflateInit, deflateInit2 or + deflateReset, and before any call of deflate. When doing raw deflate, this + function must be called either before any call of deflate, or immediately + after the completion of a deflate block, i.e. after all input has been + consumed and all output has been delivered when using any of the flush + options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. 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 + provided in deflateInit or deflateInit2. Thus the strings most likely to be + useful should be put at the end of the dictionary, not at the front. In + addition, the current implementation of deflate will use at most the window + size minus 262 bytes of the provided dictionary. + + Upon return of this function, strm->adler is set to the adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) If a raw deflate was requested, then the + adler32 value is not computed and strm->adler is not set. + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if not at a block boundary for raw deflate). 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 Z_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 Z_NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different strategy. + If the compression level is changed, the input available so far is + compressed with the old level (and may be flushed); the new level will take + effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to be + compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if + strm->avail_out was zero. +*/ + +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); +/* + Fine tune deflate's internal compression parameters. This should only be + used by someone who understands the algorithm used by zlib's deflate for + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, + uLong sourceLen)); +/* + deflateBound() returns an upper bound on the compressed size after + deflation of sourceLen bytes. It must be called after deflateInit() or + deflateInit2(), and after deflateSetHeader(), if used. This would be used + to allocate an output buffer for deflation in a single pass, and so would be + called before deflate(). If that first deflate() call is provided the + sourceLen input bytes, an output buffer allocated to the size returned by + deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed + to return Z_STREAM_END. Note that it is possible for the compressed size to + be larger than the value returned by deflateBound() if flush options other + than Z_FINISH or Z_NO_FLUSH are used. +*/ + +ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, + unsigned *pending, + int *bits)); +/* + deflatePending() returns the number of bytes and bits of output that have + been generated, but not yet provided in the available output. The bytes not + provided would be due to the available output space having being consumed. + The number of bits of output not provided are between 0 and 7, where they + await more bits to join them in order to fill out a full byte. If pending + or bits are Z_NULL, then those values are not set. + + deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. + */ + +ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + deflatePrime() inserts bits in the deflate output stream. The intent + is that this function is used to start off the deflate output with the bits + leftover from a previous deflate stream when appending to it. As such, this + function can only be used for raw deflate, and must be used before the first + deflate() call after a deflateInit2() or deflateReset(). bits must be less + than or equal to 16, and that many of the least significant bits of value + will be inserted in the output. + + deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough + room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + gzip file" and give up. + + If deflateSetHeader is not used, the default gzip header has text false, + the time set to zero, and os set to 255, with no extra, name, or comment + fields. The gzip header is returned to the default state by deflateReset(). + + deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. windowBits must be greater than or equal to the windowBits value + provided to deflateInit2() while compressing, or it must be equal to 15 if + deflateInit2() was not used. If a compressed stream with a larger window + size is given as input, inflate() will return with the error code + Z_DATA_ERROR instead of trying to allocate a larger window. + + windowBits can also be zero to request that inflate use the window size in + the zlib header of the compressed stream. + + windowBits can also be -8..-15 for raw inflate. In this case, -windowBits + determines the window size. inflate() will then process raw deflate data, + not looking for a zlib or gzip header, not generating a check value, and not + looking for any check values for comparison at the end of the stream. This + is for use with other formats that use the deflate compressed data format + such as zip. Those formats provide their own check values. If a custom + format is developed using the raw deflate format for compressed data, it is + recommended that a check value such as an adler32 or a crc32 be applied to + the uncompressed data as is done in the zlib, gzip, and zip formats. For + most applications, the zlib format should be used as is. Note that comments + above on the use in deflateInit2() applies to the magnitude of windowBits. + + windowBits can also be greater than 15 for optional gzip decoding. Add + 32 to windowBits to enable zlib and gzip decoding with automatic header + detection, or add 16 to decode only the gzip format (the zlib format will + return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a + crc32 instead of an adler32. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit2 does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit2() does not process any header information -- that is + deferred until inflate() is called. +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate, + if that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the adler32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called at any + time to set the dictionary. If the provided dictionary is smaller than the + window and there is already data in the window, then the provided dictionary + will amend what's there. The application must insure that the dictionary + that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) 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 inflateGetDictionary OF((z_streamp strm, + Bytef *dictionary, + uInt *dictLength)); +/* + Returns the sliding dictionary being maintained by inflate. dictLength is + set to the number of bytes in the dictionary, and that many bytes are copied + to dictionary. dictionary must have enough space, where 32768 bytes is + always enough. If inflateGetDictionary() is called with dictionary equal to + Z_NULL, then only the dictionary length is returned, and nothing is copied. + Similary, if dictLength is Z_NULL, then it is not set. + + inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the + stream state is inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a possible full flush point (see above + for the description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync searches for a 00 00 FF FF pattern in the compressed data. + All full flush points have this pattern, but not all occurrences of this + pattern are full flush points. + + inflateSync returns Z_OK if a possible full flush point has been found, + Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point + has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. + In the success case, the application may save the current current value of + total_in which indicates where valid compressed data was found. In the + error case, the application may repeatedly call inflateSync, providing more + input each time, until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when randomly accessing a large stream. The + first pass through the stream can periodically record the inflate state, + allowing restarting inflate at those points when randomly accessing the + stream. + + inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being Z_NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. The + stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +*/ + +ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, + int windowBits)); +/* + This function is the same as inflateReset, but it also permits changing + the wrap and window size requests. The windowBits parameter is interpreted + the same as it is for inflateInit2. + + inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL), or if + the windowBits parameter is invalid. +*/ + +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + This function inserts bits in the inflate input stream. The intent is + that this function is used to start inflating at a bit position in the + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + If bits is negative, then the input stream bit buffer is emptied. Then + inflatePrime() can be called again to put bits in the buffer. This is used + to clear out bits leftover after feeding inflate a block description prior + to feeding inflate codes. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); +/* + This function returns two values, one in the lower 16 bits of the return + value, and the other in the remaining upper bits, obtained by shifting the + return value down 16 bits. If the upper value is -1 and the lower value is + zero, then inflate() is currently decoding information outside of a block. + If the upper value is -1 and the lower value is non-zero, then inflate is in + the middle of a stored block, with the lower value equaling the number of + bytes from the input remaining to copy. If the upper value is not -1, then + it is the number of bits back from the current bit position in the input of + the code (literal or length/distance pair) currently being processed. In + that case the lower value is the number of bytes already emitted for that + code. + + A code is being processed if inflate is waiting for more input to complete + decoding of the code, or if it has completed decoding but is waiting for + more output space to write the literal or match data. + + inflateMark() is used to mark locations in the input data for random + access, which may be at bit positions, and to note those cases where the + output of a code may span boundaries of random access blocks. The current + location in the input stream can be determined from avail_in and data_type + as noted in the description for the Z_BLOCK flush parameter for inflate. + + inflateMark returns the value noted above or -1 << 16 if the provided + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); +/* + inflateGetHeader() requests that gzip header information be stored in the + provided gz_header structure. inflateGetHeader() may be called after + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be + used to force inflate() to return immediately after header processing is + complete and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When any + of extra, name, or comment are not Z_NULL and the respective field is not + present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, + unsigned char FAR *window)); + + Initialize the internal stream state for decompression using inflateBack() + calls. The fields zalloc, zfree and opaque in strm must be initialized + before the call. If zalloc and zfree are Z_NULL, then the default library- + derived memory allocation routines are used. windowBits is the base two + logarithm of the window size, in the range 8..15. window is a caller + supplied buffer of that size. Except for special applications where it is + assured that deflate was used with small window sizes, windowBits must be 15 + and a 32K byte window must be supplied to be able to decompress general + deflate streams. + + See inflateBack() for the usage of these routines. + + inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of + the parameters are invalid, Z_MEM_ERROR if the internal state could not be + allocated, or Z_VERSION_ERROR if the version of the library does not match + the version of the header file. +*/ + +typedef unsigned (*in_func) OF((void FAR *, + z_const unsigned char FAR * FAR *)); +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); + +ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc)); +/* + inflateBack() does a raw inflate with a single call using a call-back + interface for input and output. This is potentially more efficient than + inflate() for file i/o applications, in that it avoids copying between the + output and the sliding window by simply making the window itself the output + buffer. inflate() can be faster on modern CPUs when used with large + buffers. inflateBack() trusts the application to not change the output + buffer passed by the output function, at least until inflateBack() returns. + + inflateBackInit() must be called first to allocate the internal state + and to initialize the state with the user-provided window buffer. + inflateBack() may then be used multiple times to inflate a complete, raw + deflate stream with each call. inflateBackEnd() is then called to free the + allocated state. + + A raw deflate stream is one with no zlib or gzip header or trailer. + This routine would normally be used in a utility that reads zip or gzip + files and writes out uncompressed files. The utility would decode the + header and process the trailer on its own, hence this routine expects only + the raw deflate stream to decompress. This is different from the normal + behavior of inflate(), which expects either a zlib or gzip header and + trailer around the deflate stream. + + inflateBack() uses two subroutines supplied by the caller that are then + called by inflateBack() for input and output. inflateBack() calls those + routines until it reads a complete deflate stream and writes out all of the + uncompressed data, or until it encounters an error. The function's + parameters and return types are defined above in the in_func and out_func + typedefs. inflateBack() will call in(in_desc, &buf) which should return the + number of bytes of provided input, and a pointer to that input in buf. If + there is no input available, in() must return zero--buf is ignored in that + case--and inflateBack() will return a buffer error. inflateBack() will call + out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() + should return zero on success, or non-zero on failure. If out() returns + non-zero, inflateBack() will return with an error. Neither in() nor out() + are permitted to change the contents of the window provided to + inflateBackInit(), which is also the buffer that out() uses to write from. + The length written by out() will be at most the window size. Any non-zero + amount of input may be provided by in(). + + For convenience, inflateBack() can be provided input on the first call by + setting strm->next_in and strm->avail_in. If that input is exhausted, then + in() will be called. Therefore strm->next_in must be initialized before + calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called + immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in + must also be initialized, and then if strm->avail_in is not zero, input will + initially be taken from strm->next_in[0 .. strm->avail_in - 1]. + + The in_desc and out_desc parameters of inflateBack() is passed as the + first parameter of in() and out() respectively when they are called. These + descriptors can be optionally used to pass any information that the caller- + supplied in() and out() functions need to do their job. + + On return, inflateBack() will set strm->next_in and strm->avail_in to + pass back any unused input that was provided by the last in() call. The + return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR + if in() or out() returned an error, Z_DATA_ERROR if there was a format error + in the deflate stream (in which case strm->msg is set to indicate the nature + of the error), or Z_STREAM_ERROR if the stream was not properly initialized. + In the case of Z_BUF_ERROR, an input or output error can be distinguished + using strm->next_in which will be Z_NULL only if in() returned an error. If + strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning + non-zero. (in() will always be called before out(), so strm->next_in is + assured to be defined if out() returns non-zero.) Note that inflateBack() + cannot return Z_OK. +*/ + +ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); +/* + All memory allocated by inflateBackInit() is freed. + + inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream + state was inconsistent. +*/ + +ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +/* Return flags indicating compile-time options. + + Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: + 1.0: size of uInt + 3.2: size of uLong + 5.4: size of voidpf (pointer) + 7.6: size of z_off_t + + Compiler, assembler, and debug options: + 8: DEBUG + 9: ASMV or ASMINF -- use ASM code + 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention + 11: 0 (reserved) + + One-time table building (smaller code, but not thread-safe if true): + 12: BUILDFIXED -- build static block decoding tables when needed + 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed + 14,15: 0 (reserved) + + Library content (indicates missing functionality): + 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking + deflate code when not needed) + 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect + and decode gzip streams (to avoid linking crc code) + 18-19: 0 (reserved) + + Operation variations (changes in library functionality): + 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate + 21: FASTEST -- deflate algorithm with only one, lowest compression level + 22,23: 0 (reserved) + + The sprintf variant used by gzprintf (zero is best): + 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format + 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! + 26: 0 = returns value, 1 = void -- 1 means inferred string length returned + + Remainder: + 27-31: 0 (reserved) + */ + +#ifndef Z_SOLO + + /* 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 be modified if + you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total size + of the destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); +/* + compressBound() returns an upper bound on the compressed size after + compress() or compress2() on sourceLen bytes. It would be used before a + compress() or compress2() call to allocate the destination buffer. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total size + of the destination buffer, which must be large enough to hold the entire + uncompressed data. (The size of the uncompressed data must have been saved + previously by the compressor and transmitted to the decompressor by some + mechanism outside the scope of this compression library.) Upon exit, destLen + is the actual size of the uncompressed buffer. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In + the case where there is not enough room, uncompress() will fill the output + buffer with the uncompressed data up to that point. +*/ + + /* gzip file access functions */ + +/* + This library supports reading and writing files in gzip (.gz) format with + an interface similar to that of stdio, using the functions that start with + "gz". The gzip format is different from the zlib format. gzip is a gzip + wrapper, documented in RFC 1952, wrapped around a deflate stream. +*/ + +typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ + +/* +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", 'R' for run-length encoding as in "wb1R", or 'F' + for fixed code compression as in "wb9F". (See the description of + deflateInit2 for more information about the strategy parameter.) 'T' will + request transparent writing or appending with no compression and not using + the gzip format. + + "a" can be used instead of "w" to request that the gzip stream that will + be written be appended to the file. "+" will result in an error, since + reading and writing to the same gzip file is not supported. The addition of + "x" when writing will create the file exclusively, which fails if the file + already exists. On systems that support it, the addition of "e" when + reading or writing will set the flag to close the file on an execve() call. + + These functions, as well as gzip, will read and decode a sequence of gzip + streams in a file. The append function of gzopen() can be used to create + such a file. (Also see gzflush() for another way to do this.) When + appending, gzopen does not test whether the file begins with a gzip stream, + nor does it look for the end of the gzip streams to begin appending. gzopen + will simply append a gzip stream to the existing file. + + 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. When + reading, this will be detected automatically by looking for the magic two- + byte gzip header. + + gzopen returns NULL if the file could not be opened, if there was + insufficient memory to allocate the gzFile state, or if an invalid mode was + specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). + errno can be checked to determine if the reason gzopen failed was that the + file could not be opened. +*/ + +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 (if 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 fd = dup(fd_keep); gz = gzdopen(fd, + mode);. The duplicated descriptor should be saved to avoid a leak, since + gzdopen does not close fd if it fails. If you are using fileno() to get the + file descriptor from a FILE *, then you will have to use dup() to avoid + double-close()ing the file descriptor. Both gzclose() and fclose() will + close the associated file descriptor, so they need to have different file + descriptors. + + gzdopen returns NULL if there was insufficient memory to allocate the + gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not + provided, or '+' was provided), or if fd is -1. The file descriptor is not + used until the next gz* read, write, seek, or close operation, so gzdopen + will not detect if fd is invalid (unless fd is -1). +*/ + +ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); +/* + Set the internal buffer size used by this library's functions. The + default buffer size is 8192 bytes. This function must be called after + gzopen() or gzdopen(), and before any other calls that read or write the + file. The buffer memory allocation is always deferred to the first read or + write. Two buffers are allocated, either both of the specified size when + writing, or one of the specified size and the other twice that size when + reading. A larger buffer size of, for example, 64K or 128K bytes will + noticeably increase the speed of decompression (reading). + + The new buffer size also affects the maximum length for gzprintf(). + + gzbuffer() returns 0 on success, or -1 on failure, such as being called + too late. +*/ + +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 is not in gzip format, gzread copies the given number of + bytes into the buffer directly from the file. + + After reaching the end of a gzip stream in the input, gzread will continue + to read, looking for another gzip stream. Any number of gzip streams may be + concatenated in the input file, and will all be decompressed by gzread(). + If something other than a gzip stream is encountered after a gzip stream, + that remaining trailing garbage is ignored (and no error is returned). + + gzread can be used to read a gzip file that is being concurrently written. + Upon reaching the end of the input, gzread will return with the available + data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then + gzclearerr can be used to clear the end of file indicator in order to permit + gzread to be tried again. Z_OK indicates that a gzip stream was completed + on the last gzread. Z_BUF_ERROR indicates that the input file ended in the + middle of a gzip stream. Note that gzread does not return -1 in the event + of an incomplete gzip stream. This error is deferred until gzclose(), which + will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip + stream. Alternatively, gzerror can be used before gzclose to detect this + case. + + gzread returns the number of uncompressed bytes actually read, less than + len for end of file, or -1 for error. +*/ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + voidpc buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes written or 0 in case of + error. +*/ + +ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the arguments to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written, or 0 in case of error. The number of + uncompressed bytes written is limited to 8191, or one less than the buffer + size given to gzbuffer(). The caller should assure that this limit is not + exceeded. If it is exceeded, then gzprintf() will return an error (0) with + nothing written. In this case, there may also be a buffer overflow with + unpredictable consequences, which is possible only if zlib was compiled with + the insecure functions sprintf() or vsprintf() because the secure snprintf() + or vsnprintf() functions were not available. This can be determined using + zlibCompileFlags(). +*/ + +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. If any characters are read or if len == 1, the + string is terminated with a null character. If no characters are read due + to an end-of-file or len < 1, then the buffer is left untouched. + + gzgets returns buf which is a null-terminated string, or it returns NULL + for end-of-file or in case of error. If there was an error, the contents at + buf are indeterminate. +*/ + +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. This is implemented as a macro for speed. + As such, it does not do all of the checking the other functions do. I.e. + it does not check to see if file is NULL, nor whether the structure file + points to has been clobbered or not. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read as the first character + on the next read. At least one character of push-back is allowed. + gzungetc() returns the character pushed, or -1 on failure. gzungetc() will + fail if c is -1, and may fail if a character has been pushed but not read + yet. If gzungetc is used immediately after gzopen or gzdopen, at least the + output buffer size of pushed characters is allowed. (See gzbuffer above.) + The pushed character will be discarded if the stream is repositioned with + gzseek() or gzrewind(). +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter flush + is as in the deflate() function. The return value is the zlib error number + (see function gzerror below). gzflush is only permitted when writing. + + If the flush parameter is Z_FINISH, the remaining data is written and the + gzip stream is completed in the output. If gzwrite() is called again, a new + gzip stream will be started in the output. gzread() is able to read such + concatented gzip streams. + + gzflush should be called only when strictly necessary because it will + degrade compression if called too often. +*/ + +/* +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, and is zero when starting, even if appending or + reading a gzip stream from the middle of a file using gzdopen(). + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); + + Returns the current offset in the file being read or written. This offset + includes the count of bytes that precede the gzip stream, for example when + appending or when using gzdopen() for reading. When reading, the offset + does not include as yet unused buffered input. This information can be used + for a progress indicator. On error, gzoffset() returns -1. +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns true (1) if the end-of-file indicator has been set while reading, + false (0) otherwise. Note that the end-of-file indicator is set only if the + read tried to go past the end of the input, but came up short. Therefore, + just like feof(), gzeof() may return false even if there is no more data to + read, in the event that the last read request was for the exact number of + bytes remaining in the input file. This will happen if the input file size + is an exact multiple of the buffer size. + + If gzeof() returns true, then the read functions will return no more data, + unless the end-of-file indicator is reset by gzclearerr() and the input file + has grown since the previous end of file was detected. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns true (1) if file is being copied directly while reading, or false + (0) if file is a gzip stream being decompressed. + + If the input file is empty, gzdirect() will return true, since the input + does not contain a gzip stream. + + If gzdirect() is used immediately after gzopen() or gzdopen() it will + cause buffers to be allocated to allow reading the file to determine if it + is a gzip file. Therefore if gzbuffer() is used, it should be called before + gzdirect(). + + When writing, gzdirect() returns true (1) if transparent writing was + requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: + gzdirect() is not needed when writing. Transparent writing must be + explicitly requested, so the application already knows the answer. When + linking statically, using gzdirect() will include all of the zlib code for + gzip file reading and decompression, which may not be desired.) +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file and + deallocates the (de)compression state. Note that once file is closed, you + cannot call gzerror with file, since its structures have been deallocated. + gzclose must not be called more than once on the same file, just as free + must not be called more than once on the same allocation. + + gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a + file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the + last read ended in the middle of a gzip stream, or Z_OK on success. +*/ + +ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); +/* + Same as gzclose(), but gzclose_r() is only for use when reading, and + gzclose_w() is only for use when writing or appending. The advantage to + using these instead of gzclose() is that they avoid linking in zlib + compression or decompression code that is not used when only reading or only + writing respectively. If gzclose() is used, then both compression and + decompression code will be included the application when linking to a static + zlib library. +*/ + +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. + + The application must not modify the returned string. Future calls to + this function may invalidate the previously returned string. If file is + closed, then the string previously returned by gzerror will no longer be + available. + + gzerror() should be used to distinguish errors from end-of-file for those + functions above that do not distinguish those cases in their return values. +*/ + +ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +/* + Clears the error and end-of-file flags for file. This is analogous to the + clearerr() function in stdio. This is useful for continuing to read a gzip + file that is being written concurrently. +*/ + +#endif /* !Z_SOLO */ + + /* 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 Z_NULL, this function returns the + required initial value for the checksum. + + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. + + Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +/* +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, + z_off_t len2)); + + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note + that the z_off_t type (like off_t) is a signed integer. If len2 is + negative, the result has no meaning or utility. +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is Z_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(); +*/ + +/* +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); + + Combine two CRC-32 check values into one. For two sequences of bytes, + seq1 and seq2 with lengths len1 and len2, CRC-32 check values were + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ + (int)sizeof(z_stream)) +#define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, (int)sizeof(z_stream)) + +#ifndef Z_SOLO + +/* gzgetc() macro and its supporting function and exposed data structure. Note + * that the real internal state is much larger than the exposed structure. + * This abbreviated structure exposes just enough for the gzgetc() macro. The + * user should not mess with these exposed elements, since their names or + * behavior could change in the future, perhaps even capriciously. They can + * only be used by the gzgetc() macro. You have been warned. + */ +struct gzFile_s { + unsigned have; + unsigned char *next; + z_off64_t pos; +}; +ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ +#ifdef Z_PREFIX_SET +# undef z_gzgetc +# define z_gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) +#else +# define gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) +#endif + +/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or + * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if + * both are true, the application gets the *64 functions, and the regular + * functions are changed to 64 bits) -- in case these are set on systems + * without large file support, _LFS64_LARGEFILE must also be true + */ +#ifdef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); +#endif + +#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) +# ifdef Z_PREFIX_SET +# define z_gzopen z_gzopen64 +# define z_gzseek z_gzseek64 +# define z_gztell z_gztell64 +# define z_gzoffset z_gzoffset64 +# define z_adler32_combine z_adler32_combine64 +# define z_crc32_combine z_crc32_combine64 +# else +# define gzopen gzopen64 +# define gzseek gzseek64 +# define gztell gztell64 +# define gzoffset gzoffset64 +# define adler32_combine adler32_combine64 +# define crc32_combine crc32_combine64 +# endif +# ifndef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); +# endif +#else + ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); +#endif + +#else /* Z_SOLO */ + + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); + +#endif /* !Z_SOLO */ + +/* hack for buggy compilers */ +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; +#endif + +/* undocumented functions */ +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); +ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); +ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); +ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); +ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); +#if defined(_WIN32) && !defined(Z_SOLO) +ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, + const char *mode)); +#endif +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, + const char *format, + va_list va)); +# endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ diff --git a/extern/for_mingw/lib/libbz2.a b/extern/for_mingw/lib/libbz2.a new file mode 100644 index 0000000000000000000000000000000000000000..76d84caffc64a4232414b06c9b45acedd84fb6df GIT binary patch literal 75156 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 DxduE@ literal 0 HcmV?d00001 diff --git a/extern/for_mingw/lib/libjpeg.a b/extern/for_mingw/lib/libjpeg.a new file mode 100644 index 0000000000000000000000000000000000000000..7a003aca0e58bca96396575e0312334debd0d966 GIT binary patch literal 205042 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 z zZOO?VOuQc3r8nYY+SDPpvcrRUI?Pb=GT=siTk#3B<@yJ#AGPkh|oX|e@XveeS zLz1_;Ul4g#y`_$MRclj%osk2H@<2Kv^#l3pjm#-IIU5MJX&+^$4ta`C5J3z>^I|Yi zWd7V`A|E?{MLV9&{FQ$5H-@4Pz)$3#oUD*=W!E9%Va6DJJ$Hxpk(UU#YC(Uc_@v$6 zKaa$#8oFnXrjY+_@Hcm;ReL~s>LYisE%Ki68u-7?j4%0n0r*>*s0w@sbF@AoZiSFD zNIUfibAG{ien5@+1Z;*!f8#~yp{w|9G1Q=a?1hn2!e=p_S~tt9zk%M!stt;MC~}NFV~B`jIc}VQXZ_q*8%*RV}9lOL-VWq!E5j}hhGmMI@9jK)BNgrkaOv0 z#11^@4eoy^AKu~__=xo=;n}t2FqF~Dk(0XSbHHGc13EgbuoSdGwZ{u0BNGpLm6l-V zvf-s2rJt#Fu;nws8lQrNGtXhEkh14Q@Tk6Do%B`exKC?v$E!~TTjDdjSG+0aLz*rS zBBj<1*5A-yD}Ec65v9IGDSnF~_;myH*YNHxerpSL4uG5&;T*bzx{39^WPq!*+u+KZ zbs!!iJot=ZI@UMd;kDwOU-51cyOzY_U9B79AQMEgqtprVBA*y{A`378hHpATiAi21 z72K|BH{k^{@rc-ZNIN(!xIJFe9XV`V12EdVi2-Gc3WPwkr%T_Xw4_j+N9IvP;#vYqUl;=4UY@ z-d+5;X4GPl)Q1Jd+f$uGl=gUKckt~Mn8_ZK+dRgh!DC$UX?gk>Q-7hD=6W^J9C6`J zLG6RU=E2sX#2sF}QP~#Ux9lveXRTwMVR$P(zB{;W1$?7krXfq32BZ`Iq@W+u$Qa%6 zC5F}>&kFwlBO76#v>VG^wJURc!uUklarG?mqW{+({-|_^t#36aIT+A}$^Mn-s?BuA zYw#$D*SInKP@@Em_>jmuA~%6gGUoz)Yl)WEln*K7s~zP|*E| zW{dhZqXNN9phIDZ2MJLoneJV&5X$V2!B-Z%D)TNt zjLk<-nsqWGiHzT+y~~HV`XNL^(Y*RnZ9c5$$AYV7cCUs;4@52mIH&dmjK+JYq}mg3 zSB67twWfT*+}acF$QO2$YhVizCGru}AdoD|NtWj&SN+(foan$h1dJBHhVL-gnCS2= zzZ=~lzuu^~L!|s-AQp}psuw@nku0pWh)+4CrG4>Az{U-TSE8=RdE=Gf@HkJr5>+wI z9j`=Hj8o#3(5LL+YjIDcK|hM@eERld`;t}7?7dK8eW{NS-y4XJh4Q0V@v*0xN9TH* zN9R@O z?8sqdhqE+ZBr5$31IE`oX^ndW!XA(7MoQ4Br6rNsqJ}_0rGn}?JMx}>6b-MLpCIBn zI5v_WMK^^*2) zj!unWMNKbOpmM+mim)xeUZVup(Xs)<$PV7LhU`?ECw(YcHI$SU%~zxElJ@4} z!)&(Nz&cNS0?=10@d-d*t)R)BphONDt6<8cKCy^cS`xk+8H9h|oxI(E56HzHcKNcj z!(Nt;W&}i!1^;19#)AJS?O5<1rR5t+%Qv9o8_VkI zQVMYd2EjoJydxK6=E!BA(E_#EEcznd#_I^{`{4A5Wh}xn$o)CfNj9L+8`Hah zl|Gy+Ju4J!$7~XUB7NNkrsxQti#kEie;-Cz5_%l4Jtq?Rzf$YHqp*H?92d70g;Itu zuCj-H9N)D@tiX0-r5cu#dIMPa2Cwz!fU9-69HLX}mZDy68vwU7XFDX#&A{tiQpmuo zq2N9>x)ilRv}kt95;_ZlC20kTB+;vNZ6F2j`FlPIAflSBT|DEVVuyLH~&i#De+cb0w|{=C(~oiVya5ioCq5bwjjWDBn!x;lltE zxS48GB@0maN65-V{$pf;(Mh8_JOI1Vp+@V;JMe>?cnI}iu@);Av1AYa8&(C60|O>Q zmR5LE2YorMSiR~&xl{k}ypL}<6!@QL8lucn9HH~`U9Nc z@(MWwpHN7x!Ansr6vd$wD#;D!vBZg@fU*l5(|1w?<27H43FsN8;x&+w8QnpMGx}a? z><$Q}v4G9FtoAb~0k=b$4yZ95B>)(DbXZh(f!-ypWM#Iz=kgB{&69M)b>LzsWlyoYsMtAEw)v9+ePmb*r1@T$kk^j)YGTuQ; zjjHt;yBHW2Fy6w`WUDZm=*XZZ3W!_(ylkgHNdi*fQhpr&#dNGX1}0{wDGS`e0wd&8 z_LDQ8gEO@-4lcE7Cs-Iq4b?zqrTGMJyzv>`k;jaifmgOSpNX*WpQb>8^05ZD3~cfx zr(mT*_KIPN{6}l4Fh!5viAQY5gXdu;vvjwT3ayKypNw7)INzrE zzVq|6*?{FEhBpyenL2!i_7A1D3qys&L7=*35PoaBpq*SCR*S_Ju|h)7H$|nOg#sx) znt_)%6%C`#@LyyYg;%4$Wmt;L0ptMH;xMC&1f^@#y4XFyAJ10nV`9dO<~MdPLF3$j zaX>fDeFm|`B7~9X7>C8<;|4&63$QD}hrD4o(M|d>a)(O7)0mN+`p~DehQtEZMQ{T` zsD%wusOlTGc4NYVidMW$t$#j@-1c-)^)`J0-713m=O+q(jz^JNUpQXf)SBEd$W@Cn zfMCof8U@PE)S&{b{ofVAu%M9BqfneZr;wyDk^g6G5xUvbB{U~9JaHN`Myr3G^900& z_T~R6GLV)ply@>X1yu1F;N7Duflb{6y_+#WAoV5+|II2=^lVWiD4X7h(y%2ez<%sT zyGX5&*+TSA_jDx+*CW+vy)}f_IJ$&01{k$yRYU8f4DgO*3OJn?p6p6Cu)QdhvLR%^ z$FP(E?zSy$5Ve1aTKDLEtjxinmZmd4gZo<0M2+wUu)Ym3K|I@H587g7Z%AyI%z`|H z;P*7D^-0dpsr4OOSfj;9X>!#~y95jNoIsVLJ_|&B7CnXstYZEIPzrnhdU8W98Q`eT z1CIK92MjG_ok~wCQ=h0y<2E+VLM@}aBl+M#fx3o^#;|^+iE9IYAVwhMt_@)Ikr&JJ z%<_j1pgk%FSS-Ip0bS5$UwW~y7px^J=hR2x!@+wQtv8BVrB2W@7@U~;1d8h&4UND; z0Kf{xcd`hxn{bh;V*FlXrkmlFYLX9@W=S>4$2>piXX`53sTm4A2(~zSGnyH^z}uMR z#S=Dj)&M*UbqqHgRo(~V%0of1QU;6fm`A-x$=?3QKKuJ$StBuy@9{e_AtxQ**=nh= zvjh#ArTTKRo5j>@)t9s0RDI1>eKD>PC_RnO z0tjj{zXBcA0_C`#A4mse(Y*Xe7%krmPbZt+S{^s3QU(Q48})^?$X$Fp~%yTjmYwkRlv z#2SlJdaM2_iunZXbcpQ~HMk>iEqV*+Bs`uaOS}zT1ciG%eW?>@jUssnVl5TMc8i9@ zFVf*qjN^)?C&X-dGi=#ua)RPxIe^TKId$~RX_g{dfmR9;vP;s$b_6c$#dtx+aR(WY zo_t??vfJo_a3u-@rLqme@f=qfEtmFmn_A2j|Z-&2mU-4gZ!cGwEhK)c|G+`@RS7URDfE&;S%AIs7~nO*GdbG#J-CBCusEqjHU>xqL~Er%*0waCT6ChX>drz6q1Lz_Mmxjo~> z1ki{gh~oD}p4aOb@`GP9kv(cvt=E}*aOVq5rbcgvJ5!u`QN_Fzh9`Di{1s}mAoYKu-fYtI7vz*E677(Ig&pD;_RSL8fR2mEcZTW{>~}x)q~@=~l}~lp1F+#Wyv5ob`b(ME9MecXxd)*wv6F6?xkwN#O)T%3l*Rt@-1T=D6{Nuy^t@6AkHpmabr_@v{=wR zOTntzkGQJ#6MY|O)iJ!Wy?CFF{sRVXfR|#KeB4ATS`V?VHaq=1DkjskIvV3vtih7{ zYc|GLBMWv@UjJ9EJd~x#YH;daQMQ9mQgPBxCJQT+E|ls_<341+4lYgbZ8bVipvn%7 zh|!&ipsS0va72v0Oypg>xbY$!nK!<%Hq+0%KoQ#V&_h%Z%-5zarU_=z_xvO0Xne4- z56(dG{>?&EIb2tMG0f)g8A0E_=aZZ^V?HCKwg}x4>7iTT&YwgcpX3}ee$Q^aa2x5J z!5ENM5#j?qLIP2he}U++eae=R8PoW+ble;e7hjt36l#UIt`MZ>r1#ifQPhjx8YEz^^u7-!bc~#?~@`l+hR(j?x3@n6AV;O_7|Rt3iJj zlC-i@^9B?&Iq2D;Fa1Eg=D7YghHFlQQb&AP{8YEHD?YQ+`Td0We$xK_b$n)5=DYs3 z{1Bh{b-dq%!A|eoH)ZsV1uH+rhSC*)777}1ApqE7Y(zK z!Xl`;!n1Q=Zu9ftG-w~S=jdJ^4tmg5zLomKyZWCEMD$^n_K%XBHvMEytM*ZT>YzKPRqsk+*kC8Utm1eU6v~U?H)swIL=%$x z^HEe|8-7^s8Z-sT{N+kYtPVmizwm5G0VD{6&J5y#L1z){4yGdejf;?g2?yh8uD`(N zY7wQd8m>n0b1W?495G{kjwhF%6wn8uWHZmNkta~}#)O1>jRrH}W;~PmC8j^jg-bF) zH^*a*U-By!#yQ7hxjt1Kn1ll3u$$X_2{)H^Vy@zr9Ef4~eh6Tgr%eS=&qJG_I9d}= zjx)~?eCbJ;6r5y%-&nVv9|*steeAA1p`5#0JNUJ}S8ImLo}7A4R=61YbsMOmq+S8{ zyy(|zebGJod!f{4KHZ4t#&1)Uqj1q8=BZ;i^5`WF3u9^8Pcm7a()VcFydq0ac(0i9 z!H`ki~Cctw8vZ zQ;{3fOJ0Cvb;l>6?0I5Ah!-Q~=&1PI@kyxJ35xlu#3w70Q=uTo-KtDoa1uiW2wJ;^W$2Fj{uyEQsL0lyAS_Lm^g zWe}_83W$3}9tOwtmEQ0am{ZioaJ6n>z#HpGPQ4zh8&=?CAvHP@PK~~|7-law_?o&Q zr5#d4q1|FN#(10o#?=@f5q#Uuw+RIIk*svsW9Fna=PMYm+ls;xf_!Yc0&Ldt~y4%X*fhfkPzZr2KEXSshb7g zZ!zsUBz(C$4x65wI=EXu0Vc${lM}b1fXkpQ$)bm39Yex#2HXcoT#_CdT8EK7@cmZU z`SY|x9?kH^Zw13|bH{Imyxyk7Z*>Q|!snHZJ{5UOPnX@+9l@#;;3zvU@=ED}bn`my zMw*^uOtJJ^&?akdUX3JK<9YxYSGH=DbnI$n|HH}7Nso zST;a>&6Rn+%<`S|&&~D1JVU$!s$G>x1fV<|@Z5m9#u3byR#doLBVG7WqxT8Ws*a|D z@GP}%nyiZdQ-vCP12&Z>VjRO0 zpLyDY%YP@%nsE6^?_EeGb75BKM%ua5Vt()#2qwAcHCzDVJDL!91OXm8{f+>*A)jiD zcK{1)ec%M543NDX;yp54;$P5a`&bsIe*pkvon8igC2Jqp4Png(VC- z$z#8gK{tYR2yR68@pTEpuB@4f%DEWs7?jw`%0Q3JtHTR~jm0cOcPqqa3HQr3BEDKT zX4XYC3_O_scVNDYm?PfgXhlyc&B1oL z9|HX+;)~zh9c<=)h|_GeV7*kR(aV^J#`6ME)cl0T9d`)zWx{V@xll~bB|IkOrlSe6 zdlZHrH2ExU92D=Ye2z?#x{22)NpEQ|wd`CmUc%#4&!i>8E`x$#3YIJaTQMeA>43Nw z=n*e1*_b?#XZ#y-=%|c9v@T~}y{l!{9sp5_T4)TuOMdrTf!Du_UT_+gIkZmX7v)aW zKKZRS^Yg3GEA9OH#DazhnTD$-uxjR!Kz%v(^PQ4D)ZJ&m-6y9rcaU{pRcs$WZ=DEn zf_aPY#G5JP?Ae(b6n#n1-zOI{hSaU-Q~e<_qfqCf4>JOeh(~2(%jlidr~YdDmDdIB z$Q9Zdy{o@mkG^I_f!0RH_ZQ`7e-lxl&CzT6`)(3uoP&?1e;pr_LnYQzP~qrEz;#SB zrsC7M+!8vxwj3a_x_XRDu9-B3XL6R7L8`5*hMx1Z$~4jJqz!~19Vfh&1N;@ zI26>jS05H=3uDmN_$_A?<=Fv%7swsn6b*Um0^(6P%v5c&k08l1BuQZ5sosvk3v?06 z;Z1_!yAHuuR(5KgaB%^^Rz18bIc$*P@>xdtZQB+7Z)QbrM?{GW>QiOn z`yBX^_bHpzX6)1*N9tO|>7T>-in}q;dx8_^2R*e{wr@X61T?r7fZOf+sJu=tZUSgB@2-=?*sGS z8(D_Sz#@R$@1O0zXVKyni~O0Z5B+!Zj!2it9@ivgKDZV~!b>7y`Q48f|KgAzwdB z{1B7lbC0h}!Bgiq@NwaSyHIHV+{N>j`4=sgRk(PmSs~xfaPQka2sDKz^Vwuh`2Ho} zZF>c#3~$1-T88g5pM>*&L9cfUZavqHa|uzwEvEAp&EYkhqEc`0M;6(l!8&)zd+8Rh z@ZS{)g>ZZHG~7H1VV}Kl!2^^Y+@NaZOsVy&TJ*3s@2U6W>Sp z-}6>H_ZY{ucvX2z9B-rYraIon<&Af|RrPv9wyW?zivM5Y|5x}=JTdpEf%$7aqXrhN z@s1i;s12wbIMn^0xdRJv!(PFt=7IU6T5yxzD+9fid6WBrj>((Q5A>$In!XuG{9csz zOZ?~aH25proBGLf>}l}#Pu1l9@RP?;;zl!5#`5Db!8>yYdPn6=8A#sq`&0PNKHurS zH{pBqG~cU`{_ptSgzvlYWck*TziY@}%?oty&vL=mZD4CN*xEweKkNmWmFlk>y9%vpG-+9I3xV%LUc^#7{ZfXpGcXQ8jxvn(J%^M#}JX26w zapxmSImZl6%wv5`Mf?p=tkcyO`|59g!}ksNUU<&w(?5srQ@`Q+o5cSO-@hdO(|l(= z7eep~2f18#oATn|RkMRTm3j9#-p1rXZ1W*TK8TT*)$E#y|92v<=wO%YfA=eUCGO5% z@-Zs!-d+%qaS!<%i_B^N{))T<=gJ#0@#-qa|5m`N0P7lvm;P-@ji(7!*T>b7?*&3qkl^ye1AG&CO)&E^Wq~<} ziXN4>+zh!~wsFxo$XJ*{Ai!U6tn^*BdsLD%FdiQF*NMXORC~G@0B6&p+0A z6JUjC&Hf0v?zg%|CVCBn>CbGxBiUQyoX@NFu-4W*ONzl;y}JnreY z#N^kPNFSZ#a!rS>oF@HH_ow|P7k0U#T)EJb)8t#?PW6*RRbGE$RKgB%y#`_CtGOpYZoE}_53%MX?j?xhg`(VeI$5h6IOL9gP>;)V|F$16O`(v9 z?Z~(42QJqxl7+YHKtFBf_n%CwLD*qkAA`ypTy2)GsLp+2rG*KGXWfd7TU zXOS?jHA)edo}TgEFvXoQG2--a!*VH<7OGd9czMng4_^E(L1 zT!y2bWvCn>-nd-oT5iK0v|(#(*dsQK$63p?f3rihuXM11!-joohj??Fq~I**nM^z0 z4n1y%o2|!$Hmm_5DY2b4j91!ASQ$dYkxQ1V!iKH1VYN1F zvkhyoVVyS21>a2OHy0t9-$H~W%}?5}jR=huG<)HJ$#~zkL;q=q{(z9w#=qFGCL5NG z=18Vh5t2A6ZP)~aB#wVH4i#KtrTq^(^a4VXf)qm1 zn&p1W$~l0L%=s#WBn7kV(DwpXyt@&S@pObH3R>#z(8qR2xzzf4ksYeALwDGrRd(oS zm%Ciw6Z!qt4sEqVZ`q+w?T}}vm7*9SN%IgeN|y2>J9PJG3s#6$SALy6+vS3*09*G4 zLX$=4bA;H&p+4@Ccib1c{u`lN1Z>P4EA96Xk~MfgLdX&+KCnZt%(LRXhLGg*CpPRe zgk;*UY}iQ~HUKS^r0)!bWW47TE0^sEjS$$lT2bcA^D`yv6R#DTmTiR!VE;yo6c@tQ z$#@sTg2>RNg;r=Fv_itZV~3uFv`g3lJLE@UCEi-#y$U&JxuSN6cVkHyCro5$ogLa> zhkjv)9=AhJ+M%cH&_+A-M?3V49pYkXiGyve4E@y(HP|6PsN~l|SKJQyz)2Hkhc?zauvqL3jeub`8cIZ<(#FkyAm}!Sr+M!?Aq0M$^pB?J7Lqkx5GMBk_sKE}sX@?32 zSn+1sp~j5^`psc!bmF|@igjN#j>=18dgg^3k^ip%eEqelAsyAr^5 z{1!5=f2<5W12gDCZ0b0mRoC-i{dO$dhxUL6;`!8F2KptW~Xg4$Y z{1T8_XnO{-2@pS+oq@aoNJS6GVM2yF<77h%8Zau5Ni_%%KRVeN$Yp@siAv8v$^mKZ z0lA5(u6D-ZohWyfI3Yg*q@dIZ`57P$!<~@d0P^H@PDnie7m<{^{wMSwKGN@gI}0rKQ@CxjOTJOg3O#F+sIhZ!;u z_6sV0;Dm4=i$7#Rt_sgv85Wcif>J0sce`A5CPY52;tZAv0qKa-aJzWEGUWS zH_p;bMuKBX1ENB>d;LAZ4DbilKt6rH^Bem%{Dbj9oGRFYV)5?$`HL9`<#my69P-)+ z!j(Vr&x*6Z55(vJnH5^Nc=6KSsW@iXGoJx0qWH6NKC=(x{2q{5_s+W)Q)#_YUEU)O zKbG}@+|&m$tq){jABffmvat_DY{u$Qiof-V^Y=cGFZw{vWM%fq=Yl?vtNK7j^nl!q zx2uE<1s-_d0oPUY=FbW(oqg{-*DP!PaL&>>v*g@f29}vDn-yBHa^BqjzGPsSyInYM zR_S#PNOc%8*r(%xt?Uox?+`K}B^OnvrFD(6G(;$aqU_990CmVnl9 zc;2k=;#rtz%j6~F&Eh=UtkPN6%o@%ZWts2cTP95*s8_{|c{^BKe6p{O~6|5n2>ky$oc|zVil~ZO+t*pN4nrl%%b~tEfK43vK^OR!mKWcjS{?7QG(3ZmyMUbuMaG6>(iSuoe4t{t=c zw&YsHxyFfO&f=vgsF}Y+TXq*zpa&f6mC`3u;&smad2{ZWW$F8ZMRVt^oM$4!*Sqe{ zNF#NEB5fz_`67(jocXgCEtN6P`B!>v*)`W)Tk@T2f_{IAfXLs{ zl9KDLyUy>w_WIK6z9Zmw=1x@D_TmzRT9@kq5%MZdZ-StT8SstZEo@jQBDmf{*zc;j z)9F#jFMWS2TqO-oucB`Z38`f~hi5@(El8`H*)v6j>&}X+;o&*|3h~l(hZ6#tT_qJ) zmwu-Q@UQ6q?nAtPJSf3%CPh4)7|z9wbv1d3C0+yzxK*ahqkpcn7Vp9#<*8!_f_s;r zffeCHTm>3VQ{Nu>0;hx9C!EXlSRlpSl!b|zUR(!%fLjamvt0RZCfFA_DvlGECwzz# zYjG@;SW<;^0kZ9r-dZrGFQTO#es38hQlRoYN|9EX~{5gw%0 z4a0h<{A|V8b=-{A9yug78Cg35tIU=B*x}~E<_~O6<3#~`im{cs1aASg&V}REvy(r< zX4~LS?x|S5KtGoDU?T-KDGkMUNbH;LB0IVPj0` zQRVQr@zlQx?ouc1QYU)@sgoC#9xgr{mj;L=Nd~#qCP7 zf-OBvUVJi9;XU>N7W3r;lpn-#G$>ZV^82t>kGsnY#6q&FJglA^HjpR0RCenu3-(yG z6mvt97gvLJUW7~HyNVle2t9&W&RDu#IsR>~dBuj5V52$-|4!u!Dz*8>|Al@Z7vf*1IKhz4By!t5+v-n?kV9}?Ej}dv8W@fj+=c?vlZXcBJIA^cB?y)vh@*THQABgH&SH)lP2!8b zm8>k?fmMiG88e-qSWh-55{#$3uC(gUGK2$Q1p7%hGA7-EMjrX$5iw-C$S~}8$pKkJ zUpzR&u6z+4vY5ZRiS!F0Ks-`he0>_bWpPo#(@~-#F%ZsPq_irp<91ZUmV|6(P#xP` z+>G0Lby4N#HfSGuWq|}G$}Vm+zSx7OkdnC>rb1M3PD1HXO<5y7l-JXqy``t*HmVJx1-`efu7j5WZm8Hv?fwWfuljyK~|x8z3jDA<}FNjh~WUD1VzBB0PLuvCf)0wP~*_EX0+ zTG>HlYDr9XFRn)afV}%r!0^9Pz~Q|VFx;;KPDJj!am0%y^4*q#a<_fAaW;O;9TRq; z)EFz$WFWLqSd2o2%%!Eq!;AmYgv8LA$U7~p_|BSwA}Rizwr_7@r3Le%9>Gaz&;k zGzyRYtPmltVHXuwD9ZKhU-8M(_JR?zu`R@vL*|m}%Oy2ENo~YOGgF)>3F*LRk)0(A zh3SOYQO4$CSfZ9v8x(qlh(%}}tJE0x?1RV(T(U#skZA{W(O#Hs0ZM^L)l|e<){!u4 zJWDB&9ehO{*H+wyz317upHk*lq(2=e!J;8a2s?ww0~1*-!atOjN4rs>@o}^KWRq?; zHgYpqA`59AwNocbcf-gv7=L%-zo-ZP$QYZvRjC!*Q&EVFoUP$b4T?5G=3Arh4BX_){ACjr#^_}Ich{;9AaS{Vr?I5 z(Rx_m^gm7WD^IKtzQWLs+KW&%e%XE{Dpp?V!r;_M{zxrKl1hP%^FOP>W5~2BeV)23E$eG31ryk6PcQ7%f;4=XaiLQ zBc4>L$P7^gt!XG+iESMf_hT>9Dl!W+v}k?sBcVlunIzSgqqQr&vkm{=%9i_0T-HI# zQ?yTqz~_U1nk$dGzYQBS1?|`hGTN=|C+XW)4$zv0e4nRD`blXuDK+J>*A9j$$P62O zPm|gAMQ*}TGfxcpKaG#Rk4b)Vyp$e!vZ}<-TDJJfh|MAo9(2HSq`k@ce(ujf0{Q^gXs0|Y&fm3<$Q5MPD&}swUpNu>lv`cPbJuveWC1-!Nf~4Q&=J!*v1vLgD8SO7`U@nv z7c&~7BZ<%FNWzn43n*}BQW(!p{Xaz&P`%qM80Q-^rnmBugb3`uK7x|Xy zZz8|dpBA9diN^!Zj3WsaW78N1q-Vj9`-Jnjm&t$FzNj2f*5!%S^wy`Uu0 z!}uStDJU#CHpRi>LZo4(EARJ(pZeE%n-*GhOq?es-42qMBr3z)i_Mu+ZB=098ETA! zKiYOB8HNK=8K(Uqr5IVUHLzdUzP8KYkx^rhFxA)7du05H@%2;9;Dq@4g=ks{9Uou+FoV(OQPA?N@G9=YXE&o+`#xeTLLTJ4 zaqTt$R)oct(`LEjRM!dsgXu1Z8!`l%RtO&PEM`AoWiS8;@_?J+coyJUf+ugV3*#x> z6|L!Z(aRA1H(}g?Oyc%ppR2&R{9$XWdUHA{znQmsa+{k3xarBdM2`>E*27-$eVd~i z`OXf@CD6@&EcTb};IAO3Lc;I2bS?=8U;>=zMo7z0N19CQF`x3YFT4%*ZxC!I}I zBn^TuR+^8ng%xQn+IvSc`!6Pf=Q5EG0&nlg`t}#6Pn$OF*k`HZ7ZvY>JmK1?F~AL# zDoK{#qH~a>NNIs4TnT(WkmAx_k;mqkO@IZaMp$g5G+h~=hLbL)2Cj-v!|>YFz}4|- z-NBQQ7trf*;V4to{18Mpg@8_;FA)t)1p)-6JXo7}!*kG4kl=9_KLaUd ziqah+y?PM&ae}Nh2{S(?DtsF&BGovOA^HsL6k}bCEUZ|@znlK;9|a0tKd%GgNL&zp zxpX(~R3_qdlIaIJ(q|&3A9qk-+{kRDlouI3nr9^3=OB;ouR7jE&1B?{{s-^(WOF(c z7E1eY0NUzEi8eu;;3inT51Vaqj&7D1hvR9~bP@yGkg0%(rj=-%65hwZfsrVa7BKn_ zQf|zOT(05V!YasuK(Y)-mCB4a>o3ILYAi$gy8gF!BM zH8na{|3PtaG?>WSw2iG>z{qZ%)Cbo}xU}j`tx4@&s34^V1o;GZVP+g1A%j;9lRhWI z&5n~p-`N}Ge&;>gXtU#R1+pI%*ERwt0cXaw- zR~`^z#i_}}p@f?PAmhZfr-4h7B&o>|0`f?Rv9zDsk^PBsA(H*F7 z$muYx%OB>&i9$|a#o5BFVkeKSfhMSx740cR>suZ6U@BJyzAX=xM?OQ<>Q+!*fd98MLNUDwEA|!2DLdjYo>~f{t5$ci>2*fC3V;e` zdo^PV1lKA@aU4D3m#Wq6C@If`geQW-uaG&?N@}i=k*~Lr4ARy@WM4}Yl2`&a+7#NZIr=VPrd4qC<^)q; z!8S}9BSg+eT+7XsHmNTz<92fxtsk>w_dgx>xf5AR`>bT_^B&j%64z7io%Z?9h|yQ% z8N;&Af>wvQL4I79*Fy;)@YRP+`)qS{<)a(D;o(k>(!uM+&PpfScoR6?aAB`xOp|GL zyWhupUwIn)0RIf@Z0MiyA#KAX^e1SUPl0^64O}j&b^Fvcw}S|$G(3lQ&^}W?zD3X{ z-6aTEQQKm$hOC`x{0I+H%6h+}rArgSy4Xpok^O=K@cXq^)c-l9FgjS8_w31i1Bm zWIH~&(BDU}gf^h<9z!^#B|uvw(Pm~qECTjIU)8z|B6qbe8u$++RO=oN{Dyg9@HNwg ziw6D^FdWnY--Tn4$@Qj_BBiDZLm*QFLj`xxh?Jby5gG^i)wKb>qb1uc zOyb+M2bHkrsb@5KzifCw=)Z70m7Xfyoif}T-Cz7yI8Ut~6w(K8L1Oqs^mV+0;@-im z01}F<{U-14!Gw1{7%g~iR>A;*#T(G~q3tPY`|O|af>s4eAO{bjQkj?xmBP#JVt-6f zqa2*(M-vfopcF0>$Cbn(1_(Kdm!T>uYFsDswlEP(I{}^InUEco4-`aJZsF91al9V` zP1;(-oC#uJW`f+~pQUIF3xXYHaLY7gY%%^RWXeo*k%@>ZGBF-RX-p=3g-lQyuQ|aY z1f`ckzw;@w(Vio=RmeJLRR{epMPIH-2Eu#?~R9Wcg z`7kG2)__ySYK$?NS@&;(dzt4b(dE)j!4bC%~nb3ZLYJ(n~ zkLfoxdJsr8+&qklQ1L;HHUMHaDIX#xPw>+T+RDL&WJF;X^g{qfh$%94E!z_zv5raq zKJWY520+|6U3Dv>H+!$f#hbM^y27~_pKefU%UqGpWVMo@2Lx|r{ zHTpFopuRAOxz{@1Kor}6Hz^P#8s$WBBi;~m==q#jmDrFML zg)CB@Eddr1?NFuk#bSI2ycH#T6K0!=;_TyUP358`Cj4<0$dm^w&67xD$LUX#optDN zi@?E_@b`5g0=lSoBL^xg*Bb!Wiw<1I3e#!%)Cm*~CP@{_%~L!q+Kh3CZxPttCJRNY zVMn-(5n%RZy=0+I%<4FSCu`wrJjwi%c$z%NQMstM;{corwyoM`tOdE`iVH$)XZ)H8 zbb6seUsiuQ3sJnD9HCdWp_P zA{Y-*XMVGIPM39c6LDq6|HOgT^q+WIoIG*UE&O?6#}SUt;_P8u9fuLN-^0W5+jhyS zYRgWU@8-afF%+q#{FtSgp0ZSuW=PfusOWMqWQ^BB+X9wv+Th}cjPZtyp@R8TQ;nCR-CDsIJRI|aZnxd z1`UVDk90kK?0s#Ye<<68`yoB16IkvEPud8}k1-vLIr-rg(GR9foGIiW1oJqQKbP?* zz@JMjV`_QG6guNl!16cMKwrV}F|=MaWGFsEsk;j(nS znZC4v3mQc30vB(Wz9jt^_3}oiXi@$MbQ&v5USO{f6&9+3j}3upKE?{6Vb@*zFiY!n zhc6e72$uIehE4{v5>1D>+y^?1M8XWg?o}a-dBQW{iZIww;j6%jx`KIYXovJ&yRbGg zljAt#DEkzmJ8l^hE60&8q*<{WUdQ*67_3bWtHku#g&@I)7%pv_TU4D%i3N7T$h-^5 z--}ERR-VG~=P&8)ZU6ngl%aB3AgfiCRD&QeUOIC|ktGin6E;A@O_FW-buhtZwMmt| z9$3uxmLxb_im@Y8HLpbZpqjX@0O~l_R~xw%o?UfL_=eU(wtc4Sf`!%?4$O4Lpq`n2m>g&|u0~bZ>@^Dr z#WKgE{|EfdQTpX?Bh1PFfWQBaXhh%BaT3+go4-pkIsRYrH|yODfBodIHDoG=O2q)7 zSPpTCIYw$)S@Kp4`eR(R0EWSr`f!L`<8ztPWiy`rV|K6Qn!|s=U)jFM`QL?sFuc)~ zrVu~ik?uZc_;3eBe#e*`FV?Tbeu(#kSS5!;wz>Y`b4dG$^|JFUTt9QI3Yag18uBI= zrdaR$+OiHvH5~{XN$+>{W6f}IzUue&R`e~;d+m{_BF(=eJIbBoScVBsKyF? zn`W+~$22c5sDVsb91vZOay80v2&_ymDQ!TV%<~&EfCJ6_mOV2%{Z+ ze9PXH!l)1(BWk`?eJa?yqw?PfzdkNgm9ER%&qH5!BP5kBAugnyi^zirILJL+j7>WF&~ zs-Z6BwkIR!^~*r9UuFaeg^Ym&j$T#a$pM@SJmtc1L=5+?fpuoNwt?OrZM!vJDfM+? z;`YFuAY{I&tJi>dcFo!UfPl@#oihW0Yi>tH4qEEJl3!RU7BJ07+wY)$L_mgsR8d~7 zX`*cIpB6p)2Ng~MLoHn+wo29hB_sFt+Iqk5Yp%jRoVLr}7WVCF99+%u1YBFN<~K-A zoJq-NfiwNnbrwm5APJ-}24$lMNmiWpckDP0`zy)rS8kpDrlT(lIekTqit>oU>Y{|k zMG&`j$%$}CFaQU|=5`WmMIBy?K${<8$x@WyA!!7+i{QwN0Jr_Y=H=HWYk2X1UyMyh zE(NsY(l`>0^x-EwfyLwXu@=+C$Sr}tbOP@)Mbg>rwRrI9e#mSMBJ?H@gYi8G15vry z6XS=n7KJY*j+dM`&MWD7%5g_VV)`LV+wQ{(BYH{MxRc4@{(QZ!KT#FUv+(Dgaa$4B zlp%+F$fg`~Whf5MyXfQp^oG&@c~i*mzfpk)v3)+%hJX)pIZbe>N!4lFCeB7*oYvFz)qCW zY@ip52AWOSh^M6%b8g<2YpX%F94A-QZIp!U3S6q6{^kem+I%0kp@rU@^g&0&qwSec8eT*K>i@ zd6XrQ@{ttfiIotKL$}%P$aT_Y+atwlc++i`yx>;EyZI#Ew6PVbD9VIwxl%KrdiG5kOVl$+ieha;Ttoo(}X3F)tn zea0I*e~Lt?e>J)qfzlo6oZ3}b_!G|2_a|@VtyAsV@kuM@Cr5d))j%V*%^bRBU0Nut zsucdTAdJ;HE)4QwoCg(kX_6!B^500Ph^Y(Gjj@O(gpWt>5jDlmy)mn}?V5mBJ z9Y{#WEL!KnLfAEH(k`~mSP?1_!EifDca51s2#l42x1c5j$;vj|1Xj>o=_c!j;GS*i zPS9#eeJN+-SSZRPElMGxSVP9W^=+6LPa0#A&zsjak4LGEmz<{Gl7fyN>wj*CZ?OdO zw=%J&hy2|Jj+*vId{Cpe0%DFWoQupUe>*6WzhX5cf2?q!GS8A3@seqOSbY?^+aVuT zXS(-$d)p_tVTAJoGC5M;1(lDd|Yn#t-c+}8J# z-ysOQ?Q!FJ^CEckFRTD@xO_+^^&rRw8SPVacd{DSOH>602VVn!{eo{3vHWihPjmzt zUWIfyg8KG!4&v8h8DcmaK4I{c6<=VIBKR6z19i=pGH2Xi6m3UPe}*@&go#xi41my2Z#|o)G~d|A>i0>TNs81 zlzsS6g%5tnO%be889tVq)m{O?<~$$8gFa?8!j>q6FL;4skj@qKy&&{yVx}@I2h<#o zk`+mP9UGR_87qbS2rFn-A5?am8r=%ix~O$sRJHJ(L+e`B*!sA})<;L(r=Nd8%yeJvg{?nu`rd{k9&`y$%piI)+Hizx1HZ2HF$gWB$V6n|btX?~4*xGLFtfSwbtKL^!&0iKlBIeb~Q+CT=jk zCA5uv$Awp{Q^b_5s(`Zg6WZhWE_ZOMYuIa*c{XcL0glB0f5by>DqR1h87zpe{|^z2 zYdk{<{sgx7VvuzGf8s5!J%e9d>x|zP8x5SKQLl1zTjU`r>0U2LMK7J{UIwwyh95a; z&Uexr>&|2sIm28quSTaMt!D3+3AU(fMxeeZaJYgI#XSVmKyE$^A-0O2egX_xh(6A` z@Cr<`gcoF@Z$)&@yu>&WWh40^ML*-J2%pdJ}ZD*b|Q{SCiw#o}!C1xq)bKs%=QJ z=D(OK-`r;8g+$xi*M7q)G8Ya=e{UFYV%#b|i^}p0SD>hM>u7S+y8T)+8d10~`H5#Z zZXTZ)7#yF9UP*Kvijr7Y1{hXhovWS5*7vJxw&68pc+^d=W9mHS0*B}X@@y&n9d*-Q z{Vna2Y&14lBD)4uAd$L;^XvKtxVTu|bP9J3d9dtv3wvlC6%Q(E-T%kko5x2{r2peR zlOYTw(xZ+TH0r2P!x}Nss6?U;oqn5D^9@foaEqsCccevb(y= zuDYONP*F*^g4Y_rb5X==WrzoghC?L3_ft=IO;2XB$LIC=eE;}0O#11ko_gx3r=F^= zuC9I_6$PGx5XFsiLAL8N-wP!;E84r>8`*w{!!=ZBC-Uz>J(6+15f%VA->4>DOo^|; zPSN%q>NuzG+57u-1o|3#Y`5Wg3ihe9_B<6VT7a8sivLrqXBDl=4a5gqbeElb51zJ* z5N=W2yy>xQAcCmU6FAxct7)KdyomNxcHo86g}B)Dng6rCaOZJ9)l+=Rp0!g1cRX|u zJ9t_TVXTG)VUS9Mo-kAw(R$nj!2X{to+Lz``q@e!*|b{dAsX+4cI>xw1Z_>OL{Lvb zMNte=@?o*bxZ$5e_M^2O+Hp?8IsN;!1^VY4SC`V4QiG41AcH=(HB|_(}((KKYv?aG-UWPT(3pY$T?tw67-JHop@%Xv>NeD6hicGfYU`ziJ^ zy;Ad2q|3<=fIf3?JW~Lwy6iy!+P;2==_8}N2;R}}!!CqAY+8hi)p)y2^F-gL0Jc%; z2l&8#?=fu$29sp}R$H*(n7`fT58Jen$GqR=2uo9!zKFqO@E%LMWoyn4b9Rv@73}f} zIK>3*fcN|GLrAA3ikv+GY|JXK1V&;hs*y8&Z21JEd}Fw&|neG+LFRBP}a%vJe$h(e%J_3&3z9;B9!L987B z8FAbb_97RypY6i5=@+fNQ-unW2OqcmVmX>~P#w8PbmtNb=!o}*6fxb%IX?HpFvZ^^ z`;8uC)&bBfj);jdpJ*i}7`Q8F8$_b(Uxyp z-a=cx72B3?A)WX?V&bpwXBrEOt)!=%!LS?{aT#q(IzxvsK-2_J4d#Yu(0#)VwZqWH)i$79dk{V0!hBQWD-! zCxKg8ZeJ2s8>TL$dy4VNSUZqq+DP1!c=Ib0y+cGU}OvfrMHnmBt4eLjQy_uG6Ugc#?#dAFQgXEkkzw zqJ^olh&Yb=UYCVURAE%qDF&98uDJ$7Wt;ZxE^OXOI{S64ZP!2hkyoLVoOT2h9|LC` zABLQnKsXTfF(1XD;!X?JIGx^Cfh`LT%)!#T=M2hX!OAC+(=0jk?s5su{lXNQwHb-2 z{@Sz*Qn0J@Bk^!T>VUS=wX-lkT7yL^J$B@~$RKoskb=>=Nr>nsG@>t?z=?FiK_NJaK zJpM)LXE&<9BOG1(9i5TNtBt!MTF7=E%%9dRTp`;l1hRS9;Jb!YfN?^ofKo^WG=nfy z5WoIvbp0vgODa4V{V$kD@AZe682@|Je}rWtl@4zPcu*MBN_9jBOQ(hwbrXr$AgHIK zTB6sZ=HU}jZKB;s&36b7g2Fmr8;5XX6Se_8kRn8mF!>S*jY!x?orowB#I{9I8YvNG zBWeAu2|7hM1gY`WYj^<8;#<-15bzNT2jMh8G{3~~nnnW!Y&?bPhen0TyZlEI=AIi| z{U$i${qC9Q{Hf>^w9eoRHa2eunqCNX?-j3w)Rxust?P@lmfY^6Jan}C=>33OK;&7s z4v>Fq-?m>8{J&UU@gaj+@Rk<%07;#XiTNVQ!`_~Pjl$0peS3i|CYewq#z-d~CxmB{ z7r+Ub8-+6^lamcb7#>a#8X9E;pUlNy-qVIhpTE2ea}$m#&L+XI3S!3@Rg=#o^wEvj z#GrdB_)>T(z}yV0_m+2Q*?y}UNW_pwbIkwBQvsDmCIMy2()bZiJW^(8Gwjj7ATB`cRi%ucxQ*V~M&f-;_8M@Kq(l^GC5JhLcP} zO;~e660NE2!0;ACIB4u6BquS(u6VU^4~TR4eZi7vDI;#WnCt4h&?8>2A~;@Kf{i5) z7KKDPn0ZRHGnKdo%+T!QAB&yLNH=AqGet9IsKPCbsnPEeS;Uk2M$pm1Al=V&R&+_P zcuh{Y;;#BrE%fCQNG@TTHf*EP#hY)9-yQTr-xc<%d)Rrd85FuikQL1wE%8br;f2CA zOhoX|oeEVoB7W0w8WWxifEhkuwZm_fy{RkW!pqw~7$j51>swm)wY^KZb&(^LZ6xnZ zdhfxTl3R(glPNptnLX<5gJ?U0#Y)ii_QDKm}8i=2OfW95|Knai+Wts zsA!0$JG7yuQSi1eC5U+poO#(jCoSIK1CGqlQ|KoTF3sR&CpzLuXX3FB6Fay`i0EOp z-MbY_j-;Xp2MzveHekJk6clkUW_B#*BZfG@ld8S16$61Nl_p+M>)X8E=1&1DJlzfR z(_*kDF4ZM3frD>@c*<29dHu{GiX>_}u;d){yC_FV8act^dg!)`jf?c$9;!n~;M~Ny z^VF8@K|h``(aB$=&$HB)yGP*^%I^yYVp%&69qP(kU`0rHzmsU1-U5HMsi1=lgzr84kDYTyNKk86dtO4*6#a<9?h;uZ^p5V`0UsA=^n%d-#5uNz=X#-Kx1U(bl>pKS$Od z&I1*06HVlwz$gb#WWUEHnqpCY*3R5Sb>*gz^Ia_4DB%ZyZ}xv@)ed8S$+A*G<=W^* zl4t`oSa>ucTl=B{;pb_3H3$AYUdjXozC1w^u3sYhFuB4riVOsGF`e`a;#^?sC z&nP?#gcWOkk8D4*NH`!oLBPkx^}& zLKV%u4|P^vB8L~+;Y0h|y3ZPXG&}++^3EWJPa+b-8~T{hSDRhl28y>lzrh1v(=(N< zA(spps_0jUI$Tj(K7A%Uwj)GAeYuNVVb@nRG*nfJklKnVo;HPj_Rb>z%}9h(>Z)l7 zs%?(qtc*j9<#HF%8Nosf7<}vNy>%4#dg^Vi;S=*ljRK0Ce>Wh&whUNZQRAI8!zBVO z>x}Da;Q`u6S7uIc5Oo<u*!0mRGuFRNXdr zc73IQ4K0e`;Z>fR*_Dc?9;z;f0tB;$8pNSSV~s;xZ}M>seY&{v73CE*RS4r;?`kL> zTcW_lHo0;~<>-=WlnBTHxKVm-)vRfr8gmNCT#Go+W?X&Mt={QqUWC*}g}fCtMg@%e z&YkY5(W8tT{;Q3o>EsXFXbD$cIRyovu<8|vIPFoqv*2-iHe7pCaB7sofzw4x8Vp2S z3gf~Hm-IqabEj9LNUCGGM?u``i{ObJVXo&?xkQSfsi~Sit;Q3Vh?9^pt{x$71EObh zFmb)E6i%F+uIsu)%&+(~*!9}qhH@wj_E?Twv*38VvKGxC z3~HFGuC}VYp-KdjmoeaHR8`f%x4#e_e$N3lpe8b7Jz4;c-etAX&a-fdpyM#9Y11oQ z>^GjG!<&*CD7HAVRd{Q;`I#z;hMU{SF3m|)RfZtoxaF?Osydi74JuW$W_zdAxTeo6 zpH{`=QbF9&s>CpB6Qwc%Qd69I*@;ESb20!=hzIdHAov_m=pX%|gLnzF=?~#aF5;(j zE8Qdu@lf!_k;*snQJGX8(NH;5hM)oOczlf_{+o#JE@Yy$71HMw_)!#5J=$-B5#rYc zv>U&C{L=9=(Nr2V*+5s~M`LUmesQCbS||62hs)8f=~3$){GRSDAI0nbeQdPYp`iZ& zzeX6qN4@7ww|2zlEdo7Fs48JZL&$(oZ#_bK9z{qm7*J=OipHp8(A53B_0uechff+H(dstgz{9 z&^n=Hidfc*PU{j@#Iv2kq#9)LAbaqP}*jUV>ix-?E5MJaKj)T8V;ShoF-Aj3Lznj^jGIS*rpb$A>O`BbO4d`U0a zSY}^$x}v!LOTE-0ZyoZ!lZvqw=eV|mw(oBZ#wi^!ub+&AMzH$$t*`fglw&(rQ7%T` ziCbRYfZ~LG@ocp>jVlV(V<=usWS_4n6k9JY-@*Z{R%>k>ff3DqNgVX>xJE4QBh+VB zqr7$Ks2RPLhkC>S=*Xj*dAy{7dNRb{3*PH4`rqgM6nN+2i%{pqwEv

?CkOZZ1T+bT%9DULphlB^i6W0YEuM}-b+3XZ}ob!Me4tO;^`Pd z$J5)$Brz{IOnfnz&Fx(m#nz5El`crKmc&69!QN?MC@!b$P+=OtmNS30Qt5&Sk$q51LT{xlsEvVBdwk#-I43%&4mTMx&n zoSr`;8DsZIjQhRkFH0C2PqyJnMJTcs`F|XXbxgo<%b(xB$8*4lq~SeLkcIm73*gmw zE#&DB~j@EeT)(~im5tU zK;r>%>TEz`1nzb~XbR*#3o|4r5)k>l;~bkLt_u+7-H29as2vcOQHr}OOK=+?&f5Wq z=?(zm(vAV*(o%6BW4dfW<3zbr0gV^XdO*bj>X3BwXwNxv0deXLfVhmQfY4Nsz6lT- z0?<_$=eR~MO6UL}s2QoY{yZ~qDlR~b%a*vQfJO_td4RZ#cK|Wn>F7a>I}Z?-I~fqC z*2~ldfVjR}CGIUi*9*?8VY{4T8=xBm?w=C+0T7pQ6cFb~g_STa4G`ld0b(xC0GcGY zyatFyO{a1to)b972td?hoXTj4n*fNpECIw^j!5VPtV}SM!GJh5N8;v6+^c}NjO~C} z8^>hoS$LY@)WLwp3JD$s#Qcs*Xv~QQt`rcL``Af}a-+y`6cBTpJY zP2$dxxIanUIzTMndlI)>;u4$&KRY0%yB^R)A;EM&B?4Ll=q3UE6A(-AEg;U3e2Rf{ z0%F`)i7Sz~8i{L?PzVs$<35S|oy7e?Li=UvF$vl5gu;1;17fL00b&WNC2oeqX@IzH zzXQZ|3j?}Y)a?kMDFRBw^9%E%NcUVulf;DpaTzZGVt%g!Vt%wc_}79<9w6pY1c-A? zlek)mdtBn40yJ6V4NKhjfH?2Th^)>0QUEb-C?J+#EFfJ1JfUzsG5~RoY(ShNU*g6} z+#P^!5#=@m;=I3;bWZ?csXmpsFd*iam}-=f1c-5i0kKq90b;2d08J5P+zyDP@&n== ze+E=4Qr82TBA_jRnC?wLEWzn#7`TyunC@mk%;g?HT<)I$>Fo=Mxg?)yKqms?9GQSP zhZ~SCsid1H>4Fk>|5?1A=Tu$;R4yd_yGv1~3MlJrql~L1R0xQr{|%sGK{p@JcmXYv zbn7Lw5fG0XKLV-{bmyIed$WKp1H^eJ0^*VXPC%@UzW^Emx zfVk$z0ab}Io=?NdzJRs@Vwv{>V$S;jvHlKA94%T+6FIU0aSk^imb4NO=dG1=w@KV$ ziCZagk4W6}688!qE_cBB2ET!TxZHCk?m|GU@s$$y2q4be35eVLXFy!@b1yLXr2}HR z(GoXa;_d*%dG7|qd5=ik3F!u|3=r411`zYR2T+aB&|@<7&wyA`=U^j8Dj?2rjl|_k zT!qBdNL(WzmTDy+mg)yU(?w|;er0gp42U^*NZbd2^uBeWL3b`7rmK@Uuf#nKh)Zh& z#HCp?6y-Ofv~vM*&C>xfmthi@2Z&3%PvU+n>0Xq$Hi`R6;=Y!+q>Bs*&H}^|gaFMD z68shrOYjFkT-r|(cN7pyHE4)IcQzo#jg+{t5;p@7*LM*hF6|pYwW746fVed4#YSnf z0qHpaagJLvjlQ)95ciM$fH-fzECX@_;?xpA+d~`MoP9( zqp^Ty38|IqB<@a$`yLSM;J8dp8fI`g z84yd_3}~W|c@-d*^suBmmTPe7bCr?zLgi0g3|AeQ-FN%x9`wgTcDsaG5P z(g3k`hf16q5YsJ?xJE!M^V5JDgv`4DacRr0F`(B0v95LkVlG#>4cs+=7&ikD=gl3? z?-iZOwScMw=b3<5FLwZ9y)2ihf0L=N%GBL}xZKYHag919?jRtq;7mkJXUBpwWW!DIn(@={PZ$Oh8OG zRN~x#bd5_~vBXW8fOk`Z-vU6)#V?^hNoc)qCEN$4X9(Z*iRQ7IwX|H-&x63Vq2IFE!Ll+Zc}(V7?iey`Jf{Ln?rh#~>ZDC@uxgLgF4U8pVyDpb-?*2kW9R#Iz#{b0@BR z;26pEJTPTw>j-8$FwJP+20VBAp{A24N6nB~A^LaUKnPY@0IUj&SaS$~Xp^G4v+hb*dRdZdcZ(m@%|tW9{i?%qU@aF z^L#UgHs-EPH)F^x-QHiBF^>XMoMFbSpT)y221{8r)QmX=7#HS35k3@vr5SUM2E-WuWj2r%^aKSD!e)q$~Qnytj=S~KQDV9KsDW4;51mNg=rZD2{?K}0yG0HjYM zBA6inM?_)rfT2$yA~ZJv^x^Il;XDf%`YIqovjiZ0Ai$U*wD(eIfO0__mTPe5d6z(W z3=!K(`4Wv3cib2hA_z_zBr81&xpZX z5QQnl2FZ##njO$#>VlWLcn5G!a${5TOF_`CKFs(6|zsF!cioxuU!5ogkBx0_? zhf#ND3}$c)CMOD0ijNJjCA|lqkx?|1I4K6x5Q7OuVaN^}s*F*=knoWx8sfYm2Gbse z*@Y|a^J(+v&sT<2)s$A#mUg8SbCXiqAYO`D3wAe`V%KwNgLi8D1aDn@eEFPd@e}IG z@jXCk7VSYUt(!its`g)z&GgoKruQV(yLhSiaD#K}s3G{IqQQfW>vcmed|%rCq^k)2ckBUTp3zy)>&Q;*tnL5SXq-j;za> zK&TmCl$fr>X7th;=)bC-(If*AMy^<*$Te>#7Y)Z-*h|F+B4z|Wo+#i921UWR{3yh< z;dq=kXK5HQsw4_gQ8eM&C`7}Akt3oI)ARC*qY&a74l`5wA|;A~K0b*;&<83}h`OR1 z8=?@i3k#zWb$P?bMo~2MM0iGB8(n=*!DLTVmiZ+;5Yu}i^v?x27d}#{n87wxI!ksN z7~9n8v#O}eD5aIt8}RkcZKX5I8)gi-^s<~wVFlEe$5W zxSdr{)+@~R66uyKiZG&4`NK;}#T{H^*849RZYd?1DA{;eMC$61axTxhJd+6puEA4Y z?-_FG?4r(q67tiY=Qs^iqOm6e%*!vo+~vy3x%AQ;fiLSn*1{8^-@1843(p`H^YaJI zDLT$0EWYl*vmqVd;OA0`%goOpA|cKnx02aveh!I4B2Ye}Gd+tCvJ9fVbAEIVw^HW5 zI6E5W#AP;~cFhOMbzhvN3#=#57Z^pLI}PHtse@Fv60KjoS{*rGq=iBtr zbf_?0P5)4JZo^lu$@I9V4kXu2^yRxcn0(|7h9iT0z{BGN0zdl4)l(QF={SPrk)E4L z-h9Yg3>PaUEN{LpFVryECb=#}FCC+92;(p;bytk!dM22JS=BVM(=VDZ-uzhJ!2kd?Bb35p$exp^_MA|b2CLmf_HfwRDS&Jgg>IV1$<(!g6HnNvNvJsL4ShA4=43do;W>8qeRKSo( zwnC)sTzV@^k!g|EOV`sPEu`~-6&Wqdabrnc5uQfNX2#*^)_HP(56TzeS!8PUXpY4_ zY%d~Xipln1DFYU7A?*rdL4QNA+;zCb(DxPEw+tPZJT!}zr3R`M{k;z8Oc+iLjDh;Q z2iMf0=i%(ac>&H-w8k_aIKiA~s31!r#xM+AaVzVFKxo4d2sRsnS-2LYDKuV@ODGq{ zD;j3fQH3P`7AHmv;rRvw?e|n1jW8y62oN+4E}~q5GE9tgPal#WS}2`rIumK6apDgS zqCrqbU%d?Q|LMQsZ+J>wfPrfYJYRd@t`n{>F2pUAoQ$7~v${Ud35T}TaIL8>O9g_& zAQ5q9Cr~u}cNExm9@+v}$8N!RmIWKS(m$)%EX_*Roduhl(6Ie-F)asP|&1 z&e^Bl+h&J5%xZskfAxX3Msh^j_#()(wtnBk*@N2j6kY7df_uFLIQBz&8{Au_+pdO# zKXtHesK4EjQwzVQU+28;nX0bO9apX87KLuJJ zUKY8u;qv^*WglFgN|*k&M8pRIgN3Mo6P%qz{xNpA^~ewg3eVhd&$x;hce1phDHK6y-T_#UD)ZSz_6x<^ltuYk7h+sbyPo3>&x95Az0dmQQRPvpM2wI&4gS1K;E%m! z2Tt(CMgCUl-VDGEAQ{t(T%0+WnA$RN5F#IXCUtGHdb79Xond*AM$#A1po;%9o2O4; z%o*DDu8Nf0zJa_m=bU4BMBJw3C9~+rlkg&~aK1omyPb$>)~c@A#y&(kKO~NVStmRZ z!6zoFZ^sQ`F#6wlG|yRFWT&-dt(kfs5Du-G?wo*}f##P19o#JE3vAE1(A*Sgkj95% zsH+6DlhMbhS5~5*r6H{rrb)N^v1v}aXCS3U`vhs^MW>E*pf+BCYQiyYK$j%xl4U4KkY(w#c8-eG09M==!|~&t%E!}~16>}bN@g$@@(UUnht$T8kVcN~k1yJZ!ZIigXNOTJ>gYs$7Sn`* zeaHZlfmBq_4lo&Kn-CA4B8Bg@6sW`%X!-&f;9m2-cW?$KEztBOLFkCueROX!3JA@! z0O=4O*z}5`yrz#p!lMNWNeyK@PmK&BI~T1NNg2sEn4VE<2PD;wSJr64-)BvACkQF|FU zv!^g)Jg>!gjyXAWMPvHdrf=Yzuo$Xvs*Ut`L}U9g5>tewhM5u$F0HevDBYR9=pQL+ zqYF6S)fcg&d@{TUf!av#X{bwdl01`1KNPvs82x`0|Eju&og>RnRjSC~_|mK7% zEoO6ffjv$uar*Gv-TPI)6J>l7R{de*!)(My>F_NHSB^BLOGXj&xj*@HbVC8Sw4a1a zS#v#$K_=5#1(-h2qk!&a@R2khvXT+hQDJwbHPR(Ux^gZ%fJ?(P91u(UDR@0xP})LE zx{n_}erV^}9p}N*h0hZfo)rJ$12;8)Q|NlDn!jIZ^?#f&_$RgTFW`mF>w*D13Q&vy z(zFl(hj2d!Pxfz)VY^>zYYRJcwr!y?VEZB1?oJr|Gl%H|TQ}I=LM%*^kET|&aWrsx zg=jv|(wIh-2`nb-(p6+0i;TKs>?E6Dqa~e&8Z0y*NmJtnp%jVI)rPFX;^y?UI21>E zrLn~ zkM&?&4j5NG@u0hw$!3MY{SR#RN@kl0wigrI9yWVAaJYYZgu$X3y0wxbOt(##yqQ*q%%oE2vrwH>D^G(t=8AY^VGJ)=STck(Xu9o#IRccJ|> zH01x<^Yeee5271lLrk$WNnYjSKbS{(KBec4V%SUxY-KW}p3>BX3YWopDm}kOjPD!a zQS|zzofscI<1ltLC8EvX!Ez8LG&D2jn3%Y~hw{YggNC5mC2716BgP65WSdO^+|$4t z3%}kZ@H6I_)&4Q{DVSd&UxsKq@IW9fn)c(ztk4$e$eJN0c4=zkDrlUZ5A<15q)5}K z$3P_z{t)Kk#b9}v7STr(oFUu zs;pNL&mkf(2kM9PlC_i$1^1YAr%@hc7o`#1N1*F`Pk%7z(LQ)uM%$FoQ{1mWMpM>v za29Qa8x(Dm13Z~-Ed2?7z=wJSm(l%ua0db=Pf=G`2)`@tQH|xa zv=dxP)d>ELND%H|qz(4|Zcv3WxUfV47v}1+3Xnk_Av3g03|w?8uchoGF)8QAOcP0Z zaAXRhDR`y{oiXE^)Zj?F#zw{!>YKnsoaMUgAWRcElk*0j65z==YY_JR~T8MISFROeEoZ_=4$X z;R2rbd+;wb@khmkgxnX`iMLl!=@hsp?p|csvG_=WWj^BZ81*Rapte4M^Wqhv$=p;cc-jx$X!n19m_pQa2AlP6jO8$T zi$gbL7YP7ZUpTb`Oascck3u0}IPBvmU)Ye=Rz{W7Z=IbdG@B0!gDVz9U}p|k{Y2c9 z#^Z)GrpxWMV!ZJpBGpY+f2YOwbJE}} zkIAGntwGw&Q!3qTFV=V z1y6_m6z!t9PO8~{d`GR`b>L|QPb`t%V9V*aV;D)giqxS?+DRd&hKies7#(?J4Br5| zLv&Pa#z4$7w}#(QS8 z)nv5U6!btl!e!W+x)d00Yr1ms5CD*7_84ZV z$%ays$#l-ZHpV;_hlG;peol$MBTgZkFO=$U4km8HwrDg?OQ8cHr(G~Amw#`P_sp&l zULS6Gpd@`&Qr&g0;D>gcy&VC{K0LcEr_K9AAkTqD!*G<|o@Xbq+VeyY_6z9|u*~V- z=0ub+?|nu+^*T_+gjjk#(9jdm(4xMvEsQdR?0LzZPk;f*M8Q6yn5ZoyJdj;&x&^Hq zF2JAaW~P;Qs};y23k^?YYnZIJaLFmmF>2z~qdj@P4$;w)w5pztmUN@#a+`L~8#?S! zYOy;qp~MUb;<+Svzfg7Z!=dCmwM~cqarUO14$lBuPtvb8L4m^^{>b|>y>3rQIl(HF z{4g^@JQxu_#=rN7zts+&otvN(8$=j@BJKXYeY7R?#I-rAb+bNf80({m42YhW4~dH) z`B>NuEqP-VU2PnO>We8*Hvz}tNPZUp8kt9u#n4>ng~EP*C{^5}AimS-! zs=BNac_56FdfDrgA0s?{b^@zMSSq#APIJ&CG#N=r*8tSD4zzVi7e^VDoS8GYq}e`y#RVEwMrW0h_GdmTlT58b5vb z0LpVp&L)ficCEkKQe+E^w)r>pK_ESUYoDA0-aU9+sSuSE)k76hF>iEezojaB&cWD0 zJ0$4VPg5_p9a4#StR{sRLoL++^ACD4frUjftzZHz)fXt?Yw1GIl+#R^JoMz0nzbAD zD_4nw%P56L08~T?*K;OE)^3R^1qv7WX;>E(0-;sSqY>fSeIz&?xN^v>*%1+(T5}0V z)W#9Oy-J@8Y)}$W;7L5*<-ZBrGjqjA(NhC>mjUK@F+}4ly$G>w4Bk!B15NW3e#fAz zD|`g+14!({U>wfZ1t@uS#&kl&A* z^aU-^lO=0zrLHeMy+3R5L4oC(hBiWMG7{3ap8iN|It|4%#=I6BG0)rYyzcH5-P(wG zn@^w*+z99~K2kYZtxY>AkNRjUqS!5=hqukfoRl^!yGGP{t6VoK5qL7gBeCspmXW|0 zdddX&4%agfsADJ9Ooyjz9nTjg`kNGEbD!8pO% zHaW*{m@&PsuBsBciRXo#yx@x*Vxu5C{+4{P8?lF@d08fVlNV0(X=`-ES-qr)M!VRD zeXlYwwYMIw>8q$6dy`erk!O2+ZS*f`g!lZ0|A2-(?1PL|NgFWX-W`tfqcH3zKMJLL z#lKcWCotTclfJ9V5xt<&HMa&Q3T8ka?uGw&u#UskrAJnXPSV}+_e?WdTHhRN2&AJ~ zZ(I@DCJ&wShY6+_3Gs9WH|>Tee$GbD>U(K}p0vm)zC4wl-y^>K#rI%*X_jMlWtD4s zLv&P&NTw@|1l?JDFY-2c5RF2_4Nyi=WC~L7biEBdh_&GoQ6*3Z5uSo=n;g_5ro=_F zt1qfApEV8rrFir!78tv-r)H+v{G04PG#^mejz-h=*#Kv&3M_zn5!j@A~FhLP}-^HgQVzamSM#NOuf8*Jo z=2^7RgK3EZ7bD`x#@|f*^6~pKVa%Sg-Dcm|@TwYu?{M9{IpwRt???RTkvJ+}agTid zNWKz~uEK96Zj#6Gi|Y+EZ$PspAv?b7OY4iVesaNv_|lU;dEBQ3-ne|>8Pt++OFX{$ zN!I(~@}+tfL(a!BM;Qe;s-CWiCjZ}sNmC=$Bu76=0Qr7Iz8hom!R@`&g-t7&%dt;7c<|n$AA(uj+q6y!sDMnh}R@fzCGt zwy^~hxsQ977ZDYd_yXS&hcN^uJ=B5k<51Fq-uc!gY>X#wVbY{HY)M|y`F8M4J2|5B zTHrnct`a!1$+$M22e;Y7<1+2VNx0P;mm2IzhOrnd);W2Mz@@P3GT^=d?!WC1^xby$ zDeQwL%Km!vqZyITA;y>vq6J$7XzE(uR$OWD}`)>iwh~9OPX?-hB^&kh;kD^UG&rp=# z_nzNf5hweIq=XydSuoiu-3Q2b%9b+~rLA|q#qoWHTR)Fe99r&)*d{_b8Tjo*Su0)e z*#J1&j;zrG8Is9{9T@Y{&Q_E`M2~~|Q5tah!2PNBKI@KutAJ?p<46qe;PD*b8+~~t z%KPzLeD5P9U~kjp+25JQo@IN~V}hv*2tUj3fYt-rICU5)~_2CP$>w{hV=UO5FJpccsLQkT|+qab8-a;k>gX zZjQv=DRK8m99abC{hP$m9f@(J7=O7Q^!|rsrX@Qr!vTotQY0=z;wX9w(-lcvvBc4m zGv}?9IG@A?B<>N3dtBmLB<@v-qfwLjeIRlBC9bBAq5B{puE#DwG%s{2^dTNgdLkg^ zaw#BAeFV@jLH86O8kL;N)ao&7DoVOGZbG{uA%lE2;wo7QIgvdt_)9nM4CpiBo zamOUij`<1Gkq;rJn+Ax>4FGbBysIRxP2xHMu~hvq8)2Er&o|>Pm$-63`GU(_KwMf- zLiYmVavzqsKT6z_68D_M4TMjk0>N*%gf;TQ7ZP-a*Z+oF>bWP%>$GPeu;_?5KI4{#I2IJ7XWdMcFNR$$kcrjcK{IA=$ORW zFneR10}z*%B5}W$xX%D_FZ%(|NKwlxF%&ayG$6*2mvXLAGa%;oxP+bp#HF2#85GUf zoJxg+z5z5^;C=zbqriCs4J#fBh&5COh|8#zxH~28Pk>mecL1>jdjX9RoPU%!=c$I) zQUNjDD}b1DSVFhrrosJarG%c8P=|zm26U|`ovM0%DEN2E_cxYd5DpDWOx(GRhqW zi0PIAV!9Q8xNe^SVhL<6qqNfjFx3-hC9VVz>u;vS9g@&7KrG*Ya|}O}&45^f zuOxKJxkee)5^9jpJ%Cud8v(Hn-ju21(~MSF3uvN3*8UD4mU+K~ew5HLKzV}hOWggg z5KsZ`Y7DK#z3eK1TY-_EAwR}bhMq>hWats}GOqb~vL7v!kPVhSR&b%%S)Aixvf52ZIMu_)kvimXw11*LR%!1 znqZ`QB=n|)_DYCmGR%c$G7QmNg`syOof_eAn@PyuC|4h$;duqg0~1Wm^~E&$Sv zpP&&0!|?Y&6oxFf8TlhL<%EH*BbWwYRzX`4%ramOL}Bg&rWiVl(EJgYz0gSn^9*57 z(+FlGFfPo_BAB-bgIP-i^D!{3=m`-_CoroVW=uEbLLZ6HoPau&MPX=b{95#$2o3GW z*&Btq0+>wnrU=bMV49;aD28_~`l7Qe3bP9sUle9PFl!~o?0Ex~ffv2)Nc)BamxtNw z1~P+2CP~2Taf9j|m&W96L+HnHJv0@2B(dU@K7tP>b#ab?It?*Mu#lgP^JA!7It}!u zkleTj#9)3MgQ3Vtd>FZw#$Z;(VAjN7T4OM8MPcH5Zu>ZzCdLE}gc?@P%4Ca{_%$67oJ?}=>;@SX_gN6|C~ zqiFiUuzL4MM?Q99XMy3hu7!AGZ0Y-+~gZ?iieM-ieTvdP|rLOhiJq(+LchW zZ>HW{2~obDUW3FNCMmB-?NNtlH$@S@PlDSB!zY`#l0KA-t5Q)B#6K6Bh}19Qn2jju zjjrLV$heNs_V8;Y9kz)wq#q`_>hXS4)+!2LYP=cc66&hz5#_yfCcHOQSCxCb^@iIi zVi@OzrNU0u8cIF0OZkmE9HI@)8XA#T_(-Av>bg6&YLnk6_**l1Y%;yGEai8TrQ)5X z6kLC~8R0G1>T&5Mm3SFiT2T&9QE=uqFG9@;x&y1I6tnLzvp~X|7Pf1^qnUWGjB{nx zynoRRdN}9$cmBKJ1&o}f&1M;UWUiW3SvMPA=X8NgX4r$!eT#OL z7I9_Pqk^OI@|XpA;W7ziZZ;-}@e&8?6Mo~$>+8#JGt-#iQd4S-qc5RS-5kX`dGg~W ze0~|8y#AdZugk8`-FUeoe!P6RL8pu1Hr9_-jC5csiF@(?y&o^S_in-5 z)_k~o@#96_)6IuFo*yqvA07nV-}HK5QmPQ0zRwKbzAdoOK0f`rpYH|Qee3X84{k=1 z1Do2`iRp=+?&S2obCZy2+vd9w#Mt^K^E-_6zKe?%(EQHu`$hR_FB2yf|>RyV&^0KC2RG# z@HvIglUl6>%8-*}@nP5BQHv*IaoM~@*z$OAv)U4vgtW%jJlVb@R_~b+qHVq@NU(X| zSzI&^*%T^|HZBeYO#2GMI4gQZ=k#N0Yv*r?gi<7ld0(ISjs$xQv4!z6+P>(?hDOrx zbpy#4%v<1l(+95|=@u<-f#;gV6+*_YEk2K(+L*B7;}W&SFJ#6Z%UrA1g?!umLRM3D zZ`aVvyH>(xu z@43$qS<$wfZtpdn?9D~?GLeh{Op|@{?TYtoxQ%OiE#$O&9D1{MIpD`6r^9>bX5Lq+ zt{-i$UVOx6_gp|Hhxe=CP57qDvsc?BzKiNQscVA8zsaWU7~Gcg#@qupZx$>)tyw!c z-RbaevgYiV+jaA1+J}4t2|!=-IDGT_IXns2aH_V{_gB|kf=$ssWbIU2Qs5NA-)hAc zVzguXgU{_Mv^^kd9nAr38!NWT&XV zY?f=D&=cd1+z|ahP==Q{%{d2C>j%#5U zCS0#r{B3ssw!}c;QMG0GkwD?kI2{cX9>eM9K;bVq9Sam5$LW`x*8_#!bKg4jE(v1U z-?l#?R5BqUlsjpgJ1H~#3JR2^w{q!f(=?b1ZKcKr@Fv>S8=7GY-EM^h*@gsMKOu+B zzs(v|Ryb0YHMC%o6$LrMe+2JlY%Na3S42%)a3OdmfM<@uv%1;fm%vr{h1nkGDtu;U ziz-;&2jdjqJbU6ccmD+M_-$^xwR03UjHfnz;~f*4VGZ4G0sFxQd)U9=Z-u81=6Jy1 zxMP24!KoIovxA)t>@1%A!JlaJZ2VEu42$+j=Q`vEQ|*)RkF>YC1y#T`Qo=*2bLrQV zK0&5KB&D;3GQLa;GA4UfTSnWv+N>T&@DdE3usyrS?mO!641sOJKs;5xBZ<|`-tS?@ z-;f>Kg&o6!CLf0p2PPjQJMP>`q`v{FcY9M8it)5XXzidq7AS&66degnK8&kh0!6N8e?!&dVVb@GyBU{RJB{{d zxe|4`P}a|Z$uLRkYUpr3Q(57`Qa{&=n*ntS_-sL^fFalSQ`d{H&$aK>_22E{ibRS7hd6dYj-Zb*Xx9{NyS(_j0+a@hZAUvy2i@z2oaoXfNy&_z8rLVMn{oc0D+ zFi6{?(JOOaUuf6vr3-C`f1f4iuy;R=7os`Q#l2lQ?e)-a=eO{x)#BK76!)k8?S7)i ze{x!a9A9*HfajaR=Lp@INcnYY?Op$uYR*p!Ptcy!%hSHyb+qlME$0VW?0d}Qt4oYLubiuAr}%M$Xofi3p(F!pa^^KLEnRf^q_yzP{Bgww7^?1*)V z9kH%yn0C_6**dRB?)&6?v@H~qO?X4EpN^0S*l-NL!7k5jbyX-?p{D|UE2gWw8r!US z*D8B#Ca<&8XO>T^av=vv!_QcC@O50p&lAL=_ru}JbQhP^`I=X)ZSB~5z;fc*S;Ma@ zzjg85zkjA}$EV+0Pdew45fi4?FS+Lr&u-fJ*$)XPpL=QE#EJ(0y?=ae^RCYi+MH?G z`6ZQ}#+8q++w#sAKlVB0yvqu%uktqC_r&vC-~IBZ#DV8uUU)IGMfoHT9jvIqXWzWx2L4%t)EhZaq)nHP9)^$XiS*mtdMhK{bv51zy0e=um5BJ(WKKa95&|W8Mg-?esaSbyE}hQPR+<2JEeBPU5`BV z@|z!hee8rYF1qU4U(dWF^t-2DdF$hEei?A)kgLbtGHc=TNB{Qf-}iibTs`aJYsQz( zUbNz|H5=dlG3)Nhpb+MpXB`f%{{zl3vcd-2E#*M{CY{L+T!4)z_nto_tU54?ZD zv_F4!#oYCWlEwtzIQ`~_cV9T;$u4_S$Xr`@z#b^tp1!(fU&@1%KN$MLyu-G}{4HsZSAOAKS@KTyI?s>Eca42BzP}> z@28D=ZSY^FhX*}$4rK_p;}`Kb;V|_N|Map83rgzx(ya zSG{t_FA4s<&FB8H;`5X5ow)1L=Nb+s1;@N`;gd5uPk;F4-NQEA{&U}DBik?d^R%x{ zePGi2SFE3VNL?}h?TgpU{_d>DNAqlW2M`B6&Sc_;g?PD#hj97$(fcPX zh>L@8lkqFT4~y;MARN7!^5B;yFnHp@*@xfb_??3v9fVtn-#hvlC&h)|YWzGHk7x!Y z_sUt_a62mIDy)$%A{(;hM^QJ0bT z`5YrUEQ!y?naeGVF4sCQZW%6+4~4As=yf$e=-N^DCM?MVBqDnWynJK~`B zr~|GMIC>_ggK(tx$AKFtFla-_b2i{ag&w>Z3QOpFKr}sbDua-ZQ_lv(xC-czakol{ z_J1?31f?)UpJj3mY9WShLMlTp@W(44l#wl=A_+~AP@RMtCG?<#o{~_9gual_VF@Ke z0=+Z|RZ56= z%8bGk;Ho$ZGYMC9QJ896t%|}d!Bs~T<{n(tq27_Qo&Y8j^@?C#1cttnj9}iTTu~U( zyDtiJ5EuoP5y=HmaYtcJ1f~^aHYUa2a|wfA1Vh%^3eFKs0Whng_}mQ4TJ*?BSf_y; zF%Aoq{6qUX>3~A${T!~0@j;-)pJbf|T2ida>A3ngZ)K*{^IE5PK`^&mU$3RBy7Gz{ za-r8iG(?d!)J(6|S8Itt20+RG9oB0s49%8p6#ulT31IGdRz<7+}Y8H*|Vym5j2M;j#&4u!)pqB z3uOd80(PpQK)}32u75KKf$%oK{DMThkC5>ocq%U5ONd}Z^bRDFSm)8(h0-d#_4QSV zRYU=3%z-V;X(E)1p4fYnN0!KGoqF!{*~Th0;z|6wcoUc9T<#J_WS#n3*m8=nyV!MV z7c83AsVD39-XCTwJ0Y|_5vZC;->Xy8h%ZO6L51px*qW+)`9ME(7mkJgL)|O zGk^aLUu>RpgL!4-MUa*%QEggmrB%E%P5+o29t0A_cifwa0tE8QZGQX&tqqT|$w7CS zT&Kl@r(9>z{r$Lt#gpmDlvZ84KOxt%L zQaycgT~J>?yI#q|YZezia29 zkPCk)hg0mVW2j8x8YM(CG)|2>E26QZ0wkv6KbaL}fu1ZXa{tc9Rb3Q@w7n_{Q;Mrr ziHW^`pN!hk_!2q(@9y6;zQi84>ZpHp|6ZWe@cnxou82Bvlvazbp(Bi0<5EdLn9}O% zT5m&54;r!uK8WT~fW6-WDyyo?5t*-4lw}ItWZ;>3vqHQ#c}UD`Grhl{1x}79`_x0U)(!E=N1peJk}5$y?@a*`@c?w^9*?2 zxfeWw!b7(9zV`QR{u6PlQnvXWI9V{F4{R4{R1n=&G~@l5pFU~jbb?~jX_G6b6Vx-^ z-);4r@9*Z|1anU6c}FAHfb9IN8h*vp<@9uhd!sBqYo{i}>a=4$RzTZqj&8gTz}otE zq1?-b-%VXq9oB@z`$&*rkVF>Fz2HxuVr1a;s^%v-5h25mAQy+Vw*YBx_xr_vJPDyP zwEc~*tBp$_1-%^W*Cv8xG|(m9^=aSh0W;L}K6^0;gK;v&%@}OEGAeFHGU8_Z9d3B= zN^32o*oZL<3oZDAs28J+NE*l0<@bzH`HipHTG2ngc{-s_^Kg}cxDNtb?_E4@eq z{j2n+TI;`&&ad!Ara5K4RU}nwHC8=&v`wT}Yjrj~_k4&`gCE|BYISz;YJ`o^YFGrR zJnJ>H_Hv=Uj3SBv^1b(~a0!;)$)0FDH_X*^t@%m(eMnTeCYq>0IEUU1(DVoW<5kkd z#Km9Vh1Lw#I2O-KA%t33N0E<8w0-`)39!cWP@RR~v;Bw9R#&#dr&%_lZ-By0Sn}mG z8D9Ls0;NyJiO$Bfr-;hObv|TKHn{OeyfV-}485G@!_~nj2|%IR8_%?A9~^uVv%7To z+-!UnqXgQ=tsU@xY4h*3pp@KD{^iHvE-q7h7w;zXKLBYFoc@drrCx(mZRn9SGF%v5 zn&q&C>LGjoLzs4vM;F zQ`_NW%l5Xz_CSKV{(9?wlOd0MT}}S4%F&KcNqNWNFU!9<0kJAFES@wMerXs4($(d( zst2Z-&~?)}FbV&0coWT<@e9%kS5xTD1ck~x^*+M9# zddEI>eQO_|Z_%QM4lPK_4vfuR1g6DMuXY6E+0cb^!LAJ3DzX=e+N<~Hr!}a{o`ZP8 zjsgituM|l+B{0in@59bGMd++XNCNL;NScDAmr&F0z{KO>FY%hzcchyNRGY}Rx+oF` zLUS%a1kL!Hm8CKw7RW#AkJdlw;E4A@zK#S3~3$cw~UAh)3mYt$)zY0TGfY*kU zTV20W^d+F?L4XCKkEv^LMVPkQw0ZOdInUD3w$C2k2j6HkzHw<)l$MRsvZ=IeE-isdYat=w^uIw-n;rrpYbOn1E29d01|*1e@tJ+_Caq)f zXJVAtN0r22>ZAM^A<&@NMqS(XC0jPN?YD=or4mpdo&TA{U#M@8iT|9U{|(i(qmk4# zaI6^`;cna4xAR%jadD{F-L}7PxDbYKN(^s>X3f{6Y3QXyAJBu;_Vmatg89VQQg{tj zODIl%UySLR|7&srDcst^GW%n(AhD~^Yx5v9nG3eISl46Chb(}&cI%xd0%)ecYpt~|RYDLe~piS$a~sMkctt=lBmNc+Nm^{rs=e3#$ZdHVG0xmZP%;^U0C$G3uEv zbTX1XxC@QwPO#0?0kS`#NTvw+=>Z)%ZDM{Aw$qr1=C-*AtqapGng<9aTn5t+>5Zmz zl;61|2zT|Sc7PtM{kPXEsnNm*FNYL%c@Y6~0 zi)bRD`#ru7c1O*H_FM(U_-?203q#Q$Xs?{Ek%-FHw2sYbkh*^2KvdEZ@~@(DummKU zo_!<3QNB@sV&_tup2ou0YPZ_t$GK|@tfv(GySBgpGyx##BLJ&?@ZK*-U@@5jaA7Z@ z|1ipckMCb)b#b@A%x9Yg9)T15KT_$Y@`gP}vVG{1n z!eEh|ypaZrQgCtvi<~rH54y!&K-7aKaQbo>=WVy;KsnvPCy6a>l=}9L;u*)`iZUnY z@E=tcJ?**Kf3(~CrO~m2#n^@>B4-g>Xan8^g~>7XGC>$*99A zl%qNLoa}G+=e(!-E5TO#zVk%tbK69p19Ci&U4;%S;ug_kT5g)?0Nn2i(eGT;?@kx} zZX@@*0a5+#S>f4NZTurl3>r%g7TR@2)Fgsg6#WtkohVu>&tWzJm|S=a8VlP=Uq-D2 zEB^}&*@J#sGwDH2hS)fljNiYP=~9FKj~K#W>Hm^JjFB0&!cBn)AOI%Pf4eC>ys1A(lPlr!E9>c|;@iW`Tmnm`2XcZBv*W zE`YUU?G)a7!h3#Zn$;#6^L}gG(6L|IYoqS;coqp z#(;54<>EPe_ z2SV;LWis9W$o4QG+pzE2S-rTewr{nDzBt-}^@Bi>H8?ssP?QiHja^GN?6VFO^$DI7 zC{B!hkCKMR2p5SBUKCm;IRx0aZ>Z~woT0mGu>yzPp9m#%a_Bldm{^0w$$^OpxIF|W z+A#AAOzacH6QXz(vsuQm!)%Y9CUQ}Q6x4v~=hV;QJ|Gl_CrrI;ntam@CetXJ9kt(w zEZF3)C@!Vl*Gln=J!%m-y+n5;!)(|?8MoPvjgW`oawpZ|2OqD z#^(;>Q4P*fpb?Fm0p&39*8-Uc7 zd#B(O4AMRstYy)?kG_Ekl%$+p7$X{OTQHc0OEeS*xk3ZN z-ZkBczb>NMNc|C|kX*i_ebi-}agFah=mB8`Kzd-=AV^TamHwMRrZzo{zgPN81-t@( zInI|Y1P|z*6MP%UYXWYuHzNg)fhm}=J_ZgLGUZBf(7zpt7;q4^R}?MgPC~oTAwBtb zcVMzM43RC=CYoFuBa5K(Q@yA#3_h42p@#Z>5Vi@P)ikW23J|@Kf&d6gQ{mxEAVoyp zHjc;}-bsV2*i%hURTGhH7B)!55q<-FlS3eHqO=8`yA)8&G~CM0W@fTJwqpF(=ba0Xh=xcsitev58HcgaEcx$3ikfCiGfpZLhZ0dV6iF z#a?Ydv6=`b;FE_H5FhxcW{C2%JeB;vZ|`&VoOy)Wd++c5qs&=n?bq6Cuf6v3tR)jS{nK6vev6L&&u@R@)l9s?ISTFUEW+ zb^j=c^^XhCKiudRg=YWwuC}}b>3i=Vo>cvV=Ly#SF$eEP{}=&~{eyzeUD@xN{evbF z%>MBR;8_1~Tlz;GLeM`7&_AvLXcf6{(?4XhaN)CGTX7GXJ%ARnhwP5 zxE8VSb3M@AXW)E>%Ey%FKLKeD<=OW}bP-UpJxob{&XnY*qc%Uxc$Hjk41gGjP zWZOUOEnF@B?WuVAy7 zgTY-4mFt7l@_y>^U`2<}-0(eaXu9w-#*iRaY1qz-+{ht8sZf((Y(S|YVR;*Jk?qma zA~LiL1=InisMDT^DeB(1p@2Dvp};#sEFjf+<+m6Hq%U~YYsEKAwb)aE`nQ}tMr(zV z=0`3qZA*S>4eGuh`crn<;3&kh2q7~WnPLplTCy0?ATuCHF!XJF^ypB;6XT7gKlwVM zlOR}T7g{Tu)3IoE^fI7jd&YI7pGCi;;%E3mMiIhM(bSN2qsgTJQ&W1U_?n z&jz;0fuB)alNF$X?1dgYut!_vN~^|RKV74^;k*z@uo@|)asV}>O4_x+XUHs!lQrN9 zpzl0Ln-3J0pyD8BhyE@%uHS8bSsdc*$qD5a2lm);j)RPH7M~t>j&lN{pO1`k0!Nqe zyyl#%xW5ks_wjPIF^sB8h`nsa(6h9}D2z(3qZ^Ls6FZvq<{T!R`&EmuOHtY@kWcz2X!jt;`=Ff~xbggx*Aa?ahZ4GxmaL%+Z%YL$b zudDmlfmfV?b_dS9+}etBQ6T7;6)xjWF&7gfb!>n&VNEX4d4b(0?O-IRDuoQZ3pNHe zOk7J=i=z&($fK>E$EDCH`zzR<{)qM0<@c>6-Axm~yCR%z3jKmFBjNt+B$iv|w*Pix z+kc;?wXPtU7)P<)e+@xy_w)FoBpMpsPbx4YR_P`DeA^r2ssZ zV%{dj9MR7@4DI3xFU*pn4#7=3ydKWRW>LC7aig>3d2=D$`HslV4zMK;@+o9Ie7(!Q zRa?Co@|}l|AjkEffKn;u1Cf@Zyv~WLu;(GoNY)Cc$PV1Kn7kfwhl4VA2^Rr@-ysN5 z#1d5OFC!=ya>-8>^X;8>Hc5fDW_TK$e8cDfHh&KeGLNy? z?xD5V@HxFU@J)|53luiLY%4=6!%6#IJ1CvvsMQDF>(<{2tcR4`aI&`KZ;RhVkT{?; z!egm(QtKVlhva>PAL`8|AgIN(A+iO|>! zQbUpGF_pI@ZTO*4?Is-wZ;U8Mm9l$kB@m0Rkr}Ew?4y{oK4?jMoG2igHoGr`+ zL=Kq4$>H)Pj?Q#urL|m&uw(~9#!!Qm5R!@F!vQyQiNh2mVTLDR_{mOus*y>UTufO0 zuWlHj9&&nQsTp?<<7wpKw-qB<4kt~5=c2tM0kP9*h(MIS`U298)3Za#TC=@HbD$A^ z4xBMJi7jkLq8v`#3j#+ov=u861xxcMfUFhgKSw32L<4jLZp52Qd?Fftkh3UA+E|>z zV8@&d!A$~AKAvy`^B^07XU6Holo7**Ackw{VB37`)SwZn!>0;1sPX-Ky+9Hs!n#b*|*USg8n9oQ-{V$y#YRf4!ZX3W@(u)yvQCGVn(jYy?ZvP6@rNG}5kl;A5b9_oPBU7WjxRtSj~QzyZ5^OK75JiWWQ{C55NupwLp(oKn<6 z_st{%uSQ21Db>VSY~VxWNBZ)@lXISD^uz7A*>(fU(pJM~<}_CjLh~sC!eg=Fs|5#P zH#9s>_%R*;FmN>Ic^6V?%P%B()xv|E8weIBCRuojeE>Xj5k+|H)I)SulE&sqptib2{j&!bzf!}BrHYrz^IFohWj5`F@v^}2QpfD}`x)DGQjB)MT_!A53Zh3 zz(mWU)j1EMTTeWCZCMnAx(0bf!p1^s*Q3krag8XNxy2I0(}>&ZEdQY^Wcjo9h-Y4r zPdszG{NkCz?>7-ID=6PxL+=7(An+!0qVJ)4h){ug*g7gaQy9CFFL+7@yoVDplQ0JK zE?vRLkeSguKL^NEX6(7UmE;CjkflbKkKTosz(;BNtGM49eH3M3N94bp+KP<=Ogn2U z%)dm};YH4`k^K}Kc3Ts&Pb5qqo3D4G{8DUSpew@*Jz7~G$+?Mh)*$1Cq~6gvRj*c%eO$l>5!ofj9P>Z-HW}!hYJ# z=6>4uwB_d@ty-B|_M1r;FW02lZ{CP18=DJQlVi(yvAB$KKhW$tToG{y{GPd&Rs{x_ z8w?eI%?$=z^|9=wT?9hF;_28+dk8sLMdjP8|*S6KEF)PA#lpNJ=DeG2Qq=xNAP$`=I0#XKk|d{R!2!k@Vz)>9C>Gq3>x)Y;K8 zE+Xae0Gu$RShf^q&@nPrBj@M9RNHqaV?nUd{%Z7VEbI(PY&=&d3ucVNum;P;6+4w{q<^FBee zOVwZX%ag|hJ?i~5kPZ6O`{{TmlM*+`zhFl*Iyb|u8|Hl9h;WSQHd6)?>`}?_KOc*! zBCNYdhG$?&31zGA*Z1f&y}bUWVPfs|$M+je#_{`)%@*6r+blw`Gqf5ut-j)Npm5NDF4Xtb8U^Ho9I zrdr(*Ud{!<2kq8i49_5s$Bbp&nZ|j;`#at*bE$IY{!hytbBcni9HL~@_WiP)|HUGm zz1Ou$Tt*^;-!IEkMgH)AT+8%R6q%mHU$>nO`pIChxfF=hAc6Rnfo0DxPQhQ*Y4s?;V0N@!fV-Qx=XnqtADUo z|I5)_Y`!&jRISH^aj(9k{p5LDj`p!(mePLww8De6di5mRFOHmmxKF{p*Oe&NI}G^^ z59fzkb}jp>*%zjmePNQ#i00dgXhmUH^RZuJ#&hqL`bKnE?07KuOS5c84m|(LElc}` zf6YEotEWYrZ;*uWk16WyU44#x%;dPGTC4XDS2~Sct~zxt<&INiGu46nbKf!_=c)2> zhAXqaWj^Vr$|pTsnIrSj9;kql{wH;FCFdpBGZkVY8yy_uceI9|Vh&{Z@>T3yrt)LV z%M&TXv#DDGl}qgU%C|)v^Zrx(et{R;!P+wXWZXMc7dNuRBAw&FNDQFnII)(OEV@6S zyfJ8=HHf2eckKR%^}AvZ_F~TooP_Z~rh3?tN`Gb}lErOgnD(jS>c2zK-h2H&{U_lZ z=i~Wvs`~Fn?EkC!zbDEP{NVcsVYZs@<&eS$F0r+J@XQ__6``l~cE zHV-U&zfbTwm~Wn+VUExBvReC8;zjnNUe-VVr}qg8Kn>SGN%slfLx8yk+6>rS1L0uY zvIhEJyHC)e-Pg-~f~Xhs0y+N1txsO0iZ{9mtVlv18tVb;eVAV$lA6%pkC*P()oh;S zb^p~|^oZL9tHqZ`Mgre&j6=~y4@IXUu4R2Dt_LJs1j5lFH(To;I2K)fRw2Y#_jNH=^aZZWpxhJJBi8i?)-U3FldA9x&nyfcw*~HY+P(EmRtkk- zaz3!33Q9qq?_oV^9=o`8W7!Ivn`u}sah0FTqW4=yAj;pR=wHaIxQ)4){KJ=PTI;D#U%i(4G* zxlK~RKrOflvIe~-*v2}WtRyQa&rjI(_7@qTwd}_)?4)Wf?=aqx;;n(tzwUJQ#|xHF z&XVH`58AgJ=>ThO-b@6x<4kSp$-rlJZyHX=F)eZXD{;6?+m}T;zJ5!?vHV2OT)lEu zaa(7FvqCj^-Xq}7kJFx*BnMmBNM({dPlP6gPQ@JM^Z zY_5fjXMD6HMwQ`O@IR1~ST!IfHqNrdM;U<5e`ri978;kwad%!2e%xzSGokzKWwNXb92W<#ldR1C_jf2v%%-;+fsDPmU9 z3@}cdH&rh|)uKlsRp39!;w7!-i z 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 literal 0 HcmV?d00001 diff --git a/extern/for_mingw/lib/libpng.la b/extern/for_mingw/lib/libpng.la new file mode 100644 index 0000000000..ce7dc3cc63 --- /dev/null +++ b/extern/for_mingw/lib/libpng.la @@ -0,0 +1,41 @@ +# libpng16.la - a libtool library file +# Generated by libtool (GNU libtool) 2.4.2 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='' + +# Names of this library. +library_names='' + +# The name of the static archive. +old_library='libpng16.a' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='' + +# Libraries that this one depends upon. +dependency_libs=' -L/home/roothorick/stepmania/extern/for_mingw/lib -lz' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libpng16. +current=22 +age=6 +revision=0 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='/home/roothorick/stepmania/extern/for_mingw/lib' diff --git a/extern/for_mingw/lib/libpng16.a b/extern/for_mingw/lib/libpng16.a new file mode 100644 index 0000000000000000000000000000000000000000..dd34124ac840f5407289d2e34fc84ecb07834ee0 GIT binary patch literal 317662 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 z zZOO?VOuQc3r8nYY+SDPpvcrRUI?Pb=GT=siTk#3B<@yJ#AGPkh|oX|e@XveeS zLz1_;Ul4g#y`_$MRclj%osk2H@<2Kv^#l3pjm#-IIU5MJX&+^$4ta`C5J3z>^I|Yi zWd7V`A|E?{MLV9&{FQ$5H-@4Pz)$3#oUD*=W!E9%Va6DJJ$Hxpk(UU#YC(Uc_@v$6 zKaa$#8oFnXrjY+_@Hcm;ReL~s>LYisE%Ki68u-7?j4%0n0r*>*s0w@sbF@AoZiSFD zNIUfibAG{ien5@+1Z;*!f8#~yp{w|9G1Q=a?1hn2!e=p_S~tt9zk%M!stt;MC~}NFV~B`jIc}VQXZ_q*8%*RV}9lOL-VWq!E5j}hhGmMI@9jK)BNgrkaOv0 z#11^@4eoy^AKu~__=xo=;n}t2FqF~Dk(0XSbHHGc13EgbuoSdGwZ{u0BNGpLm6l-V zvf-s2rJt#Fu;nws8lQrNGtXhEkh14Q@Tk6Do%B`exKC?v$E!~TTjDdjSG+0aLz*rS zBBj<1*5A-yD}Ec65v9IGDSnF~_;myH*YNHxerpSL4uG5&;T*bzx{39^WPq!*+u+KZ zbs!!iJot=ZI@UMd;kDwOU-51cyOzY_U9B79AQMEgqtprVBA*y{A`378hHpATiAi21 z72K|BH{k^{@rc-ZNIN(!xIJFe9XV`V12EdVi2-Gc3WPwkr%T_Xw4_j+N9IvP;#vYqUl;=4UY@ z-d+5;X4GPl)Q1Jd+f$uGl=gUKckt~Mn8_ZK+dRgh!DC$UX?gk>Q-7hD=6W^J9C6`J zLG6RU=E2sX#2sF}QP~#Ux9lveXRTwMVR$P(zB{;W1$?7krXfq32BZ`Iq@W+u$Qa%6 zC5F}>&kFwlBO76#v>VG^wJURc!uUklarG?mqW{+({-|_^t#36aIT+A}$^Mn-s?BuA zYw#$D*SInKP@@Em_>jmuA~%6gGUoz)Yl)WEln*K7s~zP|*E| zW{dhZqXNN9phIDZ2MJLoneJV&5X$V2!B-Z%D)TNt zjLk<-nsqWGiHzT+y~~HV`XNL^(Y*RnZ9c5$$AYV7cCUs;4@52mIH&dmjK+JYq}mg3 zSB67twWfT*+}acF$QO2$YhVizCGru}AdoD|NtWj&SN+(foan$h1dJBHhVL-gnCS2= zzZ=~lzuu^~L!|s-AQp}psuw@nku0pWh)+4CrG4>Az{U-TSE8=RdE=Gf@HkJr5>+wI z9j`=Hj8o#3(5LL+YjIDcK|hM@eERld`;t}7?7dK8eW{NS-y4XJh4Q0V@v*0xN9TH* zN9R@O z?8sqdhqE+ZBr5$31IE`oX^ndW!XA(7MoQ4Br6rNsqJ}_0rGn}?JMx}>6b-MLpCIBn zI5v_WMK^^*2) zj!unWMNKbOpmM+mim)xeUZVup(Xs)<$PV7LhU`?ECw(YcHI$SU%~zxElJ@4} z!)&(Nz&cNS0?=10@d-d*t)R)BphONDt6<8cKCy^cS`xk+8H9h|oxI(E56HzHcKNcj z!(Nt;W&}i!1^;19#)AJS?O5<1rR5t+%Qv9o8_VkI zQVMYd2EjoJydxK6=E!BA(E_#EEcznd#_I^{`{4A5Wh}xn$o)CfNj9L+8`Hah zl|Gy+Ju4J!$7~XUB7NNkrsxQti#kEie;-Cz5_%l4Jtq?Rzf$YHqp*H?92d70g;Itu zuCj-H9N)D@tiX0-r5cu#dIMPa2Cwz!fU9-69HLX}mZDy68vwU7XFDX#&A{tiQpmuo zq2N9>x)ilRv}kt95;_ZlC20kTB+;vNZ6F2j`FlPIAflSBT|DEVVuyLH~&i#De+cb0w|{=C(~oiVya5ioCq5bwjjWDBn!x;lltE zxS48GB@0maN65-V{$pf;(Mh8_JOI1Vp+@V;JMe>?cnI}iu@);Av1AYa8&(C60|O>Q zmR5LE2YorMSiR~&xl{k}ypL}<6!@QL8lucn9HH~`U9Nc z@(MWwpHN7x!Ansr6vd$wD#;D!vBZg@fU*l5(|1w?<27H43FsN8;x&+w8QnpMGx}a? z><$Q}v4G9FtoAb~0k=b$4yZ95B>)(DbXZh(f!-ypWM#Iz=kgB{&69M)b>LzsWlyoYsMtAEw)v9+ePmb*r1@T$kk^j)YGTuQ; zjjHt;yBHW2Fy6w`WUDZm=*XZZ3W!_(ylkgHNdi*fQhpr&#dNGX1}0{wDGS`e0wd&8 z_LDQ8gEO@-4lcE7Cs-Iq4b?zqrTGMJyzv>`k;jaifmgOSpNX*WpQb>8^05ZD3~cfx zr(mT*_KIPN{6}l4Fh!5viAQY5gXdu;vvjwT3ayKypNw7)INzrE zzVq|6*?{FEhBpyenL2!i_7A1D3qys&L7=*35PoaBpq*SCR*S_Ju|h)7H$|nOg#sx) znt_)%6%C`#@LyyYg;%4$Wmt;L0ptMH;xMC&1f^@#y4XFyAJ10nV`9dO<~MdPLF3$j zaX>fDeFm|`B7~9X7>C8<;|4&63$QD}hrD4o(M|d>a)(O7)0mN+`p~DehQtEZMQ{T` zsD%wusOlTGc4NYVidMW$t$#j@-1c-)^)`J0-713m=O+q(jz^JNUpQXf)SBEd$W@Cn zfMCof8U@PE)S&{b{ofVAu%M9BqfneZr;wyDk^g6G5xUvbB{U~9JaHN`Myr3G^900& z_T~R6GLV)ply@>X1yu1F;N7Duflb{6y_+#WAoV5+|II2=^lVWiD4X7h(y%2ez<%sT zyGX5&*+TSA_jDx+*CW+vy)}f_IJ$&01{k$yRYU8f4DgO*3OJn?p6p6Cu)QdhvLR%^ z$FP(E?zSy$5Ve1aTKDLEtjxinmZmd4gZo<0M2+wUu)Ym3K|I@H587g7Z%AyI%z`|H z;P*7D^-0dpsr4OOSfj;9X>!#~y95jNoIsVLJ_|&B7CnXstYZEIPzrnhdU8W98Q`eT z1CIK92MjG_ok~wCQ=h0y<2E+VLM@}aBl+M#fx3o^#;|^+iE9IYAVwhMt_@)Ikr&JJ z%<_j1pgk%FSS-Ip0bS5$UwW~y7px^J=hR2x!@+wQtv8BVrB2W@7@U~;1d8h&4UND; z0Kf{xcd`hxn{bh;V*FlXrkmlFYLX9@W=S>4$2>piXX`53sTm4A2(~zSGnyH^z}uMR z#S=Dj)&M*UbqqHgRo(~V%0of1QU;6fm`A-x$=?3QKKuJ$StBuy@9{e_AtxQ**=nh= zvjh#ArTTKRo5j>@)t9s0RDI1>eKD>PC_RnO z0tjj{zXBcA0_C`#A4mse(Y*Xe7%krmPbZt+S{^s3QU(Q48})^?$X$Fp~%yTjmYwkRlv z#2SlJdaM2_iunZXbcpQ~HMk>iEqV*+Bs`uaOS}zT1ciG%eW?>@jUssnVl5TMc8i9@ zFVf*qjN^)?C&X-dGi=#ua)RPxIe^TKId$~RX_g{dfmR9;vP;s$b_6c$#dtx+aR(WY zo_t??vfJo_a3u-@rLqme@f=qfEtmFmn_A2j|Z-&2mU-4gZ!cGwEhK)c|G+`@RS7URDfE&;S%AIs7~nO*GdbG#J-CBCusEqjHU>xqL~Er%*0waCT6ChX>drz6q1Lz_Mmxjo~> z1ki{gh~oD}p4aOb@`GP9kv(cvt=E}*aOVq5rbcgvJ5!u`QN_Fzh9`Di{1s}mAoYKu-fYtI7vz*E677(Ig&pD;_RSL8fR2mEcZTW{>~}x)q~@=~l}~lp1F+#Wyv5ob`b(ME9MecXxd)*wv6F6?xkwN#O)T%3l*Rt@-1T=D6{Nuy^t@6AkHpmabr_@v{=wR zOTntzkGQJ#6MY|O)iJ!Wy?CFF{sRVXfR|#KeB4ATS`V?VHaq=1DkjskIvV3vtih7{ zYc|GLBMWv@UjJ9EJd~x#YH;daQMQ9mQgPBxCJQT+E|ls_<341+4lYgbZ8bVipvn%7 zh|!&ipsS0va72v0Oypg>xbY$!nK!<%Hq+0%KoQ#V&_h%Z%-5zarU_=z_xvO0Xne4- z56(dG{>?&EIb2tMG0f)g8A0E_=aZZ^V?HCKwg}x4>7iTT&YwgcpX3}ee$Q^aa2x5J z!5ENM5#j?qLIP2he}U++eae=R8PoW+ble;e7hjt36l#UIt`MZ>r1#ifQPhjx8YEz^^u7-!bc~#?~@`l+hR(j?x3@n6AV;O_7|Rt3iJj zlC-i@^9B?&Iq2D;Fa1Eg=D7YghHFlQQb&AP{8YEHD?YQ+`Td0We$xK_b$n)5=DYs3 z{1Bh{b-dq%!A|eoH)ZsV1uH+rhSC*)777}1ApqE7Y(zK z!Xl`;!n1Q=Zu9ftG-w~S=jdJ^4tmg5zLomKyZWCEMD$^n_K%XBHvMEytM*ZT>YzKPRqsk+*kC8Utm1eU6v~U?H)swIL=%$x z^HEe|8-7^s8Z-sT{N+kYtPVmizwm5G0VD{6&J5y#L1z){4yGdejf;?g2?yh8uD`(N zY7wQd8m>n0b1W?495G{kjwhF%6wn8uWHZmNkta~}#)O1>jRrH}W;~PmC8j^jg-bF) zH^*a*U-By!#yQ7hxjt1Kn1ll3u$$X_2{)H^Vy@zr9Ef4~eh6Tgr%eS=&qJG_I9d}= zjx)~?eCbJ;6r5y%-&nVv9|*steeAA1p`5#0JNUJ}S8ImLo}7A4R=61YbsMOmq+S8{ zyy(|zebGJod!f{4KHZ4t#&1)Uqj1q8=BZ;i^5`WF3u9^8Pcm7a()VcFydq0ac(0i9 z!H`ki~Cctw8vZ zQ;{3fOJ0Cvb;l>6?0I5Ah!-Q~=&1PI@kyxJ35xlu#3w70Q=uTo-KtDoa1uiW2wJ;^W$2Fj{uyEQsL0lyAS_Lm^g zWe}_83W$3}9tOwtmEQ0am{ZioaJ6n>z#HpGPQ4zh8&=?CAvHP@PK~~|7-law_?o&Q zr5#d4q1|FN#(10o#?=@f5q#Uuw+RIIk*svsW9Fna=PMYm+ls;xf_!Yc0&Ldt~y4%X*fhfkPzZr2KEXSshb7g zZ!zsUBz(C$4x65wI=EXu0Vc${lM}b1fXkpQ$)bm39Yex#2HXcoT#_CdT8EK7@cmZU z`SY|x9?kH^Zw13|bH{Imyxyk7Z*>Q|!snHZJ{5UOPnX@+9l@#;;3zvU@=ED}bn`my zMw*^uOtJJ^&?akdUX3JK<9YxYSGH=DbnI$n|HH}7Nso zST;a>&6Rn+%<`S|&&~D1JVU$!s$G>x1fV<|@Z5m9#u3byR#doLBVG7WqxT8Ws*a|D z@GP}%nyiZdQ-vCP12&Z>VjRO0 zpLyDY%YP@%nsE6^?_EeGb75BKM%ua5Vt()#2qwAcHCzDVJDL!91OXm8{f+>*A)jiD zcK{1)ec%M543NDX;yp54;$P5a`&bsIe*pkvon8igC2Jqp4Png(VC- z$z#8gK{tYR2yR68@pTEpuB@4f%DEWs7?jw`%0Q3JtHTR~jm0cOcPqqa3HQr3BEDKT zX4XYC3_O_scVNDYm?PfgXhlyc&B1oL z9|HX+;)~zh9c<=)h|_GeV7*kR(aV^J#`6ME)cl0T9d`)zWx{V@xll~bB|IkOrlSe6 zdlZHrH2ExU92D=Ye2z?#x{22)NpEQ|wd`CmUc%#4&!i>8E`x$#3YIJaTQMeA>43Nw z=n*e1*_b?#XZ#y-=%|c9v@T~}y{l!{9sp5_T4)TuOMdrTf!Du_UT_+gIkZmX7v)aW zKKZRS^Yg3GEA9OH#DazhnTD$-uxjR!Kz%v(^PQ4D)ZJ&m-6y9rcaU{pRcs$WZ=DEn zf_aPY#G5JP?Ae(b6n#n1-zOI{hSaU-Q~e<_qfqCf4>JOeh(~2(%jlidr~YdDmDdIB z$Q9Zdy{o@mkG^I_f!0RH_ZQ`7e-lxl&CzT6`)(3uoP&?1e;pr_LnYQzP~qrEz;#SB zrsC7M+!8vxwj3a_x_XRDu9-B3XL6R7L8`5*hMx1Z$~4jJqz!~19Vfh&1N;@ zI26>jS05H=3uDmN_$_A?<=Fv%7swsn6b*Um0^(6P%v5c&k08l1BuQZ5sosvk3v?06 z;Z1_!yAHuuR(5KgaB%^^Rz18bIc$*P@>xdtZQB+7Z)QbrM?{GW>QiOn z`yBX^_bHpzX6)1*N9tO|>7T>-in}q;dx8_^2R*e{wr@X61T?r7fZOf+sJu=tZUSgB@2-=?*sGS z8(D_Sz#@R$@1O0zXVKyni~O0Z5B+!Zj!2it9@ivgKDZV~!b>7y`Q48f|KgAzwdB z{1B7lbC0h}!Bgiq@NwaSyHIHV+{N>j`4=sgRk(PmSs~xfaPQka2sDKz^Vwuh`2Ho} zZF>c#3~$1-T88g5pM>*&L9cfUZavqHa|uzwEvEAp&EYkhqEc`0M;6(l!8&)zd+8Rh z@ZS{)g>ZZHG~7H1VV}Kl!2^^Y+@NaZOsVy&TJ*3s@2U6W>Sp z-}6>H_ZY{ucvX2z9B-rYraIon<&Af|RrPv9wyW?zivM5Y|5x}=JTdpEf%$7aqXrhN z@s1i;s12wbIMn^0xdRJv!(PFt=7IU6T5yxzD+9fid6WBrj>((Q5A>$In!XuG{9csz zOZ?~aH25proBGLf>}l}#Pu1l9@RP?;;zl!5#`5Db!8>yYdPn6=8A#sq`&0PNKHurS zH{pBqG~cU`{_ptSgzvlYWck*TziY@}%?oty&vL=mZD4CN*xEweKkNmWmFlk>y9%vpG-+9I3xV%LUc^#7{ZfXpGcXQ8jxvn(J%^M#}JX26w zapxmSImZl6%wv5`Mf?p=tkcyO`|59g!}ksNUU<&w(?5srQ@`Q+o5cSO-@hdO(|l(= z7eep~2f18#oATn|RkMRTm3j9#-p1rXZ1W*TK8TT*)$E#y|92v<=wO%YfA=eUCGO5% z@-Zs!-d+%qaS!<%i_B^N{))T<=gJ#0@#-qa|5m`N0P7lvm;P-@ji(7!*T>b7?*&3qkl^ye1AG&CO)&E^Wq~<} ziXN4>+zh!~wsFxo$XJ*{Ai!U6tn^*BdsLD%FdiQF*NMXORC~G@0B6&p+0A z6JUjC&Hf0v?zg%|CVCBn>CbGxBiUQyoX@NFu-4W*ONzl;y}JnreY z#N^kPNFSZ#a!rS>oF@HH_ow|P7k0U#T)EJb)8t#?PW6*RRbGE$RKgB%y#`_CtGOpYZoE}_53%MX?j?xhg`(VeI$5h6IOL9gP>;)V|F$16O`(v9 z?Z~(42QJqxl7+YHKtFBf_n%CwLD*qkAA`ypTy2)GsLp+2rG*KGXWfd7TU zXOS?jHA)edo}TgEFvXoQG2--a!*VH<7OGd9czMng4_^E(L1 zT!y2bWvCn>-nd-oT5iK0v|(#(*dsQK$63p?f3rihuXM11!-joohj??Fq~I**nM^z0 z4n1y%o2|!$Hmm_5DY2b4j91!ASQ$dYkxQ1V!iKH1VYN1F zvkhyoVVyS21>a2OHy0t9-$H~W%}?5}jR=huG<)HJ$#~zkL;q=q{(z9w#=qFGCL5NG z=18Vh5t2A6ZP)~aB#wVH4i#KtrTq^(^a4VXf)qm1 zn&p1W$~l0L%=s#WBn7kV(DwpXyt@&S@pObH3R>#z(8qR2xzzf4ksYeALwDGrRd(oS zm%Ciw6Z!qt4sEqVZ`q+w?T}}vm7*9SN%IgeN|y2>J9PJG3s#6$SALy6+vS3*09*G4 zLX$=4bA;H&p+4@Ccib1c{u`lN1Z>P4EA96Xk~MfgLdX&+KCnZt%(LRXhLGg*CpPRe zgk;*UY}iQ~HUKS^r0)!bWW47TE0^sEjS$$lT2bcA^D`yv6R#DTmTiR!VE;yo6c@tQ z$#@sTg2>RNg;r=Fv_itZV~3uFv`g3lJLE@UCEi-#y$U&JxuSN6cVkHyCro5$ogLa> zhkjv)9=AhJ+M%cH&_+A-M?3V49pYkXiGyve4E@y(HP|6PsN~l|SKJQyz)2Hkhc?zauvqL3jeub`8cIZ<(#FkyAm}!Sr+M!?Aq0M$^pB?J7Lqkx5GMBk_sKE}sX@?32 zSn+1sp~j5^`psc!bmF|@igjN#j>=18dgg^3k^ip%eEqelAsyAr^5 z{1!5=f2<5W12gDCZ0b0mRoC-i{dO$dhxUL6;`!8F2KptW~Xg4$Y z{1T8_XnO{-2@pS+oq@aoNJS6GVM2yF<77h%8Zau5Ni_%%KRVeN$Yp@siAv8v$^mKZ z0lA5(u6D-ZohWyfI3Yg*q@dIZ`57P$!<~@d0P^H@PDnie7m<{^{wMSwKGN@gI}0rKQ@CxjOTJOg3O#F+sIhZ!;u z_6sV0;Dm4=i$7#Rt_sgv85Wcif>J0sce`A5CPY52;tZAv0qKa-aJzWEGUWS zH_p;bMuKBX1ENB>d;LAZ4DbilKt6rH^Bem%{Dbj9oGRFYV)5?$`HL9`<#my69P-)+ z!j(Vr&x*6Z55(vJnH5^Nc=6KSsW@iXGoJx0qWH6NKC=(x{2q{5_s+W)Q)#_YUEU)O zKbG}@+|&m$tq){jABffmvat_DY{u$Qiof-V^Y=cGFZw{vWM%fq=Yl?vtNK7j^nl!q zx2uE<1s-_d0oPUY=FbW(oqg{-*DP!PaL&>>v*g@f29}vDn-yBHa^BqjzGPsSyInYM zR_S#PNOc%8*r(%xt?Uox?+`K}B^OnvrFD(6G(;$aqU_990CmVnl9 zc;2k=;#rtz%j6~F&Eh=UtkPN6%o@%ZWts2cTP95*s8_{|c{^BKe6p{O~6|5n2>ky$oc|zVil~ZO+t*pN4nrl%%b~tEfK43vK^OR!mKWcjS{?7QG(3ZmyMUbuMaG6>(iSuoe4t{t=c zw&YsHxyFfO&f=vgsF}Y+TXq*zpa&f6mC`3u;&smad2{ZWW$F8ZMRVt^oM$4!*Sqe{ zNF#NEB5fz_`67(jocXgCEtN6P`B!>v*)`W)Tk@T2f_{IAfXLs{ zl9KDLyUy>w_WIK6z9Zmw=1x@D_TmzRT9@kq5%MZdZ-StT8SstZEo@jQBDmf{*zc;j z)9F#jFMWS2TqO-oucB`Z38`f~hi5@(El8`H*)v6j>&}X+;o&*|3h~l(hZ6#tT_qJ) zmwu-Q@UQ6q?nAtPJSf3%CPh4)7|z9wbv1d3C0+yzxK*ahqkpcn7Vp9#<*8!_f_s;r zffeCHTm>3VQ{Nu>0;hx9C!EXlSRlpSl!b|zUR(!%fLjamvt0RZCfFA_DvlGECwzz# zYjG@;SW<;^0kZ9r-dZrGFQTO#es38hQlRoYN|9EX~{5gw%0 z4a0h<{A|V8b=-{A9yug78Cg35tIU=B*x}~E<_~O6<3#~`im{cs1aASg&V}REvy(r< zX4~LS?x|S5KtGoDU?T-KDGkMUNbH;LB0IVPj0` zQRVQr@zlQx?ouc1QYU)@sgoC#9xgr{mj;L=Nd~#qCP7 zf-OBvUVJi9;XU>N7W3r;lpn-#G$>ZV^82t>kGsnY#6q&FJglA^HjpR0RCenu3-(yG z6mvt97gvLJUW7~HyNVle2t9&W&RDu#IsR>~dBuj5V52$-|4!u!Dz*8>|Al@Z7vf*1IKhz4By!t5+v-n?kV9}?Ej}dv8W@fj+=c?vlZXcBJIA^cB?y)vh@*THQABgH&SH)lP2!8b zm8>k?fmMiG88e-qSWh-55{#$3uC(gUGK2$Q1p7%hGA7-EMjrX$5iw-C$S~}8$pKkJ zUpzR&u6z+4vY5ZRiS!F0Ks-`he0>_bWpPo#(@~-#F%ZsPq_irp<91ZUmV|6(P#xP` z+>G0Lby4N#HfSGuWq|}G$}Vm+zSx7OkdnC>rb1M3PD1HXO<5y7l-JXqy``t*HmVJx1-`efu7j5WZm8Hv?fwWfuljyK~|x8z3jDA<}FNjh~WUD1VzBB0PLuvCf)0wP~*_EX0+ zTG>HlYDr9XFRn)afV}%r!0^9Pz~Q|VFx;;KPDJj!am0%y^4*q#a<_fAaW;O;9TRq; z)EFz$WFWLqSd2o2%%!Eq!;AmYgv8LA$U7~p_|BSwA}Rizwr_7@r3Le%9>Gaz&;k zGzyRYtPmltVHXuwD9ZKhU-8M(_JR?zu`R@vL*|m}%Oy2ENo~YOGgF)>3F*LRk)0(A zh3SOYQO4$CSfZ9v8x(qlh(%}}tJE0x?1RV(T(U#skZA{W(O#Hs0ZM^L)l|e<){!u4 zJWDB&9ehO{*H+wyz317upHk*lq(2=e!J;8a2s?ww0~1*-!atOjN4rs>@o}^KWRq?; zHgYpqA`59AwNocbcf-gv7=L%-zo-ZP$QYZvRjC!*Q&EVFoUP$b4T?5G=3Arh4BX_){ACjr#^_}Ich{;9AaS{Vr?I5 z(Rx_m^gm7WD^IKtzQWLs+KW&%e%XE{Dpp?V!r;_M{zxrKl1hP%^FOP>W5~2BeV)23E$eG31ryk6PcQ7%f;4=XaiLQ zBc4>L$P7^gt!XG+iESMf_hT>9Dl!W+v}k?sBcVlunIzSgqqQr&vkm{=%9i_0T-HI# zQ?yTqz~_U1nk$dGzYQBS1?|`hGTN=|C+XW)4$zv0e4nRD`blXuDK+J>*A9j$$P62O zPm|gAMQ*}TGfxcpKaG#Rk4b)Vyp$e!vZ}<-TDJJfh|MAo9(2HSq`k@ce(ujf0{Q^gXs0|Y&fm3<$Q5MPD&}swUpNu>lv`cPbJuveWC1-!Nf~4Q&=J!*v1vLgD8SO7`U@nv z7c&~7BZ<%FNWzn43n*}BQW(!p{Xaz&P`%qM80Q-^rnmBugb3`uK7x|Xy zZz8|dpBA9diN^!Zj3WsaW78N1q-Vj9`-Jnjm&t$FzNj2f*5!%S^wy`Uu0 z!}uStDJU#CHpRi>LZo4(EARJ(pZeE%n-*GhOq?es-42qMBr3z)i_Mu+ZB=098ETA! zKiYOB8HNK=8K(Uqr5IVUHLzdUzP8KYkx^rhFxA)7du05H@%2;9;Dq@4g=ks{9Uou+FoV(OQPA?N@G9=YXE&o+`#xeTLLTJ4 zaqTt$R)oct(`LEjRM!dsgXu1Z8!`l%RtO&PEM`AoWiS8;@_?J+coyJUf+ugV3*#x> z6|L!Z(aRA1H(}g?Oyc%ppR2&R{9$XWdUHA{znQmsa+{k3xarBdM2`>E*27-$eVd~i z`OXf@CD6@&EcTb};IAO3Lc;I2bS?=8U;>=zMo7z0N19CQF`x3YFT4%*ZxC!I}I zBn^TuR+^8ng%xQn+IvSc`!6Pf=Q5EG0&nlg`t}#6Pn$OF*k`HZ7ZvY>JmK1?F~AL# zDoK{#qH~a>NNIs4TnT(WkmAx_k;mqkO@IZaMp$g5G+h~=hLbL)2Cj-v!|>YFz}4|- z-NBQQ7trf*;V4to{18Mpg@8_;FA)t)1p)-6JXo7}!*kG4kl=9_KLaUd ziqah+y?PM&ae}Nh2{S(?DtsF&BGovOA^HsL6k}bCEUZ|@znlK;9|a0tKd%GgNL&zp zxpX(~R3_qdlIaIJ(q|&3A9qk-+{kRDlouI3nr9^3=OB;ouR7jE&1B?{{s-^(WOF(c z7E1eY0NUzEi8eu;;3inT51Vaqj&7D1hvR9~bP@yGkg0%(rj=-%65hwZfsrVa7BKn_ zQf|zOT(05V!YasuK(Y)-mCB4a>o3ILYAi$gy8gF!BM zH8na{|3PtaG?>WSw2iG>z{qZ%)Cbo}xU}j`tx4@&s34^V1o;GZVP+g1A%j;9lRhWI z&5n~p-`N}Ge&;>gXtU#R1+pI%*ERwt0cXaw- zR~`^z#i_}}p@f?PAmhZfr-4h7B&o>|0`f?Rv9zDsk^PBsA(H*F7 z$muYx%OB>&i9$|a#o5BFVkeKSfhMSx740cR>suZ6U@BJyzAX=xM?OQ<>Q+!*fd98MLNUDwEA|!2DLdjYo>~f{t5$ci>2*fC3V;e` zdo^PV1lKA@aU4D3m#Wq6C@If`geQW-uaG&?N@}i=k*~Lr4ARy@WM4}Yl2`&a+7#NZIr=VPrd4qC<^)q; z!8S}9BSg+eT+7XsHmNTz<92fxtsk>w_dgx>xf5AR`>bT_^B&j%64z7io%Z?9h|yQ% z8N;&Af>wvQL4I79*Fy;)@YRP+`)qS{<)a(D;o(k>(!uM+&PpfScoR6?aAB`xOp|GL zyWhupUwIn)0RIf@Z0MiyA#KAX^e1SUPl0^64O}j&b^Fvcw}S|$G(3lQ&^}W?zD3X{ z-6aTEQQKm$hOC`x{0I+H%6h+}rArgSy4Xpok^O=K@cXq^)c-l9FgjS8_w31i1Bm zWIH~&(BDU}gf^h<9z!^#B|uvw(Pm~qECTjIU)8z|B6qbe8u$++RO=oN{Dyg9@HNwg ziw6D^FdWnY--Tn4$@Qj_BBiDZLm*QFLj`xxh?Jby5gG^i)wKb>qb1uc zOyb+M2bHkrsb@5KzifCw=)Z70m7Xfyoif}T-Cz7yI8Ut~6w(K8L1Oqs^mV+0;@-im z01}F<{U-14!Gw1{7%g~iR>A;*#T(G~q3tPY`|O|af>s4eAO{bjQkj?xmBP#JVt-6f zqa2*(M-vfopcF0>$Cbn(1_(Kdm!T>uYFsDswlEP(I{}^InUEco4-`aJZsF91al9V` zP1;(-oC#uJW`f+~pQUIF3xXYHaLY7gY%%^RWXeo*k%@>ZGBF-RX-p=3g-lQyuQ|aY z1f`ckzw;@w(Vio=RmeJLRR{epMPIH-2Eu#?~R9Wcg z`7kG2)__ySYK$?NS@&;(dzt4b(dE)j!4bC%~nb3ZLYJ(n~ zkLfoxdJsr8+&qklQ1L;HHUMHaDIX#xPw>+T+RDL&WJF;X^g{qfh$%94E!z_zv5raq zKJWY520+|6U3Dv>H+!$f#hbM^y27~_pKefU%UqGpWVMo@2Lx|r{ zHTpFopuRAOxz{@1Kor}6Hz^P#8s$WBBi;~m==q#jmDrFML zg)CB@Eddr1?NFuk#bSI2ycH#T6K0!=;_TyUP358`Cj4<0$dm^w&67xD$LUX#optDN zi@?E_@b`5g0=lSoBL^xg*Bb!Wiw<1I3e#!%)Cm*~CP@{_%~L!q+Kh3CZxPttCJRNY zVMn-(5n%RZy=0+I%<4FSCu`wrJjwi%c$z%NQMstM;{corwyoM`tOdE`iVH$)XZ)H8 zbb6seUsiuQ3sJnD9HCdWp_P zA{Y-*XMVGIPM39c6LDq6|HOgT^q+WIoIG*UE&O?6#}SUt;_P8u9fuLN-^0W5+jhyS zYRgWU@8-afF%+q#{FtSgp0ZSuW=PfusOWMqWQ^BB+X9wv+Th}cjPZtyp@R8TQ;nCR-CDsIJRI|aZnxd z1`UVDk90kK?0s#Ye<<68`yoB16IkvEPud8}k1-vLIr-rg(GR9foGIiW1oJqQKbP?* zz@JMjV`_QG6guNl!16cMKwrV}F|=MaWGFsEsk;j(nS znZC4v3mQc30vB(Wz9jt^_3}oiXi@$MbQ&v5USO{f6&9+3j}3upKE?{6Vb@*zFiY!n zhc6e72$uIehE4{v5>1D>+y^?1M8XWg?o}a-dBQW{iZIww;j6%jx`KIYXovJ&yRbGg zljAt#DEkzmJ8l^hE60&8q*<{WUdQ*67_3bWtHku#g&@I)7%pv_TU4D%i3N7T$h-^5 z--}ERR-VG~=P&8)ZU6ngl%aB3AgfiCRD&QeUOIC|ktGin6E;A@O_FW-buhtZwMmt| z9$3uxmLxb_im@Y8HLpbZpqjX@0O~l_R~xw%o?UfL_=eU(wtc4Sf`!%?4$O4Lpq`n2m>g&|u0~bZ>@^Dr z#WKgE{|EfdQTpX?Bh1PFfWQBaXhh%BaT3+go4-pkIsRYrH|yODfBodIHDoG=O2q)7 zSPpTCIYw$)S@Kp4`eR(R0EWSr`f!L`<8ztPWiy`rV|K6Qn!|s=U)jFM`QL?sFuc)~ zrVu~ik?uZc_;3eBe#e*`FV?Tbeu(#kSS5!;wz>Y`b4dG$^|JFUTt9QI3Yag18uBI= zrdaR$+OiHvH5~{XN$+>{W6f}IzUue&R`e~;d+m{_BF(=eJIbBoScVBsKyF? zn`W+~$22c5sDVsb91vZOay80v2&_ymDQ!TV%<~&EfCJ6_mOV2%{Z+ ze9PXH!l)1(BWk`?eJa?yqw?PfzdkNgm9ER%&qH5!BP5kBAugnyi^zirILJL+j7>WF&~ zs-Z6BwkIR!^~*r9UuFaeg^Ym&j$T#a$pM@SJmtc1L=5+?fpuoNwt?OrZM!vJDfM+? z;`YFuAY{I&tJi>dcFo!UfPl@#oihW0Yi>tH4qEEJl3!RU7BJ07+wY)$L_mgsR8d~7 zX`*cIpB6p)2Ng~MLoHn+wo29hB_sFt+Iqk5Yp%jRoVLr}7WVCF99+%u1YBFN<~K-A zoJq-NfiwNnbrwm5APJ-}24$lMNmiWpckDP0`zy)rS8kpDrlT(lIekTqit>oU>Y{|k zMG&`j$%$}CFaQU|=5`WmMIBy?K${<8$x@WyA!!7+i{QwN0Jr_Y=H=HWYk2X1UyMyh zE(NsY(l`>0^x-EwfyLwXu@=+C$Sr}tbOP@)Mbg>rwRrI9e#mSMBJ?H@gYi8G15vry z6XS=n7KJY*j+dM`&MWD7%5g_VV)`LV+wQ{(BYH{MxRc4@{(QZ!KT#FUv+(Dgaa$4B zlp%+F$fg`~Whf5MyXfQp^oG&@c~i*mzfpk)v3)+%hJX)pIZbe>N!4lFCeB7*oYvFz)qCW zY@ip52AWOSh^M6%b8g<2YpX%F94A-QZIp!U3S6q6{^kem+I%0kp@rU@^g&0&qwSec8eT*K>i@ zd6XrQ@{ttfiIotKL$}%P$aT_Y+atwlc++i`yx>;EyZI#Ew6PVbD9VIwxl%KrdiG5kOVl$+ieha;Ttoo(}X3F)tn zea0I*e~Lt?e>J)qfzlo6oZ3}b_!G|2_a|@VtyAsV@kuM@Cr5d))j%V*%^bRBU0Nut zsucdTAdJ;HE)4QwoCg(kX_6!B^500Ph^Y(Gjj@O(gpWt>5jDlmy)mn}?V5mBJ z9Y{#WEL!KnLfAEH(k`~mSP?1_!EifDca51s2#l42x1c5j$;vj|1Xj>o=_c!j;GS*i zPS9#eeJN+-SSZRPElMGxSVP9W^=+6LPa0#A&zsjak4LGEmz<{Gl7fyN>wj*CZ?OdO zw=%J&hy2|Jj+*vId{Cpe0%DFWoQupUe>*6WzhX5cf2?q!GS8A3@seqOSbY?^+aVuT zXS(-$d)p_tVTAJoGC5M;1(lDd|Yn#t-c+}8J# z-ysOQ?Q!FJ^CEckFRTD@xO_+^^&rRw8SPVacd{DSOH>602VVn!{eo{3vHWihPjmzt zUWIfyg8KG!4&v8h8DcmaK4I{c6<=VIBKR6z19i=pGH2Xi6m3UPe}*@&go#xi41my2Z#|o)G~d|A>i0>TNs81 zlzsS6g%5tnO%be889tVq)m{O?<~$$8gFa?8!j>q6FL;4skj@qKy&&{yVx}@I2h<#o zk`+mP9UGR_87qbS2rFn-A5?am8r=%ix~O$sRJHJ(L+e`B*!sA})<;L(r=Nd8%yeJvg{?nu`rd{k9&`y$%piI)+Hizx1HZ2HF$gWB$V6n|btX?~4*xGLFtfSwbtKL^!&0iKlBIeb~Q+CT=jk zCA5uv$Awp{Q^b_5s(`Zg6WZhWE_ZOMYuIa*c{XcL0glB0f5by>DqR1h87zpe{|^z2 zYdk{<{sgx7VvuzGf8s5!J%e9d>x|zP8x5SKQLl1zTjU`r>0U2LMK7J{UIwwyh95a; z&Uexr>&|2sIm28quSTaMt!D3+3AU(fMxeeZaJYgI#XSVmKyE$^A-0O2egX_xh(6A` z@Cr<`gcoF@Z$)&@yu>&WWh40^ML*-J2%pdJ}ZD*b|Q{SCiw#o}!C1xq)bKs%=QJ z=D(OK-`r;8g+$xi*M7q)G8Ya=e{UFYV%#b|i^}p0SD>hM>u7S+y8T)+8d10~`H5#Z zZXTZ)7#yF9UP*Kvijr7Y1{hXhovWS5*7vJxw&68pc+^d=W9mHS0*B}X@@y&n9d*-Q z{Vna2Y&14lBD)4uAd$L;^XvKtxVTu|bP9J3d9dtv3wvlC6%Q(E-T%kko5x2{r2peR zlOYTw(xZ+TH0r2P!x}Nss6?U;oqn5D^9@foaEqsCccevb(y= zuDYONP*F*^g4Y_rb5X==WrzoghC?L3_ft=IO;2XB$LIC=eE;}0O#11ko_gx3r=F^= zuC9I_6$PGx5XFsiLAL8N-wP!;E84r>8`*w{!!=ZBC-Uz>J(6+15f%VA->4>DOo^|; zPSN%q>NuzG+57u-1o|3#Y`5Wg3ihe9_B<6VT7a8sivLrqXBDl=4a5gqbeElb51zJ* z5N=W2yy>xQAcCmU6FAxct7)KdyomNxcHo86g}B)Dng6rCaOZJ9)l+=Rp0!g1cRX|u zJ9t_TVXTG)VUS9Mo-kAw(R$nj!2X{to+Lz``q@e!*|b{dAsX+4cI>xw1Z_>OL{Lvb zMNte=@?o*bxZ$5e_M^2O+Hp?8IsN;!1^VY4SC`V4QiG41AcH=(HB|_(}((KKYv?aG-UWPT(3pY$T?tw67-JHop@%Xv>NeD6hicGfYU`ziJ^ zy;Ad2q|3<=fIf3?JW~Lwy6iy!+P;2==_8}N2;R}}!!CqAY+8hi)p)y2^F-gL0Jc%; z2l&8#?=fu$29sp}R$H*(n7`fT58Jen$GqR=2uo9!zKFqO@E%LMWoyn4b9Rv@73}f} zIK>3*fcN|GLrAA3ikv+GY|JXK1V&;hs*y8&Z21JEd}Fw&|neG+LFRBP}a%vJe$h(e%J_3&3z9;B9!L987B z8FAbb_97RypY6i5=@+fNQ-unW2OqcmVmX>~P#w8PbmtNb=!o}*6fxb%IX?HpFvZ^^ z`;8uC)&bBfj);jdpJ*i}7`Q8F8$_b(Uxyp z-a=cx72B3?A)WX?V&bpwXBrEOt)!=%!LS?{aT#q(IzxvsK-2_J4d#Yu(0#)VwZqWH)i$79dk{V0!hBQWD-! zCxKg8ZeJ2s8>TL$dy4VNSUZqq+DP1!c=Ib0y+cGU}OvfrMHnmBt4eLjQy_uG6Ugc#?#dAFQgXEkkzw zqJ^olh&Yb=UYCVURAE%qDF&98uDJ$7Wt;ZxE^OXOI{S64ZP!2hkyoLVoOT2h9|LC` zABLQnKsXTfF(1XD;!X?JIGx^Cfh`LT%)!#T=M2hX!OAC+(=0jk?s5su{lXNQwHb-2 z{@Sz*Qn0J@Bk^!T>VUS=wX-lkT7yL^J$B@~$RKoskb=>=Nr>nsG@>t?z=?FiK_NJaK zJpM)LXE&<9BOG1(9i5TNtBt!MTF7=E%%9dRTp`;l1hRS9;Jb!YfN?^ofKo^WG=nfy z5WoIvbp0vgODa4V{V$kD@AZe682@|Je}rWtl@4zPcu*MBN_9jBOQ(hwbrXr$AgHIK zTB6sZ=HU}jZKB;s&36b7g2Fmr8;5XX6Se_8kRn8mF!>S*jY!x?orowB#I{9I8YvNG zBWeAu2|7hM1gY`WYj^<8;#<-15bzNT2jMh8G{3~~nnnW!Y&?bPhen0TyZlEI=AIi| z{U$i${qC9Q{Hf>^w9eoRHa2eunqCNX?-j3w)Rxust?P@lmfY^6Jan}C=>33OK;&7s z4v>Fq-?m>8{J&UU@gaj+@Rk<%07;#XiTNVQ!`_~Pjl$0peS3i|CYewq#z-d~CxmB{ z7r+Ub8-+6^lamcb7#>a#8X9E;pUlNy-qVIhpTE2ea}$m#&L+XI3S!3@Rg=#o^wEvj z#GrdB_)>T(z}yV0_m+2Q*?y}UNW_pwbIkwBQvsDmCIMy2()bZiJW^(8Gwjj7ATB`cRi%ucxQ*V~M&f-;_8M@Kq(l^GC5JhLcP} zO;~e660NE2!0;ACIB4u6BquS(u6VU^4~TR4eZi7vDI;#WnCt4h&?8>2A~;@Kf{i5) z7KKDPn0ZRHGnKdo%+T!QAB&yLNH=AqGet9IsKPCbsnPEeS;Uk2M$pm1Al=V&R&+_P zcuh{Y;;#BrE%fCQNG@TTHf*EP#hY)9-yQTr-xc<%d)Rrd85FuikQL1wE%8br;f2CA zOhoX|oeEVoB7W0w8WWxifEhkuwZm_fy{RkW!pqw~7$j51>swm)wY^KZb&(^LZ6xnZ zdhfxTl3R(glPNptnLX<5gJ?U0#Y)ii_QDKm}8i=2OfW95|Knai+Wts zsA!0$JG7yuQSi1eC5U+poO#(jCoSIK1CGqlQ|KoTF3sR&CpzLuXX3FB6Fay`i0EOp z-MbY_j-;Xp2MzveHekJk6clkUW_B#*BZfG@ld8S16$61Nl_p+M>)X8E=1&1DJlzfR z(_*kDF4ZM3frD>@c*<29dHu{GiX>_}u;d){yC_FV8act^dg!)`jf?c$9;!n~;M~Ny z^VF8@K|h``(aB$=&$HB)yGP*^%I^yYVp%&69qP(kU`0rHzmsU1-U5HMsi1=lgzr84kDYTyNKk86dtO4*6#a<9?h;uZ^p5V`0UsA=^n%d-#5uNz=X#-Kx1U(bl>pKS$Od z&I1*06HVlwz$gb#WWUEHnqpCY*3R5Sb>*gz^Ia_4DB%ZyZ}xv@)ed8S$+A*G<=W^* zl4t`oSa>ucTl=B{;pb_3H3$AYUdjXozC1w^u3sYhFuB4riVOsGF`e`a;#^?sC z&nP?#gcWOkk8D4*NH`!oLBPkx^}& zLKV%u4|P^vB8L~+;Y0h|y3ZPXG&}++^3EWJPa+b-8~T{hSDRhl28y>lzrh1v(=(N< zA(spps_0jUI$Tj(K7A%Uwj)GAeYuNVVb@nRG*nfJklKnVo;HPj_Rb>z%}9h(>Z)l7 zs%?(qtc*j9<#HF%8Nosf7<}vNy>%4#dg^Vi;S=*ljRK0Ce>Wh&whUNZQRAI8!zBVO z>x}Da;Q`u6S7uIc5Oo<u*!0mRGuFRNXdr zc73IQ4K0e`;Z>fR*_Dc?9;z;f0tB;$8pNSSV~s;xZ}M>seY&{v73CE*RS4r;?`kL> zTcW_lHo0;~<>-=WlnBTHxKVm-)vRfr8gmNCT#Go+W?X&Mt={QqUWC*}g}fCtMg@%e z&YkY5(W8tT{;Q3o>EsXFXbD$cIRyovu<8|vIPFoqv*2-iHe7pCaB7sofzw4x8Vp2S z3gf~Hm-IqabEj9LNUCGGM?u``i{ObJVXo&?xkQSfsi~Sit;Q3Vh?9^pt{x$71EObh zFmb)E6i%F+uIsu)%&+(~*!9}qhH@wj_E?Twv*38VvKGxC z3~HFGuC}VYp-KdjmoeaHR8`f%x4#e_e$N3lpe8b7Jz4;c-etAX&a-fdpyM#9Y11oQ z>^GjG!<&*CD7HAVRd{Q;`I#z;hMU{SF3m|)RfZtoxaF?Osydi74JuW$W_zdAxTeo6 zpH{`=QbF9&s>CpB6Qwc%Qd69I*@;ESb20!=hzIdHAov_m=pX%|gLnzF=?~#aF5;(j zE8Qdu@lf!_k;*snQJGX8(NH;5hM)oOczlf_{+o#JE@Yy$71HMw_)!#5J=$-B5#rYc zv>U&C{L=9=(Nr2V*+5s~M`LUmesQCbS||62hs)8f=~3$){GRSDAI0nbeQdPYp`iZ& zzeX6qN4@7ww|2zlEdo7Fs48JZL&$(oZ#_bK9z{qm7*J=OipHp8(A53B_0uechff+H(dstgz{9 z&^n=Hidfc*PU{j@#Iv2kq#9)LAbaqP}*jUV>ix-?E5MJaKj)T8V;ShoF-Aj3Lznj^jGIS*rpb$A>O`BbO4d`U0a zSY}^$x}v!LOTE-0ZyoZ!lZvqw=eV|mw(oBZ#wi^!ub+&AMzH$$t*`fglw&(rQ7%T` ziCbRYfZ~LG@ocp>jVlV(V<=usWS_4n6k9JY-@*Z{R%>k>ff3DqNgVX>xJE4QBh+VB zqr7$Ks2RPLhkC>S=*Xj*dAy{7dNRb{3*PH4`rqgM6nN+2i%{pqwEv

?CkOZZ1T+bT%9DULphlB^i6W0YEuM}-b+3XZ}ob!Me4tO;^`Pd z$J5)$Brz{IOnfnz&Fx(m#nz5El`crKmc&69!QN?MC@!b$P+=OtmNS30Qt5&Sk$q51LT{xlsEvVBdwk#-I43%&4mTMx&n zoSr`;8DsZIjQhRkFH0C2PqyJnMJTcs`F|XXbxgo<%b(xB$8*4lq~SeLkcIm73*gmw zE#&DB~j@EeT)(~im5tU zK;r>%>TEz`1nzb~XbR*#3o|4r5)k>l;~bkLt_u+7-H29as2vcOQHr}OOK=+?&f5Wq z=?(zm(vAV*(o%6BW4dfW<3zbr0gV^XdO*bj>X3BwXwNxv0deXLfVhmQfY4Nsz6lT- z0?<_$=eR~MO6UL}s2QoY{yZ~qDlR~b%a*vQfJO_td4RZ#cK|Wn>F7a>I}Z?-I~fqC z*2~ldfVjR}CGIUi*9*?8VY{4T8=xBm?w=C+0T7pQ6cFb~g_STa4G`ld0b(xC0GcGY zyatFyO{a1to)b972td?hoXTj4n*fNpECIw^j!5VPtV}SM!GJh5N8;v6+^c}NjO~C} z8^>hoS$LY@)WLwp3JD$s#Qcs*Xv~QQt`rcL``Af}a-+y`6cBTpJY zP2$dxxIanUIzTMndlI)>;u4$&KRY0%yB^R)A;EM&B?4Ll=q3UE6A(-AEg;U3e2Rf{ z0%F`)i7Sz~8i{L?PzVs$<35S|oy7e?Li=UvF$vl5gu;1;17fL00b&WNC2oeqX@IzH zzXQZ|3j?}Y)a?kMDFRBw^9%E%NcUVulf;DpaTzZGVt%g!Vt%wc_}79<9w6pY1c-A? zlek)mdtBn40yJ6V4NKhjfH?2Th^)>0QUEb-C?J+#EFfJ1JfUzsG5~RoY(ShNU*g6} z+#P^!5#=@m;=I3;bWZ?csXmpsFd*iam}-=f1c-5i0kKq90b;2d08J5P+zyDP@&n== ze+E=4Qr82TBA_jRnC?wLEWzn#7`TyunC@mk%;g?HT<)I$>Fo=Mxg?)yKqms?9GQSP zhZ~SCsid1H>4Fk>|5?1A=Tu$;R4yd_yGv1~3MlJrql~L1R0xQr{|%sGK{p@JcmXYv zbn7Lw5fG0XKLV-{bmyIed$WKp1H^eJ0^*VXPC%@UzW^Emx zfVk$z0ab}Io=?NdzJRs@Vwv{>V$S;jvHlKA94%T+6FIU0aSk^imb4NO=dG1=w@KV$ ziCZagk4W6}688!qE_cBB2ET!TxZHCk?m|GU@s$$y2q4be35eVLXFy!@b1yLXr2}HR z(GoXa;_d*%dG7|qd5=ik3F!u|3=r411`zYR2T+aB&|@<7&wyA`=U^j8Dj?2rjl|_k zT!qBdNL(WzmTDy+mg)yU(?w|;er0gp42U^*NZbd2^uBeWL3b`7rmK@Uuf#nKh)Zh& z#HCp?6y-Ofv~vM*&C>xfmthi@2Z&3%PvU+n>0Xq$Hi`R6;=Y!+q>Bs*&H}^|gaFMD z68shrOYjFkT-r|(cN7pyHE4)IcQzo#jg+{t5;p@7*LM*hF6|pYwW746fVed4#YSnf z0qHpaagJLvjlQ)95ciM$fH-fzECX@_;?xpA+d~`MoP9( zqp^Ty38|IqB<@a$`yLSM;J8dp8fI`g z84yd_3}~W|c@-d*^suBmmTPe7bCr?zLgi0g3|AeQ-FN%x9`wgTcDsaG5P z(g3k`hf16q5YsJ?xJE!M^V5JDgv`4DacRr0F`(B0v95LkVlG#>4cs+=7&ikD=gl3? z?-iZOwScMw=b3<5FLwZ9y)2ihf0L=N%GBL}xZKYHag919?jRtq;7mkJXUBpwWW!DIn(@={PZ$Oh8OG zRN~x#bd5_~vBXW8fOk`Z-vU6)#V?^hNoc)qCEN$4X9(Z*iRQ7IwX|H-&x63Vq2IFE!Ll+Zc}(V7?iey`Jf{Ln?rh#~>ZDC@uxgLgF4U8pVyDpb-?*2kW9R#Iz#{b0@BR z;26pEJTPTw>j-8$FwJP+20VBAp{A24N6nB~A^LaUKnPY@0IUj&SaS$~Xp^G4v+hb*dRdZdcZ(m@%|tW9{i?%qU@aF z^L#UgHs-EPH)F^x-QHiBF^>XMoMFbSpT)y221{8r)QmX=7#HS35k3@vr5SUM2E-WuWj2r%^aKSD!e)q$~Qnytj=S~KQDV9KsDW4;51mNg=rZD2{?K}0yG0HjYM zBA6inM?_)rfT2$yA~ZJv^x^Il;XDf%`YIqovjiZ0Ai$U*wD(eIfO0__mTPe5d6z(W z3=!K(`4Wv3cib2hA_z_zBr81&xpZX z5QQnl2FZ##njO$#>VlWLcn5G!a${5TOF_`CKFs(6|zsF!cioxuU!5ogkBx0_? zhf#ND3}$c)CMOD0ijNJjCA|lqkx?|1I4K6x5Q7OuVaN^}s*F*=knoWx8sfYm2Gbse z*@Y|a^J(+v&sT<2)s$A#mUg8SbCXiqAYO`D3wAe`V%KwNgLi8D1aDn@eEFPd@e}IG z@jXCk7VSYUt(!its`g)z&GgoKruQV(yLhSiaD#K}s3G{IqQQfW>vcmed|%rCq^k)2ckBUTp3zy)>&Q;*tnL5SXq-j;za> zK&TmCl$fr>X7th;=)bC-(If*AMy^<*$Te>#7Y)Z-*h|F+B4z|Wo+#i921UWR{3yh< z;dq=kXK5HQsw4_gQ8eM&C`7}Akt3oI)ARC*qY&a74l`5wA|;A~K0b*;&<83}h`OR1 z8=?@i3k#zWb$P?bMo~2MM0iGB8(n=*!DLTVmiZ+;5Yu}i^v?x27d}#{n87wxI!ksN z7~9n8v#O}eD5aIt8}RkcZKX5I8)gi-^s<~wVFlEe$5W zxSdr{)+@~R66uyKiZG&4`NK;}#T{H^*849RZYd?1DA{;eMC$61axTxhJd+6puEA4Y z?-_FG?4r(q67tiY=Qs^iqOm6e%*!vo+~vy3x%AQ;fiLSn*1{8^-@1843(p`H^YaJI zDLT$0EWYl*vmqVd;OA0`%goOpA|cKnx02aveh!I4B2Ye}Gd+tCvJ9fVbAEIVw^HW5 zI6E5W#AP;~cFhOMbzhvN3#=#57Z^pLI}PHtse@Fv60KjoS{*rGq=iBtr zbf_?0P5)4JZo^lu$@I9V4kXu2^yRxcn0(|7h9iT0z{BGN0zdl4)l(QF={SPrk)E4L z-h9Yg3>PaUEN{LpFVryECb=#}FCC+92;(p;bytk!dM22JS=BVM(=VDZ-uzhJ!2kd?Bb35p$exp^_MA|b2CLmf_HfwRDS&Jgg>IV1$<(!g6HnNvNvJsL4ShA4=43do;W>8qeRKSo( zwnC)sTzV@^k!g|EOV`sPEu`~-6&Wqdabrnc5uQfNX2#*^)_HP(56TzeS!8PUXpY4_ zY%d~Xipln1DFYU7A?*rdL4QNA+;zCb(DxPEw+tPZJT!}zr3R`M{k;z8Oc+iLjDh;Q z2iMf0=i%(ac>&H-w8k_aIKiA~s31!r#xM+AaVzVFKxo4d2sRsnS-2LYDKuV@ODGq{ zD;j3fQH3P`7AHmv;rRvw?e|n1jW8y62oN+4E}~q5GE9tgPal#WS}2`rIumK6apDgS zqCrqbU%d?Q|LMQsZ+J>wfPrfYJYRd@t`n{>F2pUAoQ$7~v${Ud35T}TaIL8>O9g_& zAQ5q9Cr~u}cNExm9@+v}$8N!RmIWKS(m$)%EX_*Roduhl(6Ie-F)asP|&1 z&e^Bl+h&J5%xZskfAxX3Msh^j_#()(wtnBk*@N2j6kY7df_uFLIQBz&8{Au_+pdO# zKXtHesK4EjQwzVQU+28;nX0bO9apX87KLuJJ zUKY8u;qv^*WglFgN|*k&M8pRIgN3Mo6P%qz{xNpA^~ewg3eVhd&$x;hce1phDHK6y-T_#UD)ZSz_6x<^ltuYk7h+sbyPo3>&x95Az0dmQQRPvpM2wI&4gS1K;E%m! z2Tt(CMgCUl-VDGEAQ{t(T%0+WnA$RN5F#IXCUtGHdb79Xond*AM$#A1po;%9o2O4; z%o*DDu8Nf0zJa_m=bU4BMBJw3C9~+rlkg&~aK1omyPb$>)~c@A#y&(kKO~NVStmRZ z!6zoFZ^sQ`F#6wlG|yRFWT&-dt(kfs5Du-G?wo*}f##P19o#JE3vAE1(A*Sgkj95% zsH+6DlhMbhS5~5*r6H{rrb)N^v1v}aXCS3U`vhs^MW>E*pf+BCYQiyYK$j%xl4U4KkY(w#c8-eG09M==!|~&t%E!}~16>}bN@g$@@(UUnht$T8kVcN~k1yJZ!ZIigXNOTJ>gYs$7Sn`* zeaHZlfmBq_4lo&Kn-CA4B8Bg@6sW`%X!-&f;9m2-cW?$KEztBOLFkCueROX!3JA@! z0O=4O*z}5`yrz#p!lMNWNeyK@PmK&BI~T1NNg2sEn4VE<2PD;wSJr64-)BvACkQF|FU zv!^g)Jg>!gjyXAWMPvHdrf=Yzuo$Xvs*Ut`L}U9g5>tewhM5u$F0HevDBYR9=pQL+ zqYF6S)fcg&d@{TUf!av#X{bwdl01`1KNPvs82x`0|Eju&og>RnRjSC~_|mK7% zEoO6ffjv$uar*Gv-TPI)6J>l7R{de*!)(My>F_NHSB^BLOGXj&xj*@HbVC8Sw4a1a zS#v#$K_=5#1(-h2qk!&a@R2khvXT+hQDJwbHPR(Ux^gZ%fJ?(P91u(UDR@0xP})LE zx{n_}erV^}9p}N*h0hZfo)rJ$12;8)Q|NlDn!jIZ^?#f&_$RgTFW`mF>w*D13Q&vy z(zFl(hj2d!Pxfz)VY^>zYYRJcwr!y?VEZB1?oJr|Gl%H|TQ}I=LM%*^kET|&aWrsx zg=jv|(wIh-2`nb-(p6+0i;TKs>?E6Dqa~e&8Z0y*NmJtnp%jVI)rPFX;^y?UI21>E zrLn~ zkM&?&4j5NG@u0hw$!3MY{SR#RN@kl0wigrI9yWVAaJYYZgu$X3y0wxbOt(##yqQ*q%%oE2vrwH>D^G(t=8AY^VGJ)=STck(Xu9o#IRccJ|> zH01x<^Yeee5271lLrk$WNnYjSKbS{(KBec4V%SUxY-KW}p3>BX3YWopDm}kOjPD!a zQS|zzofscI<1ltLC8EvX!Ez8LG&D2jn3%Y~hw{YggNC5mC2716BgP65WSdO^+|$4t z3%}kZ@H6I_)&4Q{DVSd&UxsKq@IW9fn)c(ztk4$e$eJN0c4=zkDrlUZ5A<15q)5}K z$3P_z{t)Kk#b9}v7STr(oFUu zs;pNL&mkf(2kM9PlC_i$1^1YAr%@hc7o`#1N1*F`Pk%7z(LQ)uM%$FoQ{1mWMpM>v za29Qa8x(Dm13Z~-Ed2?7z=wJSm(l%ua0db=Pf=G`2)`@tQH|xa zv=dxP)d>ELND%H|qz(4|Zcv3WxUfV47v}1+3Xnk_Av3g03|w?8uchoGF)8QAOcP0Z zaAXRhDR`y{oiXE^)Zj?F#zw{!>YKnsoaMUgAWRcElk*0j65z==YY_JR~T8MISFROeEoZ_=4$X z;R2rbd+;wb@khmkgxnX`iMLl!=@hsp?p|csvG_=WWj^BZ81*Rapte4M^Wqhv$=p;cc-jx$X!n19m_pQa2AlP6jO8$T zi$gbL7YP7ZUpTb`Oascck3u0}IPBvmU)Ye=Rz{W7Z=IbdG@B0!gDVz9U}p|k{Y2c9 z#^Z)GrpxWMV!ZJpBGpY+f2YOwbJE}} zkIAGntwGw&Q!3qTFV=V z1y6_m6z!t9PO8~{d`GR`b>L|QPb`t%V9V*aV;D)giqxS?+DRd&hKies7#(?J4Br5| zLv&Pa#z4$7w}#(QS8 z)nv5U6!btl!e!W+x)d00Yr1ms5CD*7_84ZV z$%ays$#l-ZHpV;_hlG;peol$MBTgZkFO=$U4km8HwrDg?OQ8cHr(G~Amw#`P_sp&l zULS6Gpd@`&Qr&g0;D>gcy&VC{K0LcEr_K9AAkTqD!*G<|o@Xbq+VeyY_6z9|u*~V- z=0ub+?|nu+^*T_+gjjk#(9jdm(4xMvEsQdR?0LzZPk;f*M8Q6yn5ZoyJdj;&x&^Hq zF2JAaW~P;Qs};y23k^?YYnZIJaLFmmF>2z~qdj@P4$;w)w5pztmUN@#a+`L~8#?S! zYOy;qp~MUb;<+Svzfg7Z!=dCmwM~cqarUO14$lBuPtvb8L4m^^{>b|>y>3rQIl(HF z{4g^@JQxu_#=rN7zts+&otvN(8$=j@BJKXYeY7R?#I-rAb+bNf80({m42YhW4~dH) z`B>NuEqP-VU2PnO>We8*Hvz}tNPZUp8kt9u#n4>ng~EP*C{^5}AimS-! zs=BNac_56FdfDrgA0s?{b^@zMSSq#APIJ&CG#N=r*8tSD4zzVi7e^VDoS8GYq}e`y#RVEwMrW0h_GdmTlT58b5vb z0LpVp&L)ficCEkKQe+E^w)r>pK_ESUYoDA0-aU9+sSuSE)k76hF>iEezojaB&cWD0 zJ0$4VPg5_p9a4#StR{sRLoL++^ACD4frUjftzZHz)fXt?Yw1GIl+#R^JoMz0nzbAD zD_4nw%P56L08~T?*K;OE)^3R^1qv7WX;>E(0-;sSqY>fSeIz&?xN^v>*%1+(T5}0V z)W#9Oy-J@8Y)}$W;7L5*<-ZBrGjqjA(NhC>mjUK@F+}4ly$G>w4Bk!B15NW3e#fAz zD|`g+14!({U>wfZ1t@uS#&kl&A* z^aU-^lO=0zrLHeMy+3R5L4oC(hBiWMG7{3ap8iN|It|4%#=I6BG0)rYyzcH5-P(wG zn@^w*+z99~K2kYZtxY>AkNRjUqS!5=hqukfoRl^!yGGP{t6VoK5qL7gBeCspmXW|0 zdddX&4%agfsADJ9Ooyjz9nTjg`kNGEbD!8pO% zHaW*{m@&PsuBsBciRXo#yx@x*Vxu5C{+4{P8?lF@d08fVlNV0(X=`-ES-qr)M!VRD zeXlYwwYMIw>8q$6dy`erk!O2+ZS*f`g!lZ0|A2-(?1PL|NgFWX-W`tfqcH3zKMJLL z#lKcWCotTclfJ9V5xt<&HMa&Q3T8ka?uGw&u#UskrAJnXPSV}+_e?WdTHhRN2&AJ~ zZ(I@DCJ&wShY6+_3Gs9WH|>Tee$GbD>U(K}p0vm)zC4wl-y^>K#rI%*X_jMlWtD4s zLv&P&NTw@|1l?JDFY-2c5RF2_4Nyi=WC~L7biEBdh_&GoQ6*3Z5uSo=n;g_5ro=_F zt1qfApEV8rrFir!78tv-r)H+v{G04PG#^mejz-h=*#Kv&3M_zn5!j@A~FhLP}-^HgQVzamSM#NOuf8*Jo z=2^7RgK3EZ7bD`x#@|f*^6~pKVa%Sg-Dcm|@TwYu?{M9{IpwRt???RTkvJ+}agTid zNWKz~uEK96Zj#6Gi|Y+EZ$PspAv?b7OY4iVesaNv_|lU;dEBQ3-ne|>8Pt++OFX{$ zN!I(~@}+tfL(a!BM;Qe;s-CWiCjZ}sNmC=$Bu76=0Qr7Iz8hom!R@`&g-t7&%dt;7c<|n$AA(uj+q6y!sDMnh}R@fzCGt zwy^~hxsQ977ZDYd_yXS&hcN^uJ=B5k<51Fq-uc!gY>X#wVbY{HY)M|y`F8M4J2|5B zTHrnct`a!1$+$M22e;Y7<1+2VNx0P;mm2IzhOrnd);W2Mz@@P3GT^=d?!WC1^xby$ zDeQwL%Km!vqZyITA;y>vq6J$7XzE(uR$OWD}`)>iwh~9OPX?-hB^&kh;kD^UG&rp=# z_nzNf5hweIq=XydSuoiu-3Q2b%9b+~rLA|q#qoWHTR)Fe99r&)*d{_b8Tjo*Su0)e z*#J1&j;zrG8Is9{9T@Y{&Q_E`M2~~|Q5tah!2PNBKI@KutAJ?p<46qe;PD*b8+~~t z%KPzLeD5P9U~kjp+25JQo@IN~V}hv*2tUj3fYt-rICU5)~_2CP$>w{hV=UO5FJpccsLQkT|+qab8-a;k>gX zZjQv=DRK8m99abC{hP$m9f@(J7=O7Q^!|rsrX@Qr!vTotQY0=z;wX9w(-lcvvBc4m zGv}?9IG@A?B<>N3dtBmLB<@v-qfwLjeIRlBC9bBAq5B{puE#DwG%s{2^dTNgdLkg^ zaw#BAeFV@jLH86O8kL;N)ao&7DoVOGZbG{uA%lE2;wo7QIgvdt_)9nM4CpiBo zamOUij`<1Gkq;rJn+Ax>4FGbBysIRxP2xHMu~hvq8)2Er&o|>Pm$-63`GU(_KwMf- zLiYmVavzqsKT6z_68D_M4TMjk0>N*%gf;TQ7ZP-a*Z+oF>bWP%>$GPeu;_?5KI4{#I2IJ7XWdMcFNR$$kcrjcK{IA=$ORW zFneR10}z*%B5}W$xX%D_FZ%(|NKwlxF%&ayG$6*2mvXLAGa%;oxP+bp#HF2#85GUf zoJxg+z5z5^;C=zbqriCs4J#fBh&5COh|8#zxH~28Pk>mecL1>jdjX9RoPU%!=c$I) zQUNjDD}b1DSVFhrrosJarG%c8P=|zm26U|`ovM0%DEN2E_cxYd5DpDWOx(GRhqW zi0PIAV!9Q8xNe^SVhL<6qqNfjFx3-hC9VVz>u;vS9g@&7KrG*Ya|}O}&45^f zuOxKJxkee)5^9jpJ%Cud8v(Hn-ju21(~MSF3uvN3*8UD4mU+K~ew5HLKzV}hOWggg z5KsZ`Y7DK#z3eK1TY-_EAwR}bhMq>hWats}GOqb~vL7v!kPVhSR&b%%S)Aixvf52ZIMu_)kvimXw11*LR%!1 znqZ`QB=n|)_DYCmGR%c$G7QmNg`syOof_eAn@PyuC|4h$;duqg0~1Wm^~E&$Sv zpP&&0!|?Y&6oxFf8TlhL<%EH*BbWwYRzX`4%ramOL}Bg&rWiVl(EJgYz0gSn^9*57 z(+FlGFfPo_BAB-bgIP-i^D!{3=m`-_CoroVW=uEbLLZ6HoPau&MPX=b{95#$2o3GW z*&Btq0+>wnrU=bMV49;aD28_~`l7Qe3bP9sUle9PFl!~o?0Ex~ffv2)Nc)BamxtNw z1~P+2CP~2Taf9j|m&W96L+HnHJv0@2B(dU@K7tP>b#ab?It?*Mu#lgP^JA!7It}!u zkleTj#9)3MgQ3Vtd>FZw#$Z;(VAjN7T4OM8MPcH5Zu>ZzCdLE}gc?@P%4Ca{_%$67oJ?}=>;@SX_gN6|C~ zqiFiUuzL4MM?Q99XMy3hu7!AGZ0Y-+~gZ?iieM-ieTvdP|rLOhiJq(+LchW zZ>HW{2~obDUW3FNCMmB-?NNtlH$@S@PlDSB!zY`#l0KA-t5Q)B#6K6Bh}19Qn2jju zjjrLV$heNs_V8;Y9kz)wq#q`_>hXS4)+!2LYP=cc66&hz5#_yfCcHOQSCxCb^@iIi zVi@OzrNU0u8cIF0OZkmE9HI@)8XA#T_(-Av>bg6&YLnk6_**l1Y%;yGEai8TrQ)5X z6kLC~8R0G1>T&5Mm3SFiT2T&9QE=uqFG9@;x&y1I6tnLzvp~X|7Pf1^qnUWGjB{nx zynoRRdN}9$cmBKJ1&o}f&1M;UWUiW3SvMPA=X8NgX4r$!eT#OL z7I9_Pqk^OI@|XpA;W7ziZZ;-}@e&8?6Mo~$>+8#JGt-#iQd4S-qc5RS-5kX`dGg~W ze0~|8y#AdZugk8`-FUeoe!P6RL8pu1Hr9_-jC5csiF@(?y&o^S_in-5 z)_k~o@#96_)6IuFo*yqvA07nV-}HK5QmPQ0zRwKbzAdoOK0f`rpYH|Qee3X84{k=1 z1Do2`iRp=+?&S2obCZy2+vd9w#Mt^K^E-_6zKe?%(EQHu`$hR_FB2yf|>RyV&^0KC2RG# z@HvIglUl6>%8-*}@nP5BQHv*IaoM~@*z$OAv)U4vgtW%jJlVb@R_~b+qHVq@NU(X| zSzI&^*%T^|HZBeYO#2GMI4gQZ=k#N0Yv*r?gi<7ld0(ISjs$xQv4!z6+P>(?hDOrx zbpy#4%v<1l(+95|=@u<-f#;gV6+*_YEk2K(+L*B7;}W&SFJ#6Z%UrA1g?!umLRM3D zZ`aVvyH>(xu z@43$qS<$wfZtpdn?9D~?GLeh{Op|@{?TYtoxQ%OiE#$O&9D1{MIpD`6r^9>bX5Lq+ zt{-i$UVOx6_gp|Hhxe=CP57qDvsc?BzKiNQscVA8zsaWU7~Gcg#@qupZx$>)tyw!c z-RbaevgYiV+jaA1+J}4t2|!=-IDGT_IXns2aH_V{_gB|kf=$ssWbIU2Qs5NA-)hAc zVzguXgU{_Mv^^kd9nAr38!NWT&XV zY?f=D&=cd1+z|ahP==Q{%{d2C>j%#5U zCS0#r{B3ssw!}c;QMG0GkwD?kI2{cX9>eM9K;bVq9Sam5$LW`x*8_#!bKg4jE(v1U z-?l#?R5BqUlsjpgJ1H~#3JR2^w{q!f(=?b1ZKcKr@Fv>S8=7GY-EM^h*@gsMKOu+B zzs(v|Ryb0YHMC%o6$LrMe+2JlY%Na3S42%)a3OdmfM<@uv%1;fm%vr{h1nkGDtu;U ziz-;&2jdjqJbU6ccmD+M_-$^xwR03UjHfnz;~f*4VGZ4G0sFxQd)U9=Z-u81=6Jy1 zxMP24!KoIovxA)t>@1%A!JlaJZ2VEu42$+j=Q`vEQ|*)RkF>YC1y#T`Qo=*2bLrQV zK0&5KB&D;3GQLa;GA4UfTSnWv+N>T&@DdE3usyrS?mO!641sOJKs;5xBZ<|`-tS?@ z-;f>Kg&o6!CLf0p2PPjQJMP>`q`v{FcY9M8it)5XXzidq7AS&66degnK8&kh0!6N8e?!&dVVb@GyBU{RJB{{d zxe|4`P}a|Z$uLRkYUpr3Q(57`Qa{&=n*ntS_-sL^fFalSQ`d{H&$aK>_22E{ibRS7hd6dYj-Zb*Xx9{NyS(_j0+a@hZAUvy2i@z2oaoXfNy&_z8rLVMn{oc0D+ zFi6{?(JOOaUuf6vr3-C`f1f4iuy;R=7os`Q#l2lQ?e)-a=eO{x)#BK76!)k8?S7)i ze{x!a9A9*HfajaR=Lp@INcnYY?Op$uYR*p!Ptcy!%hSHyb+qlME$0VW?0d}Qt4oYLubiuAr}%M$Xofi3p(F!pa^^KLEnRf^q_yzP{Bgww7^?1*)V z9kH%yn0C_6**dRB?)&6?v@H~qO?X4EpN^0S*l-NL!7k5jbyX-?p{D|UE2gWw8r!US z*D8B#Ca<&8XO>T^av=vv!_QcC@O50p&lAL=_ru}JbQhP^`I=X)ZSB~5z;fc*S;Ma@ zzjg85zkjA}$EV+0Pdew45fi4?FS+Lr&u-fJ*$)XPpL=QE#EJ(0y?=ae^RCYi+MH?G z`6ZQ}#+8q++w#sAKlVB0yvqu%uktqC_r&vC-~IBZ#DV8uUU)IGMfoHT9jvIqXWzWx2L4%t)EhZaq)nHP9)^$XiS*mtdMhK{bv51zy0e=um5BJ(WKKa95&|W8Mg-?esaSbyE}hQPR+<2JEeBPU5`BV z@|z!hee8rYF1qU4U(dWF^t-2DdF$hEei?A)kgLbtGHc=TNB{Qf-}iibTs`aJYsQz( zUbNz|H5=dlG3)Nhpb+MpXB`f%{{zl3vcd-2E#*M{CY{L+T!4)z_nto_tU54?ZD zv_F4!#oYCWlEwtzIQ`~_cV9T;$u4_S$Xr`@z#b^tp1!(fU&@1%KN$MLyu-G}{4HsZSAOAKS@KTyI?s>Eca42BzP}> z@28D=ZSY^FhX*}$4rK_p;}`Kb;V|_N|Map83rgzx(ya zSG{t_FA4s<&FB8H;`5X5ow)1L=Nb+s1;@N`;gd5uPk;F4-NQEA{&U}DBik?d^R%x{ zePGi2SFE3VNL?}h?TgpU{_d>DNAqlW2M`B6&Sc_;g?PD#hj97$(fcPX zh>L@8lkqFT4~y;MARN7!^5B;yFnHp@*@xfb_??3v9fVtn-#hvlC&h)|YWzGHk7x!Y z_sUt_a62mIDy)$%A{(;hM^QJ0bT z`5YrUEQ!y?naeGVF4sCQZW%6+4~4As=yf$e=-N^DCM?MVBqDnWynJK~`B zr~|GMIC>_ggK(tx$AKFtFla-_b2i{ag&w>Z3QOpFKr}sbDua-ZQ_lv(xC-czakol{ z_J1?31f?)UpJj3mY9WShLMlTp@W(44l#wl=A_+~AP@RMtCG?<#o{~_9gual_VF@Ke z0=+Z|RZ56= z%8bGk;Ho$ZGYMC9QJ896t%|}d!Bs~T<{n(tq27_Qo&Y8j^@?C#1cttnj9}iTTu~U( zyDtiJ5EuoP5y=HmaYtcJ1f~^aHYUa2a|wfA1Vh%^3eFKs0Whng_}mQ4TJ*?BSf_y; zF%Aoq{6qUX>3~A${T!~0@j;-)pJbf|T2ida>A3ngZ)K*{^IE5PK`^&mU$3RBy7Gz{ za-r8iG(?d!)J(6|S8Itt20+RG9oB0s49%8p6#ulT31IGdRz<7+}Y8H*|Vym5j2M;j#&4u!)pqB z3uOd80(PpQK)}32u75KKf$%oK{DMThkC5>ocq%U5ONd}Z^bRDFSm)8(h0-d#_4QSV zRYU=3%z-V;X(E)1p4fYnN0!KGoqF!{*~Th0;z|6wcoUc9T<#J_WS#n3*m8=nyV!MV z7c83AsVD39-XCTwJ0Y|_5vZC;->Xy8h%ZO6L51px*qW+)`9ME(7mkJgL)|O zGk^aLUu>RpgL!4-MUa*%QEggmrB%E%P5+o29t0A_cifwa0tE8QZGQX&tqqT|$w7CS zT&Kl@r(9>z{r$Lt#gpmDlvZ84KOxt%L zQaycgT~J>?yI#q|YZezia29 zkPCk)hg0mVW2j8x8YM(CG)|2>E26QZ0wkv6KbaL}fu1ZXa{tc9Rb3Q@w7n_{Q;Mrr ziHW^`pN!hk_!2q(@9y6;zQi84>ZpHp|6ZWe@cnxou82Bvlvazbp(Bi0<5EdLn9}O% zT5m&54;r!uK8WT~fW6-WDyyo?5t*-4lw}ItWZ;>3vqHQ#c}UD`Grhl{1x}79`_x0U)(!E=N1peJk}5$y?@a*`@c?w^9*?2 zxfeWw!b7(9zV`QR{u6PlQnvXWI9V{F4{R4{R1n=&G~@l5pFU~jbb?~jX_G6b6Vx-^ z-);4r@9*Z|1anU6c}FAHfb9IN8h*vp<@9uhd!sBqYo{i}>a=4$RzTZqj&8gTz}otE zq1?-b-%VXq9oB@z`$&*rkVF>Fz2HxuVr1a;s^%v-5h25mAQy+Vw*YBx_xr_vJPDyP zwEc~*tBp$_1-%^W*Cv8xG|(m9^=aSh0W;L}K6^0;gK;v&%@}OEGAeFHGU8_Z9d3B= zN^32o*oZL<3oZDAs28J+NE*l0<@bzH`HipHTG2ngc{-s_^Kg}cxDNtb?_E4@eq z{j2n+TI;`&&ad!Ara5K4RU}nwHC8=&v`wT}Yjrj~_k4&`gCE|BYISz;YJ`o^YFGrR zJnJ>H_Hv=Uj3SBv^1b(~a0!;)$)0FDH_X*^t@%m(eMnTeCYq>0IEUU1(DVoW<5kkd z#Km9Vh1Lw#I2O-KA%t33N0E<8w0-`)39!cWP@RR~v;Bw9R#&#dr&%_lZ-By0Sn}mG z8D9Ls0;NyJiO$Bfr-;hObv|TKHn{OeyfV-}485G@!_~nj2|%IR8_%?A9~^uVv%7To z+-!UnqXgQ=tsU@xY4h*3pp@KD{^iHvE-q7h7w;zXKLBYFoc@drrCx(mZRn9SGF%v5 zn&q&C>LGjoLzs4vM;F zQ`_NW%l5Xz_CSKV{(9?wlOd0MT}}S4%F&KcNqNWNFU!9<0kJAFES@wMerXs4($(d( zst2Z-&~?)}FbV&0coWT<@e9%kS5xTD1ck~x^*+M9# zddEI>eQO_|Z_%QM4lPK_4vfuR1g6DMuXY6E+0cb^!LAJ3DzX=e+N<~Hr!}a{o`ZP8 zjsgituM|l+B{0in@59bGMd++XNCNL;NScDAmr&F0z{KO>FY%hzcchyNRGY}Rx+oF` zLUS%a1kL!Hm8CKw7RW#AkJdlw;E4A@zK#S3~3$cw~UAh)3mYt$)zY0TGfY*kU zTV20W^d+F?L4XCKkEv^LMVPkQw0ZOdInUD3w$C2k2j6HkzHw<)l$MRsvZ=IeE-isdYat=w^uIw-n;rrpYbOn1E29d01|*1e@tJ+_Caq)f zXJVAtN0r22>ZAM^A<&@NMqS(XC0jPN?YD=or4mpdo&TA{U#M@8iT|9U{|(i(qmk4# zaI6^`;cna4xAR%jadD{F-L}7PxDbYKN(^s>X3f{6Y3QXyAJBu;_Vmatg89VQQg{tj zODIl%UySLR|7&srDcst^GW%n(AhD~^Yx5v9nG3eISl46Chb(}&cI%xd0%)ecYpt~|RYDLe~piS$a~sMkctt=lBmNc+Nm^{rs=e3#$ZdHVG0xmZP%;^U0C$G3uEv zbTX1XxC@QwPO#0?0kS`#NTvw+=>Z)%ZDM{Aw$qr1=C-*AtqapGng<9aTn5t+>5Zmz zl;61|2zT|Sc7PtM{kPXEsnNm*FNYL%c@Y6~0 zi)bRD`#ru7c1O*H_FM(U_-?203q#Q$Xs?{Ek%-FHw2sYbkh*^2KvdEZ@~@(DummKU zo_!<3QNB@sV&_tup2ou0YPZ_t$GK|@tfv(GySBgpGyx##BLJ&?@ZK*-U@@5jaA7Z@ z|1ipckMCb)b#b@A%x9Yg9)T15KT_$Y@`gP}vVG{1n z!eEh|ypaZrQgCtvi<~rH54y!&K-7aKaQbo>=WVy;KsnvPCy6a>l=}9L;u*)`iZUnY z@E=tcJ?**Kf3(~CrO~m2#n^@>B4-g>Xan8^g~>7XGC>$*99A zl%qNLoa}G+=e(!-E5TO#zVk%tbK69p19Ci&U4;%S;ug_kT5g)?0Nn2i(eGT;?@kx} zZX@@*0a5+#S>f4NZTurl3>r%g7TR@2)Fgsg6#WtkohVu>&tWzJm|S=a8VlP=Uq-D2 zEB^}&*@J#sGwDH2hS)fljNiYP=~9FKj~K#W>Hm^JjFB0&!cBn)AOI%Pf4eC>ys1A(lPlr!E9>c|;@iW`Tmnm`2XcZBv*W zE`YUU?G)a7!h3#Zn$;#6^L}gG(6L|IYoqS;coqp z#(;54<>EPe_ z2SV;LWis9W$o4QG+pzE2S-rTewr{nDzBt-}^@Bi>H8?ssP?QiHja^GN?6VFO^$DI7 zC{B!hkCKMR2p5SBUKCm;IRx0aZ>Z~woT0mGu>yzPp9m#%a_Bldm{^0w$$^OpxIF|W z+A#AAOzacH6QXz(vsuQm!)%Y9CUQ}Q6x4v~=hV;QJ|Gl_CrrI;ntam@CetXJ9kt(w zEZF3)C@!Vl*Gln=J!%m-y+n5;!)(|?8MoPvjgW`oawpZ|2OqD z#^(;>Q4P*fpb?Fm0p&39*8-Uc7 zd#B(O4AMRstYy)?kG_Ekl%$+p7$X{OTQHc0OEeS*xk3ZN z-ZkBczb>NMNc|C|kX*i_ebi-}agFah=mB8`Kzd-=AV^TamHwMRrZzo{zgPN81-t@( zInI|Y1P|z*6MP%UYXWYuHzNg)fhm}=J_ZgLGUZBf(7zpt7;q4^R}?MgPC~oTAwBtb zcVMzM43RC=CYoFuBa5K(Q@yA#3_h42p@#Z>5Vi@P)ikW23J|@Kf&d6gQ{mxEAVoyp zHjc;}-bsV2*i%hURTGhH7B)!55q<-FlS3eHqO=8`yA)8&G~CM0W@fTJwqpF(=ba0Xh=xcsitev58HcgaEcx$3ikfCiGfpZLhZ0dV6iF z#a?Ydv6=`b;FE_H5FhxcW{C2%JeB;vZ|`&VoOy)Wd++c5qs&=n?bq6Cuf6v3tR)jS{nK6vev6L&&u@R@)l9s?ISTFUEW+ zb^j=c^^XhCKiudRg=YWwuC}}b>3i=Vo>cvV=Ly#SF$eEP{}=&~{eyzeUD@xN{evbF z%>MBR;8_1~Tlz;GLeM`7&_AvLXcf6{(?4XhaN)CGTX7GXJ%ARnhwP5 zxE8VSb3M@AXW)E>%Ey%FKLKeD<=OW}bP-UpJxob{&XnY*qc%Uxc$Hjk41gGjP zWZOUOEnF@B?WuVAy7 zgTY-4mFt7l@_y>^U`2<}-0(eaXu9w-#*iRaY1qz-+{ht8sZf((Y(S|YVR;*Jk?qma zA~LiL1=InisMDT^DeB(1p@2Dvp};#sEFjf+<+m6Hq%U~YYsEKAwb)aE`nQ}tMr(zV z=0`3qZA*S>4eGuh`crn<;3&kh2q7~WnPLplTCy0?ATuCHF!XJF^ypB;6XT7gKlwVM zlOR}T7g{Tu)3IoE^fI7jd&YI7pGCi;;%E3mMiIhM(bSN2qsgTJQ&W1U_?n z&jz;0fuB)alNF$X?1dgYut!_vN~^|RKV74^;k*z@uo@|)asV}>O4_x+XUHs!lQrN9 zpzl0Ln-3J0pyD8BhyE@%uHS8bSsdc*$qD5a2lm);j)RPH7M~t>j&lN{pO1`k0!Nqe zyyl#%xW5ks_wjPIF^sB8h`nsa(6h9}D2z(3qZ^Ls6FZvq<{T!R`&EmuOHtY@kWcz2X!jt;`=Ff~xbggx*Aa?ahZ4GxmaL%+Z%YL$b zudDmlfmfV?b_dS9+}etBQ6T7;6)xjWF&7gfb!>n&VNEX4d4b(0?O-IRDuoQZ3pNHe zOk7J=i=z&($fK>E$EDCH`zzR<{)qM0<@c>6-Axm~yCR%z3jKmFBjNt+B$iv|w*Pix z+kc;?wXPtU7)P<)e+@xy_w)FoBpMpsPbx4YR_P`DeA^r2ssZ zV%{dj9MR7@4DI3xFU*pn4#7=3ydKWRW>LC7aig>3d2=D$`HslV4zMK;@+o9Ie7(!Q zRa?Co@|}l|AjkEffKn;u1Cf@Zyv~WLu;(GoNY)Cc$PV1Kn7kfwhl4VA2^Rr@-ysN5 z#1d5OFC!=ya>-8>^X;8>Hc5fDW_TK$e8cDfHh&KeGLNy? z?xD5V@HxFU@J)|53luiLY%4=6!%6#IJ1CvvsMQDF>(<{2tcR4`aI&`KZ;RhVkT{?; z!egm(QtKVlhva>PAL`8|AgIN(A+iO|>! zQbUpGF_pI@ZTO*4?Is-wZ;U8Mm9l$kB@m0Rkr}Ew?4y{oK4?jMoG2igHoGr`+ zL=Kq4$>H)Pj?Q#urL|m&uw(~9#!!Qm5R!@F!vQyQiNh2mVTLDR_{mOus*y>UTufO0 zuWlHj9&&nQsTp?<<7wpKw-qB<4kt~5=c2tM0kP9*h(MIS`U298)3Za#TC=@HbD$A^ z4xBMJi7jkLq8v`#3j#+ov=u861xxcMfUFhgKSw32L<4jLZp52Qd?Fftkh3UA+E|>z zV8@&d!A$~AKAvy`^B^07XU6Holo7**Ackw{VB37`)SwZn!>0;1sPX-Ky+9Hs!n#b*|*USg8n9oQ-{V$y#YRf4!ZX3W@(u)yvQCGVn(jYy?ZvP6@rNG}5kl;A5b9_oPBU7WjxRtSj~QzyZ5^OK75JiWWQ{C55NupwLp(oKn<6 z_st{%uSQ21Db>VSY~VxWNBZ)@lXISD^uz7A*>(fU(pJM~<}_CjLh~sC!eg=Fs|5#P zH#9s>_%R*;FmN>Ic^6V?%P%B()xv|E8weIBCRuojeE>Xj5k+|H)I)SulE&sqptib2{j&!bzf!}BrHYrz^IFohWj5`F@v^}2QpfD}`x)DGQjB)MT_!A53Zh3 zz(mWU)j1EMTTeWCZCMnAx(0bf!p1^s*Q3krag8XNxy2I0(}>&ZEdQY^Wcjo9h-Y4r zPdszG{NkCz?>7-ID=6PxL+=7(An+!0qVJ)4h){ug*g7gaQy9CFFL+7@yoVDplQ0JK zE?vRLkeSguKL^NEX6(7UmE;CjkflbKkKTosz(;BNtGM49eH3M3N94bp+KP<=Ogn2U z%)dm};YH4`k^K}Kc3Ts&Pb5qqo3D4G{8DUSpew@*Jz7~G$+?Mh)*$1Cq~6gvRj*c%eO$l>5!ofj9P>Z-HW}!hYJ# z=6>4uwB_d@ty-B|_M1r;FW02lZ{CP18=DJQlVi(yvAB$KKhW$tToG{y{GPd&Rs{x_ z8w?eI%?$=z^|9=wT?9hF;_28+dk8sLMdjP8|*S6KEF)PA#lpNJ=DeG2Qq=xNAP$`=I0#XKk|d{R!2!k@Vz)>9C>Gq3>x)Y;K8 zE+Xae0Gu$RShf^q&@nPrBj@M9RNHqaV?nUd{%Z7VEbI(PY&=&d3ucVNum;P;6+4w{q<^FBee zOVwZX%ag|hJ?i~5kPZ6O`{{TmlM*+`zhFl*Iyb|u8|Hl9h;WSQHd6)?>`}?_KOc*! zBCNYdhG$?&31zGA*Z1f&y}bUWVPfs|$M+je#_{`)%@*6r+blw`Gqf5ut-j)Npm5NDF4Xtb8U^Ho9I zrdr(*Ud{!<2kq8i49_5s$Bbp&nZ|j;`#at*bE$IY{!hytbBcni9HL~@_WiP)|HUGm zz1Ou$Tt*^;-!IEkMgH)AT+8%R6q%mHU$>nO`pIChxfF=hAc6Rnfo0DxPQhQ*Y4s?;V0N@!fV-Qx=XnqtADUo z|I5)_Y`!&jRISH^aj(9k{p5LDj`p!(mePLww8De6di5mRFOHmmxKF{p*Oe&NI}G^^ z59fzkb}jp>*%zjmePNQ#i00dgXhmUH^RZuJ#&hqL`bKnE?07KuOS5c84m|(LElc}` zf6YEotEWYrZ;*uWk16WyU44#x%;dPGTC4XDS2~Sct~zxt<&INiGu46nbKf!_=c)2> zhAXqaWj^Vr$|pTsnIrSj9;kql{wH;FCFdpBGZkVY8yy_uceI9|Vh&{Z@>T3yrt)LV z%M&TXv#DDGl}qgU%C|)v^Zrx(et{R;!P+wXWZXMc7dNuRBAw&FNDQFnII)(OEV@6S zyfJ8=HHf2eckKR%^}AvZ_F~TooP_Z~rh3?tN`Gb}lErOgnD(jS>c2zK-h2H&{U_lZ z=i~Wvs`~Fn?EkC!zbDEP{NVcsVYZs@<&eS$F0r+J@XQ__6``l~cE zHV-U&zfbTwm~Wn+VUExBvReC8;zjnNUe-VVr}qg8Kn>SGN%slfLx8yk+6>rS1L0uY zvIhEJyHC)e-Pg-~f~Xhs0y+N1txsO0iZ{9mtVlv18tVb;eVAV$lA6%pkC*P()oh;S zb^p~|^oZL9tHqZ`Mgre&j6=~y4@IXUu4R2Dt_LJs1j5lFH(To;I2K)fRw2Y#_jNH=^aZZWpxhJJBi8i?)-U3FldA9x&nyfcw*~HY+P(EmRtkk- zaz3!33Q9qq?_oV^9=o`8W7!Ivn`u}sah0FTqW4=yAj;pR=wHaIxQ)4){KJ=PTI;D#U%i(4G* zxlK~RKrOflvIe~-*v2}WtRyQa&rjI(_7@qTwd}_)?4)Wf?=aqx;;n(tzwUJQ#|xHF z&XVH`58AgJ=>ThO-b@6x<4kSp$-rlJZyHX=F)eZXD{;6?+m}T;zJ5!?vHV2OT)lEu zaa(7FvqCj^-Xq}7kJFx*BnMmBNM({dPlP6gPQ@JM^Z zY_5fjXMD6HMwQ`O@IR1~ST!IfHqNrdM;U<5e`ri978;kwad%!2e%xzSGokzKWwNXb92W<#ldR1C_jf2v%%-;+fsDPmU9 z3@}cdH&rh|)uKlsRp39!;w7!-i z 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 literal 0 HcmV?d00001 diff --git a/extern/for_mingw/lib/libpng16.la b/extern/for_mingw/lib/libpng16.la new file mode 100644 index 0000000000..ce7dc3cc63 --- /dev/null +++ b/extern/for_mingw/lib/libpng16.la @@ -0,0 +1,41 @@ +# libpng16.la - a libtool library file +# Generated by libtool (GNU libtool) 2.4.2 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='' + +# Names of this library. +library_names='' + +# The name of the static archive. +old_library='libpng16.a' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='' + +# Libraries that this one depends upon. +dependency_libs=' -L/home/roothorick/stepmania/extern/for_mingw/lib -lz' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libpng16. +current=22 +age=6 +revision=0 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='/home/roothorick/stepmania/extern/for_mingw/lib' diff --git a/extern/for_mingw/lib/libz.a b/extern/for_mingw/lib/libz.a new file mode 100644 index 0000000000000000000000000000000000000000..a73e3e6712d560adb5b84b3831a6fe068ae47d8d GIT binary patch literal 102270 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 e^Rz`ouyd6!U&&!-1atZig}S0^>}b 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