/* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * * Permission to use, copy, modify, and distribute this software and * its documentation is hereby granted, provided that the above * copyright notice appears in all copies. * * SUN MAKES NO REPRESENTATION OR WARRANTIES ABOUT THE SUITABILITY OF * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, * MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES * * This file has been altered from its original by Sun Microsystems to * fit local coding style. */ #ifndef _ZLIB_H #define _ZLIB_H #ifdef __cplusplus extern "C" { #endif /* $Id: zlib.h,v 1.7 1997/11/27 06:03:33 paulus Exp $ */ /* * Updated to zlib-1.1.3 by James Carlson. * * This file is derived from zlib.h and zconf.h from the zlib-1.0.4 * distribution by Jean-loup Gailly and Mark Adler, with some additions * by Paul Mackerras to aid in implementing Deflate compression and * decompression for PPP packets. */ /* * ==FILEVERSION 971127== * * This marker is used by the Linux installation script to determine * whether an up-to-date version of this file is already installed. */ /* +++ zlib.h */ /* * zlib.h -- interface of the 'zlib' general purpose compression * library version 1.1.3, July 9th, 1998 * * Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler * * This software is provided 'as-is', without any express or implied * warranty. In no event will the authors be held liable for any * damages arising from the use of this software. * * Permission is granted to anyone to use this software for any * purpose, including commercial applications, and to alter it and * redistribute it freely, subject to the following restrictions: * * 1. The origin of this software must not be misrepresented; you must * not claim that you wrote the original software. If you use this * software in a product, an acknowledgment in the product * documentation would be appreciated but is not required. * * 2. Altered source versions must be plainly marked as such, and must * not be misrepresented as being the original software. * * 3. This notice may not be removed or altered from any source * distribution. * * * Jean-loup Gailly Mark Adler * jloup@gzip.org madler@alumni.caltech.edu * * The data format used by the zlib library is described by RFCs (Request for * Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt * (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). */ /* +++ zconf.h */ /* * zconf.h -- configuration of the zlib compression library * Copyright (C) 1995-1998 Jean-loup Gailly. * For conditions of distribution and use, see copyright notice in zlib.h */ /* From: zconf.h,v 1.20 1996/07/02 15:09:28 me Exp $ */ /* * If you *really* need a unique prefix for all types and library functions, * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. */ #ifdef Z_PREFIX #define deflateInit_ z_deflateInit_ #define deflate z_deflate #define deflateEnd z_deflateEnd #define inflateInit_ z_inflateInit_ #define inflate z_inflate #define inflateEnd z_inflateEnd #define deflateInit2_ z_deflateInit2_ #define deflateSetDictionary z_deflateSetDictionary #define deflateCopy z_deflateCopy #define deflateReset z_deflateReset #define deflateParams z_deflateParams #define inflateInit2_ z_inflateInit2_ #define inflateSetDictionary z_inflateSetDictionary #define inflateSync z_inflateSync #define inflateSyncPoint z_inflateSyncPoint #define inflateReset z_inflateReset #define compress z_compress #define compress2 z_compress2 #define uncompress z_uncompress #define adler32 z_adler32 #define crc32 z_crc32 #define get_crc_table z_get_crc_table #define Byte z_Byte #define uInt z_uInt #define uLong z_uLong #define Bytef z_Bytef #define charf z_charf #define intf z_intf #define uIntf z_uIntf #define uLongf z_uLongf #define voidpf z_voidpf #define voidp z_voidp #endif #if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32) #define WIN32 #endif #if defined(WIN32) || defined(__386__) || defined(__i386) #ifndef __32BIT__ #define __32BIT__ #endif #endif #if defined(__MSDOS__) && !defined(MSDOS) #define MSDOS #endif /* * Compile with -DMAXSEG_64K if the alloc function cannot allocate more * than 64k bytes at a time (needed on systems with 16-bit int). */ #if defined(MSDOS) && !defined(__32BIT__) #define MAXSEG_64K #endif #ifdef MSDOS #define UNALIGNED_OK #endif #if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC) #define STDC #endif #if (defined(__STDC__) || defined(__cplusplus)) || defined(__OS2__) #ifndef STDC #define STDC #endif #endif #ifndef STDC #ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ #define const #endif #endif /* Some Mac compilers merge all .h files incorrectly: */ #if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__) #define NO_DUMMY_DECL #endif /* Old Borland C incorrectly complains about missing returns: */ #if defined(__BORLANDC__) && (__BORLANDC__ < 0x500) #define NEED_DUMMY_RETURN #endif /* Maximum value for memLevel in deflateInit2 */ #ifndef MAX_MEM_LEVEL #ifdef MAXSEG_64K #define MAX_MEM_LEVEL 8 #else #define MAX_MEM_LEVEL 9 #endif #endif /* * Maximum value for windowBits in deflateInit2 and inflateInit2 * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files * created by gzip. (Files created by minigzip can still be extracted by * gzip.) */ #ifndef MAX_WBITS #define MAX_WBITS 15 /* 32K LZ77 window */ #endif /* * The memory requirements for deflate are (in bytes): * 1 << (windowBits+2) + 1 << (memLevel+9) * * that is: 128K for windowBits=15 + 128K for memLevel = 8 (default * values) plus a few kilobytes for small objects. For example, if * you want to reduce the default memory requirements from 256K to * 128K, compile with * * make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" * * Of course this will generally degrade compression (there's no free lunch). * * The memory requirements for inflate are (in bytes) 1 << windowBits * that is, 32K for windowBits=15 (default value) plus a few kilobytes * for small objects. */ /* Type declarations */ #ifndef OF /* function prototypes */ #ifdef STDC #define OF(args) args #else #define OF(args) () #endif #endif /* * The following definitions for FAR are needed only for MSDOS mixed * model programming, small or medium model with some far allocations. * This was tested only with MSC; for other MSDOS compilers you may have * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, * just define FAR to be empty. */ #if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__) /* MSC small or medium model */ #define SMALL_MEDIUM #ifdef _MSC_VER #define FAR __far #else #define FAR far #endif #endif #if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__)) #ifndef __32BIT__ #define SMALL_MEDIUM #define FAR __far #endif #endif /* Compile with -DZLIB_DLL for Windows DLL support */ #if defined(ZLIB_DLL) #if defined(_WINDOWS) || defined(WINDOWS) #ifdef FAR #undef FAR #endif #include #define ZEXPORT WINAPI #ifdef WIN32 #define ZEXPORTVA WINAPIV #else #define ZEXPORTVA FAR _cdecl _export #endif #endif #if defined(__BORLANDC__) #if (__BORLANDC__ >= 0x0500) && defined(WIN32) #include #define ZEXPORT __declspec(dllexport) WINAPI #define ZEXPORTRVA __declspec(dllexport) WINAPIV #else #if defined(_Windows) && defined(__DLL__) #define ZEXPORT _export #define ZEXPORTVA _export #endif #endif #endif #endif #if defined(__BEOS__) #if defined(ZLIB_DLL) #define ZEXTERN extern __declspec(dllexport) #else #define ZEXTERN extern __declspec(dllimport) #endif #endif #ifndef ZEXPORT #define ZEXPORT #endif #ifndef ZEXPORTVA #define ZEXPORTVA #endif #ifndef ZEXTERN #define ZEXTERN extern #endif #ifndef FAR #define FAR #endif #if !defined(MACOS) && !defined(TARGET_OS_MAC) typedef unsigned char Byte; /* 8 bits */ #endif typedef unsigned int uInt; /* 16 bits or more */ typedef unsigned long uLong; /* 32 bits or more */ #ifdef SMALL_MEDIUM /* Borland C/C++ ignores FAR inside typedef */ #define Bytef Byte FAR #else typedef Byte FAR Bytef; #endif typedef char FAR charf; typedef int FAR intf; typedef uInt FAR uIntf; typedef uLong FAR uLongf; #ifdef STDC typedef void FAR *voidpf; typedef void *voidp; #else typedef Byte FAR *voidpf; typedef Byte *voidp; #endif #ifdef HAVE_UNISTD_H #include /* for off_t */ #include /* for SEEK_* and off_t */ #define z_off_t off_t #endif #ifndef SEEK_SET #define SEEK_SET 0 /* Seek from beginning of file. */ #define SEEK_CUR 1 /* Seek from current position. */ #define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ #endif #ifndef z_off_t #define z_off_t long #endif /* MVS linker does not support external names larger than 8 bytes */ #if defined(__MVS__) #pragma map(deflateInit_, "DEIN") #pragma map(deflateInit2_, "DEIN2") #pragma map(deflateEnd, "DEEND") #pragma map(inflateInit_, "ININ") #pragma map(inflateInit2_, "ININ2") #pragma map(inflateEnd, "INEND") #pragma map(inflateSync, "INSY") #pragma map(inflateSetDictionary, "INSEDI") #pragma map(inflate_blocks, "INBL") #pragma map(inflate_blocks_new, "INBLNE") #pragma map(inflate_blocks_free, "INBLFR") #pragma map(inflate_blocks_reset, "INBLRE") #pragma map(inflate_codes_free, "INCOFR") #pragma map(inflate_codes, "INCO") #pragma map(inflate_fast, "INFA") #pragma map(inflate_flush, "INFLU") #pragma map(inflate_mask, "INMA") #pragma map(inflate_set_dictionary, "INSEDI2") #pragma map(inflate_copyright, "INCOPY") #pragma map(inflate_trees_bits, "INTRBI") #pragma map(inflate_trees_dynamic, "INTRDY") #pragma map(inflate_trees_fixed, "INTRFI") #pragma map(inflate_trees_free, "INTRFR") #endif /* --- zconf.h */ /* +++ zlib.h */ #define ZLIB_VERSION "1.1.3P" /* * 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 may be added * later and will have the same stream interface. * * For compression the application must provide the output buffer * and may optionally provide the input buffer for optimization. For * decompression, the application must provide the input buffer and * may optionally provide the output buffer for optimization. * * Compression can be done in a single step if the buffers are * large enough (for example if an input file is mmap'ed), or can be * done by repeated calls of the compression function. In the latter * case, the application must provide more input and/or consume the * output (providing more output space) before each call. * * The library does not install any signal handler. It is * recommended to add at least a handler for SIGSEGV when * decompressing; the library checks the consistency of the input * data whenever possible but may go nuts for some forms of corrupted * input. */ typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); typedef void (*free_func) OF((voidpf opaque, voidpf address)); struct internal_state; typedef struct z_stream_s { Bytef *next_in; /* next input byte */ uInt avail_in; /* number of bytes available at next_in */ uLong total_in; /* total nb of input bytes read so far */ Bytef *next_out; /* next output byte should be put there */ uInt avail_out; /* remaining free space at next_out */ uLong total_out; /* total nb of bytes output so far */ const char *msg; /* last error message, NULL if no error */ struct internal_state FAR *state; /* not visible to applications */ alloc_func zalloc; /* used to allocate the internal state */ free_func zfree; /* used to free the internal state */ /* private data object passed to zalloc and zfree */ voidpf opaque; /* best guess about the data type: ascii or binary */ int data_type; uLong adler; /* adler32 value of the uncompressed data */ uLong reserved; /* reserved for future use */ } z_stream; typedef z_stream FAR *z_streamp; /* * The application must update next_in and avail_in when avail_in has * dropped to zero. It must update next_out and avail_out when * avail_out has dropped to zero. The application must initialize * zalloc, zfree and opaque before calling the init function. All * other fields are set by the compression library and must not be * updated by the application. * * The opaque value provided by the application will be passed as the * first parameter for calls of zalloc and zfree. This can be useful * for custom memory management. The compression library attaches no * meaning to the opaque value. * * zalloc must return Z_NULL if there is not enough memory for the * object. On 16-bit systems, the functions zalloc and zfree must be * able to allocate exactly 65536 bytes, but will not be required to * allocate more than this if the symbol MAXSEG_64K is defined (see * zconf.h). WARNING: On MSDOS, pointers returned by zalloc for * objects of exactly 65536 bytes *must* have their offset normalized * to zero. The default allocation function provided by this library * ensures this (see zutil.c). To reduce memory requirements and avoid * any allocation of 64K objects, at the expense of compression ratio, * compile the library with -DMAX_WBITS=14 (see zconf.h). * * The fields total_in and total_out can be used for statistics or * progress reports. After compression, total_in holds the total size * of the uncompressed data and may be saved for use in the * decompressor (particularly if the decompressor wants to decompress * everything in a single step). */ /* constants */ #define Z_NO_FLUSH 0 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ #define Z_PACKET_FLUSH 2 #define Z_SYNC_FLUSH 3 #define Z_FULL_FLUSH 4 #define Z_FINISH 5 /* Allowed flush values; see deflate() below for details */ #define Z_OK 0 #define Z_STREAM_END 1 #define Z_NEED_DICT 2 #define Z_ERRNO (-1) #define Z_STREAM_ERROR (-2) #define Z_DATA_ERROR (-3) #define Z_MEM_ERROR (-4) #define Z_BUF_ERROR (-5) #define Z_VERSION_ERROR (-6) /* * Return codes for the compression/decompression functions. Negative * values are errors, positive values are used for special but normal * events. */ #define Z_NO_COMPRESSION 0 #define Z_BEST_SPEED 1 #define Z_BEST_COMPRESSION 9 #define Z_DEFAULT_COMPRESSION (-1) /* compression levels */ #define Z_FILTERED 1 #define Z_HUFFMAN_ONLY 2 #define Z_DEFAULT_STRATEGY 0 /* compression strategy; see deflateInit2() below for details */ #define Z_BINARY 0 #define Z_ASCII 1 #define Z_UNKNOWN 2 /* Possible values of the data_type field */ #define Z_DEFLATED 8 /* The deflate compression method (the only one supported in this version) */ #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ #define zlib_version zlibVersion() /* for compatibility with versions < 1.0.2 */ /* basic functions */ ZEXTERN const char *ZEXPORT zlibVersion OF((void)); /* * The application can compare zlibVersion and ZLIB_VERSION for * consistency. If the first character differs, the library code * actually used is not compatible with the zlib.h header file used by * the application. This check is automatically made by deflateInit * and inflateInit. */ /* * ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); * * Initializes the internal stream state for compression. The * fields zalloc, zfree and opaque must be initialized before by * the caller. If zalloc and zfree are set to Z_NULL, deflateInit * updates them to use default allocation functions. * * The compression level must be Z_DEFAULT_COMPRESSION, or between * 0 and 9: 1 gives best speed, 9 gives best compression, 0 gives * no compression at all (the input data is simply copied a block * at a time). Z_DEFAULT_COMPRESSION requests a default * compromise between speed and compression (currently equivalent * to level 6). * * deflateInit returns Z_OK if success, Z_MEM_ERROR if there was * not enough memory, Z_STREAM_ERROR if level is not a valid * compression level, Z_VERSION_ERROR if the zlib library version * (zlib_version) is incompatible with the version assumed by the * caller (ZLIB_VERSION). msg is set to null if there is no error * message. deflateInit does not perform any compression: this * will be done by deflate(). */ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); /* * Performs one or both of the following actions: * * - Compress more input starting at next_in and update next_in and * avail_in accordingly. If not all input can be processed (because * there is not enough room in the output buffer), next_in and * avail_in are updated and processing will resume at this point for * the next call of deflate(). * * - Provide more output starting at next_out and update next_out and * avail_out accordingly. This action is forced if the parameter flush * is non zero. Forcing flush frequently degrades the compression * ratio, so this parameter should be set only when necessary (in * interactive applications). Some output may be provided even if * flush is not set. * * Before the call of deflate(), the application should ensure that at * least one of the actions is possible, by providing more input * and/or consuming more output, and updating avail_in or avail_out * accordingly; avail_out should never be zero before the call. The * application can consume the compressed output when it wants, for * example when the output buffer is full (avail_out == 0), or after * each call of deflate(). If deflate returns Z_OK and with zero * avail_out, it must be called again after making room in the output * buffer because there might be more output pending. * * If the parameter flush is set to Z_PARTIAL_FLUSH, the current * compression block is terminated and flushed to the output buffer so * that the decompressor can get all input data available so far. For * method 9, a future variant on method 8, the current block will be * flushed but not terminated. Z_SYNC_FLUSH has the same effect as * partial flush except that the compressed output is byte aligned * (the compressor can clear its internal bit buffer) and the current * block is always terminated; this can be useful if the compressor * has to be restarted from scratch after an interruption (in which * case the internal state of the compressor may be lost). If flush * is set to Z_FULL_FLUSH, the compression block is terminated, a * special marker is output and the compression dictionary is * discarded; this is useful to allow the decompressor to synchronize * if one compressed block has been damaged (see inflateSync below). * Flushing degrades compression and so should be used only when * necessary. Using Z_FULL_FLUSH too often can seriously degrade the * compression. If deflate returns with avail_out == 0, this function * must be called again with the same value of the flush parameter and * more output space (updated avail_out), until the flush is complete * (deflate returns with non-zero avail_out). * * If the parameter flush is set to Z_PACKET_FLUSH, the compression * block is terminated, and a zero-length stored block is output, * omitting the length bytes (the effect of this is that the 3-bit * type code 000 for a stored block is output, and the output is then * byte-aligned). This is designed for use at the end of a PPP * packet. * * If the parameter flush is set to Z_FINISH, pending input is * processed, pending output is flushed and deflate returns with * Z_STREAM_END if there was enough output space; if deflate returns * with Z_OK, this function must be called again with Z_FINISH and * more output space (updated avail_out) but no more input data, until * it returns with Z_STREAM_END or an error. After deflate has * returned Z_STREAM_END, the only possible operations on the stream * are deflateReset or deflateEnd. * * Z_FINISH can be used immediately after deflateInit if all the * compression is to be done in a single step. In this case, avail_out * must be at least 0.1% larger than avail_in plus 12 bytes. If * deflate does not return Z_STREAM_END, then it must be called again * as described above. * * deflate() may update data_type if it can make a good guess about * the input data type (Z_ASCII or Z_BINARY). In doubt, the data is * considered binary. This field is only for information purposes and * does not affect the compression algorithm in any manner. * * deflate() returns Z_OK if some progress has been made (more input * processed or more output produced), Z_STREAM_END if all input has * been consumed and all output has been produced (only when flush is * set to Z_FINISH), Z_STREAM_ERROR if the stream state was * inconsistent (for example if next_in or next_out was NULL), * Z_BUF_ERROR if no progress is possible. */ 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 * zalloc, zfree and opaque must be initialized before by the caller. * If zalloc and zfree are set to Z_NULL, inflateInit updates them to * use default allocation functions. * * inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not * enough memory, Z_VERSION_ERROR if the zlib library version is * incompatible with the version assumed by the caller. msg is set to * null if there is no error message. inflateInit does not perform any * decompression: this will be done by inflate(). */ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); /* * Performs one or both of the following actions: * * - Decompress more input starting at next_in and update next_in and * avail_in accordingly. If not all input can be processed (because * there is not enough room in the output buffer), next_in is * updated and processing will resume at this point for the next * call of inflate(). * * - Provide more output starting at next_out and update next_out and * avail_out accordingly. inflate() provides as much output as * possible, until there is no more input data or no more space in * the output buffer (see below about the flush parameter). * * Before the call of inflate(), the application should ensure that at * least one of the actions is possible, by providing more input * and/or consuming more output, and updating the next_* and avail_* * values accordingly. The application can consume the uncompressed * output when it wants, for example when the output buffer is full * (avail_out == 0), or after each call of inflate(). If inflate * returns Z_OK and with zero avail_out, it must be called again after * making room in the output buffer because there might be more output * pending. * * If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH, * inflate flushes as much output as possible to the output * buffer. The flushing behavior of inflate is not specified for * values of the flush parameter other than Z_PARTIAL_FLUSH, * Z_PACKET_FLUSH or Z_FINISH, but the current implementation actually * flushes as much output as possible anyway. For Z_PACKET_FLUSH, * inflate checks that once all the input data has been consumed, it * is expecting to see the length field of a stored block; if not, it * returns Z_DATA_ERROR. * * inflate() should normally be called until it returns Z_STREAM_END * or an error. However if all decompression is to be performed in a * single step (a single call of inflate), the parameter flush should * be set to Z_FINISH. In this case all pending input is processed and * all pending output is flushed; avail_out must be large enough to * hold all the uncompressed data. (The size of the uncompressed data * may have been saved by the compressor for this purpose.) The next * operation on this stream must be inflateEnd to deallocate the * decompression state. The use of Z_FINISH is never required, but can * be used to inform inflate that a faster routine may be used for the * single inflate() call. * * 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 (see inflateSetDictionary below), Z_DATA_ERROR if the input * data was corrupted, Z_STREAM_ERROR if the stream structure was * inconsistent (for example if next_in or next_out was NULL), * Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no * progress is possible or if there was not enough room in the output * buffer when Z_FINISH is used. In the Z_DATA_ERROR case, the * application may then call inflateSync to look for a good * compression block. In the Z_NEED_DICT case, strm->adler is set to * the Adler32 value of the dictionary chosen by the compressor. */ 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. (Method 9 will allow a * 64K history buffer and partial block flushes.) * * 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 (the value 16 will be allowed * for method 9). Larger values of this parameter result in better * compression at the expense of memory usage. The default value is 15 * if deflateInit is used instead. * * The memLevel parameter specifies how much memory should be * allocated for the internal compression state. memLevel=1 uses * minimum memory but is slow and reduces compression ratio; * memLevel=9 uses maximum memory for optimal speed. The default value * is 8. See zconf.h for total memory usage as a function of * windowBits and memLevel. * * The strategy parameter is used to tune the compression * algorithm. Use the value Z_DEFAULT_STRATEGY for normal data, * Z_FILTERED for data produced by a filter (or predictor), or * Z_HUFFMAN_ONLY to force Huffman encoding only (no string match). * Filtered data consists mostly of small values with a somewhat * random distribution. In this case, the compression algorithm is * tuned to compress them better. The effect of Z_FILTERED is to force * more Huffman coding and less string matching; it is somewhat * intermediate between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy * parameter only affects the compression ratio but not the * correctness of the compressed output even if it is not set * appropriately. * * If next_in is not null, the library will use this buffer to hold * also some history information; the buffer must either hold the * entire input data, or have at least 1<<(windowBits+1) bytes and be * writable. If next_in is null, the library will allocate its own * history buffer (and leave next_in null). next_out need not be * provided here but must be provided by the application for the next * call of deflate(). * * If the history buffer is provided by the application, next_in must * must never be changed by the application since the compressor * maintains information inside this buffer from call to call; the * application must provide more input only by increasing * avail_in. next_in is always reset by the library in this case. * * deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not * enough memory, Z_STREAM_ERROR if a parameter is invalid (such as an * invalid method). msg is set to null if there is no error message. * deflateInit2 does not perform any compression: this will be done by * deflate(). */ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, const Bytef *dictionary, uInt dictLength)); /* * Initializes the compression dictionary (history buffer) from the * given byte sequence without producing any compressed output. This * function must be called immediately after deflateInit or * deflateInit2, before any call of deflate. The compressor and * decompressor must use exactly the same dictionary (see * inflateSetDictionary). * * The dictionary should consist of strings (byte sequences) that are * likely to be encountered later in the data to be compressed, with * the most commonly used strings preferably put towards the end of * the dictionary. Using a dictionary is most useful when the data to * be compressed is short and can be predicted with good accuracy; the * data can then be compressed better than with the default empty * dictionary. In this version of the library, only the last 32K bytes * of the dictionary are used. * * Upon return of this function, strm->adler is set to the Adler32 * value of the dictionary; the decompressor may later use this value * to determine which dictionary has been used by the compressor. (The * Adler32 value applies to the whole dictionary even if only a subset * of the dictionary is actually used by the compressor.) * * deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if * a parameter is invalid (such as NULL dictionary) or the stream * state is inconsistent (for example if deflate has already been * called for this stream). 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. If the source stream is using an application-supplied * history buffer, a new buffer is allocated for the destination * stream. The compressed output buffer is always * application-supplied. It's the responsibility of the application to * provide the correct values of next_out and avail_out for the next * call of deflate. * * This function can be useful when several compression strategies * will be tried, for example when there are several ways of * pre-processing the input data with a filter. The streams that will * be discarded should then be freed by calling deflateEnd. Note that * deflateCopy duplicates the internal compression state which can be * quite large, so this strategy is slow and can consume lots of * memory. * * deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not * enough memory, Z_STREAM_ERROR if the source stream state was * inconsistent (such as zalloc being NULL). msg is left unchanged in * both source and destination. */ ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); /* * This function is equivalent to deflateEnd followed by deflateInit, * but does not free and reallocate all the internal compression * state. The stream will keep the same compression level and any * other attributes that may have been set by deflateInit2. * * deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the * source stream state was inconsistent (such as zalloc or state being * NULL). */ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy)); /* * Dynamically update the compression level and compression strategy. * 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 deflateOutputPending OF((z_streamp strm)); /* * Returns the number of bytes of output which are immediately * available from the compressor (i.e. without any further input or * flush). */ /* * ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, * int windowBits)); * * This is another version of inflateInit with more compression * options. The fields next_out, 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 value 16 will be * allowed soon). The default value is 15 if inflateInit is used * instead. If a compressed stream with a larger window size is given * as input, inflate() will return with the error code Z_DATA_ERROR * instead of trying to allocate a larger window. * * If next_out is not null, the library will use this buffer for the * history buffer; the buffer must either be large enough to hold the * entire output data, or have at least 1<