00001 // $Id: zlib.h 751 2006-03-31 15:43:49Z alex $ 00002 00003 /* @@tag:xara-cn-tp@@ THIRD PARTY COPYRIGHT */ 00004 /* zlib.h -- interface of the 'zlib' general purpose compression library 00005 version 1.2.2, October 3rd, 2004 00006 00007 MODIFIED FOR USE IN XARA LX - THIS IS NOT THE ORIGINAL UNMODIFIED SOURCE CODE 00008 00009 Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler 00010 00011 This software is provided 'as-is', without any express or implied 00012 warranty. In no event will the authors be held liable for any damages 00013 arising from the use of this software. 00014 00015 Permission is granted to anyone to use this software for any purpose, 00016 including commercial applications, and to alter it and redistribute it 00017 freely, subject to the following restrictions: 00018 00019 1. The origin of this software must not be misrepresented; you must not 00020 claim that you wrote the original software. If you use this software 00021 in a product, an acknowledgment in the product documentation would be 00022 appreciated but is not required. 00023 2. Altered source versions must be plainly marked as such, and must not be 00024 misrepresented as being the original software. 00025 3. This notice may not be removed or altered from any source distribution. 00026 00027 Jean-loup Gailly Mark Adler 00028 jloup@gzip.org madler@alumni.caltech.edu 00029 00030 00031 The data format used by the zlib library is described by RFCs (Request for 00032 Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt 00033 (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). 00034 */ 00035 00036 #ifndef ZLIB_H 00037 #define ZLIB_H 00038 00039 #include "zconf.h" 00040 00041 #ifdef __cplusplus 00042 extern "C" { 00043 #endif 00044 00045 #define ZLIB_VERSION "1.2.2" 00046 #define ZLIB_VERNUM 0x1220 00047 00048 /* 00049 The 'zlib' compression library provides in-memory compression and 00050 decompression functions, including integrity checks of the uncompressed 00051 data. This version of the library supports only one compression method 00052 (deflation) but other algorithms will be added later and will have the same 00053 stream interface. 00054 00055 Compression can be done in a single step if the buffers are large 00056 enough (for example if an input file is mmap'ed), or can be done by 00057 repeated calls of the compression function. In the latter case, the 00058 application must provide more input and/or consume the output 00059 (providing more output space) before each call. 00060 00061 The compressed data format used by default by the in-memory functions is 00062 the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped 00063 around a deflate stream, which is itself documented in RFC 1951. 00064 00065 The library also supports reading and writing files in gzip (.gz) format 00066 with an interface similar to that of stdio using the functions that start 00067 with "gz". The gzip format is different from the zlib format. gzip is a 00068 gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. 00069 00070 This library can optionally read and write gzip streams in memory as well. 00071 00072 The zlib format was designed to be compact and fast for use in memory 00073 and on communications channels. The gzip format was designed for single- 00074 file compression on file systems, has a larger header than zlib to maintain 00075 directory information, and uses a different, slower check method than zlib. 00076 00077 The library does not install any signal handler. The decoder checks 00078 the consistency of the compressed data, so the library should never 00079 crash even in case of corrupted input. 00080 */ 00081 00082 typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); 00083 typedef void (*free_func) OF((voidpf opaque, voidpf address)); 00084 00085 struct internal_state; 00086 00087 typedef struct z_stream_s { 00088 Bytef *next_in; /* next input byte */ 00089 uInt avail_in; /* number of bytes available at next_in */ 00090 uLong total_in; /* total nb of input bytes read so far */ 00091 00092 Bytef *next_out; /* next output byte should be put there */ 00093 uInt avail_out; /* remaining free space at next_out */ 00094 uLong total_out; /* total nb of bytes output so far */ 00095 00096 char *msg; /* last error message, NULL if no error */ 00097 struct internal_state FAR *state; /* not visible by applications */ 00098 00099 alloc_func zalloc; /* used to allocate the internal state */ 00100 free_func zfree; /* used to free the internal state */ 00101 voidpf opaque; /* private data object passed to zalloc and zfree */ 00102 00103 INT32 data_type; /* best guess about the data type: ascii or binary */ 00104 uLong adler; /* adler32 value of the uncompressed data */ 00105 uLong reserved; /* reserved for future use */ 00106 } z_stream; 00107 00108 typedef z_stream FAR *z_streamp; 00109 00110 /* 00111 The application must update next_in and avail_in when avail_in has 00112 dropped to zero. It must update next_out and avail_out when avail_out 00113 has dropped to zero. The application must initialize zalloc, zfree and 00114 opaque before calling the init function. All other fields are set by the 00115 compression library and must not be updated by the application. 00116 00117 The opaque value provided by the application will be passed as the first 00118 parameter for calls of zalloc and zfree. This can be useful for custom 00119 memory management. The compression library attaches no meaning to the 00120 opaque value. 00121 00122 zalloc must return Z_NULL if there is not enough memory for the object. 00123 If zlib is used in a multi-threaded application, zalloc and zfree must be 00124 thread safe. 00125 00126 On 16-bit systems, the functions zalloc and zfree must be able to allocate 00127 exactly 65536 bytes, but will not be required to allocate more than this 00128 if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, 00129 pointers returned by zalloc for objects of exactly 65536 bytes *must* 00130 have their offset normalized to zero. The default allocation function 00131 provided by this library ensures this (see zutil.c). To reduce memory 00132 requirements and avoid any allocation of 64K objects, at the expense of 00133 compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). 00134 00135 The fields total_in and total_out can be used for statistics or 00136 progress reports. After compression, total_in holds the total size of 00137 the uncompressed data and may be saved for use in the decompressor 00138 (particularly if the decompressor wants to decompress everything in 00139 a single step). 00140 */ 00141 00142 /* constants */ 00143 00144 #define Z_NO_FLUSH 0 00145 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ 00146 #define Z_SYNC_FLUSH 2 00147 #define Z_FULL_FLUSH 3 00148 #define Z_FINISH 4 00149 #define Z_BLOCK 5 00150 /* Allowed flush values; see deflate() and inflate() below for details */ 00151 00152 #define Z_OK 0 00153 #define Z_STREAM_END 1 00154 #define Z_NEED_DICT 2 00155 #define Z_ERRNO (-1) 00156 #define Z_STREAM_ERROR (-2) 00157 #define Z_DATA_ERROR (-3) 00158 #define Z_MEM_ERROR (-4) 00159 #define Z_BUF_ERROR (-5) 00160 #define Z_VERSION_ERROR (-6) 00161 /* Return codes for the compression/decompression functions. Negative 00162 * values are errors, positive values are used for special but normal events. 00163 */ 00164 00165 #define Z_NO_COMPRESSION 0 00166 #define Z_BEST_SPEED 1 00167 #define Z_BEST_COMPRESSION 9 00168 #define Z_DEFAULT_COMPRESSION (-1) 00169 /* compression levels */ 00170 00171 #define Z_FILTERED 1 00172 #define Z_HUFFMAN_ONLY 2 00173 #define Z_RLE 3 00174 #define Z_DEFAULT_STRATEGY 0 00175 /* compression strategy; see deflateInit2() below for details */ 00176 00177 #define Z_BINARY 0 00178 #define Z_ASCII 1 00179 #define Z_UNKNOWN 2 00180 /* Possible values of the data_type field (though see inflate()) */ 00181 00182 #define Z_DEFLATED 8 00183 /* The deflate compression method (the only one supported in this version) */ 00184 00185 #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ 00186 00187 #define zlib_version zlibVersion() 00188 /* for compatibility with versions < 1.0.2 */ 00189 00190 /* basic functions */ 00191 00192 ZEXTERN const char * ZEXPORT zlibVersion OF((void)); 00193 /* The application can compare zlibVersion and ZLIB_VERSION for consistency. 00194 If the first character differs, the library code actually used is 00195 not compatible with the zlib.h header file used by the application. 00196 This check is automatically made by deflateInit and inflateInit. 00197 */ 00198 00199 /* 00200 ZEXTERN INT32 ZEXPORT deflateInit OF((z_streamp strm, INT32 level)); 00201 00202 Initializes the internal stream state for compression. The fields 00203 zalloc, zfree and opaque must be initialized before by the caller. 00204 If zalloc and zfree are set to Z_NULL, deflateInit updates them to 00205 use default allocation functions. 00206 00207 The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: 00208 1 gives best speed, 9 gives best compression, 0 gives no compression at 00209 all (the input data is simply copied a block at a time). 00210 Z_DEFAULT_COMPRESSION requests a default compromise between speed and 00211 compression (currently equivalent to level 6). 00212 00213 deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not 00214 enough memory, Z_STREAM_ERROR if level is not a valid compression level, 00215 Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible 00216 with the version assumed by the caller (ZLIB_VERSION). 00217 msg is set to null if there is no error message. deflateInit does not 00218 perform any compression: this will be done by deflate(). 00219 */ 00220 00221 00222 ZEXTERN INT32 ZEXPORT deflate OF((z_streamp strm, INT32 flush)); 00223 /* 00224 deflate compresses as much data as possible, and stops when the input 00225 buffer becomes empty or the output buffer becomes full. It may introduce some 00226 output latency (reading input without producing any output) except when 00227 forced to flush. 00228 00229 The detailed semantics are as follows. deflate performs one or both of the 00230 following actions: 00231 00232 - Compress more input starting at next_in and update next_in and avail_in 00233 accordingly. If not all input can be processed (because there is not 00234 enough room in the output buffer), next_in and avail_in are updated and 00235 processing will resume at this point for the next call of deflate(). 00236 00237 - Provide more output starting at next_out and update next_out and avail_out 00238 accordingly. This action is forced if the parameter flush is non zero. 00239 Forcing flush frequently degrades the compression ratio, so this parameter 00240 should be set only when necessary (in interactive applications). 00241 Some output may be provided even if flush is not set. 00242 00243 Before the call of deflate(), the application should ensure that at least 00244 one of the actions is possible, by providing more input and/or consuming 00245 more output, and updating avail_in or avail_out accordingly; avail_out 00246 should never be zero before the call. The application can consume the 00247 compressed output when it wants, for example when the output buffer is full 00248 (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK 00249 and with zero avail_out, it must be called again after making room in the 00250 output buffer because there might be more output pending. 00251 00252 If the parameter flush is set to Z_SYNC_FLUSH, all pending output is 00253 flushed to the output buffer and the output is aligned on a byte boundary, so 00254 that the decompressor can get all input data available so far. (In particular 00255 avail_in is zero after the call if enough output space has been provided 00256 before the call.) Flushing may degrade compression for some compression 00257 algorithms and so it should be used only when necessary. 00258 00259 If flush is set to Z_FULL_FLUSH, all output is flushed as with 00260 Z_SYNC_FLUSH, and the compression state is reset so that decompression can 00261 restart from this point if previous compressed data has been damaged or if 00262 random access is desired. Using Z_FULL_FLUSH too often can seriously degrade 00263 the compression. 00264 00265 If deflate returns with avail_out == 0, this function must be called again 00266 with the same value of the flush parameter and more output space (updated 00267 avail_out), until the flush is complete (deflate returns with non-zero 00268 avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that 00269 avail_out is greater than six to avoid repeated flush markers due to 00270 avail_out == 0 on return. 00271 00272 If the parameter flush is set to Z_FINISH, pending input is processed, 00273 pending output is flushed and deflate returns with Z_STREAM_END if there 00274 was enough output space; if deflate returns with Z_OK, this function must be 00275 called again with Z_FINISH and more output space (updated avail_out) but no 00276 more input data, until it returns with Z_STREAM_END or an error. After 00277 deflate has returned Z_STREAM_END, the only possible operations on the 00278 stream are deflateReset or deflateEnd. 00279 00280 Z_FINISH can be used immediately after deflateInit if all the compression 00281 is to be done in a single step. In this case, avail_out must be at least 00282 the value returned by deflateBound (see below). If deflate does not return 00283 Z_STREAM_END, then it must be called again as described above. 00284 00285 deflate() sets strm->adler to the adler32 checksum of all input read 00286 so far (that is, total_in bytes). 00287 00288 deflate() may update data_type if it can make a good guess about 00289 the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered 00290 binary. This field is only for information purposes and does not affect 00291 the compression algorithm in any manner. 00292 00293 deflate() returns Z_OK if some progress has been made (more input 00294 processed or more output produced), Z_STREAM_END if all input has been 00295 consumed and all output has been produced (only when flush is set to 00296 Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example 00297 if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible 00298 (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not 00299 fatal, and deflate() can be called again with more input and more output 00300 space to continue compressing. 00301 */ 00302 00303 00304 ZEXTERN INT32 ZEXPORT deflateEnd OF((z_streamp strm)); 00305 /* 00306 All dynamically allocated data structures for this stream are freed. 00307 This function discards any unprocessed input and does not flush any 00308 pending output. 00309 00310 deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the 00311 stream state was inconsistent, Z_DATA_ERROR if the stream was freed 00312 prematurely (some input or output was discarded). In the error case, 00313 msg may be set but then points to a static string (which must not be 00314 deallocated). 00315 */ 00316 00317 00318 /* 00319 ZEXTERN INT32 ZEXPORT inflateInit OF((z_streamp strm)); 00320 00321 Initializes the internal stream state for decompression. The fields 00322 next_in, avail_in, zalloc, zfree and opaque must be initialized before by 00323 the caller. If next_in is not Z_NULL and avail_in is large enough (the exact 00324 value depends on the compression method), inflateInit determines the 00325 compression method from the zlib header and allocates all data structures 00326 accordingly; otherwise the allocation will be deferred to the first call of 00327 inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to 00328 use default allocation functions. 00329 00330 inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough 00331 memory, Z_VERSION_ERROR if the zlib library version is incompatible with the 00332 version assumed by the caller. msg is set to null if there is no error 00333 message. inflateInit does not perform any decompression apart from reading 00334 the zlib header if present: this will be done by inflate(). (So next_in and 00335 avail_in may be modified, but next_out and avail_out are unchanged.) 00336 */ 00337 00338 00339 ZEXTERN INT32 ZEXPORT inflate OF((z_streamp strm, INT32 flush)); 00340 /* 00341 inflate decompresses as much data as possible, and stops when the input 00342 buffer becomes empty or the output buffer becomes full. It may introduce 00343 some output latency (reading input without producing any output) except when 00344 forced to flush. 00345 00346 The detailed semantics are as follows. inflate performs one or both of the 00347 following actions: 00348 00349 - Decompress more input starting at next_in and update next_in and avail_in 00350 accordingly. If not all input can be processed (because there is not 00351 enough room in the output buffer), next_in is updated and processing 00352 will resume at this point for the next call of inflate(). 00353 00354 - Provide more output starting at next_out and update next_out and avail_out 00355 accordingly. inflate() provides as much output as possible, until there 00356 is no more input data or no more space in the output buffer (see below 00357 about the flush parameter). 00358 00359 Before the call of inflate(), the application should ensure that at least 00360 one of the actions is possible, by providing more input and/or consuming 00361 more output, and updating the next_* and avail_* values accordingly. 00362 The application can consume the uncompressed output when it wants, for 00363 example when the output buffer is full (avail_out == 0), or after each 00364 call of inflate(). If inflate returns Z_OK and with zero avail_out, it 00365 must be called again after making room in the output buffer because there 00366 might be more output pending. 00367 00368 The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, 00369 Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much 00370 output as possible to the output buffer. Z_BLOCK requests that inflate() stop 00371 if and when it get to the next deflate block boundary. When decoding the zlib 00372 or gzip format, this will cause inflate() to return immediately after the 00373 header and before the first block. When doing a raw inflate, inflate() will 00374 go ahead and process the first block, and will return when it gets to the end 00375 of that block, or when it runs out of data. 00376 00377 The Z_BLOCK option assists in appending to or combining deflate streams. 00378 Also to assist in this, on return inflate() will set strm->data_type to the 00379 number of unused bits in the last byte taken from strm->next_in, plus 64 00380 if inflate() is currently decoding the last block in the deflate stream, 00381 plus 128 if inflate() returned immediately after decoding an end-of-block 00382 code or decoding the complete header up to just before the first byte of the 00383 deflate stream. The end-of-block will not be indicated until all of the 00384 uncompressed data from that block has been written to strm->next_out. The 00385 number of unused bits may in general be greater than seven, except when 00386 bit 7 of data_type is set, in which case the number of unused bits will be 00387 less than eight. 00388 00389 inflate() should normally be called until it returns Z_STREAM_END or an 00390 error. However if all decompression is to be performed in a single step 00391 (a single call of inflate), the parameter flush should be set to 00392 Z_FINISH. In this case all pending input is processed and all pending 00393 output is flushed; avail_out must be large enough to hold all the 00394 uncompressed data. (The size of the uncompressed data may have been saved 00395 by the compressor for this purpose.) The next operation on this stream must 00396 be inflateEnd to deallocate the decompression state. The use of Z_FINISH 00397 is never required, but can be used to inform inflate that a faster approach 00398 may be used for the single inflate() call. 00399 00400 In this implementation, inflate() always flushes as much output as 00401 possible to the output buffer, and always uses the faster approach on the 00402 first call. So the only effect of the flush parameter in this implementation 00403 is on the return value of inflate(), as noted below, or when it returns early 00404 because Z_BLOCK is used. 00405 00406 If a preset dictionary is needed after this call (see inflateSetDictionary 00407 below), inflate sets strm->adler to the adler32 checksum of the dictionary 00408 chosen by the compressor and returns Z_NEED_DICT; otherwise it sets 00409 strm->adler to the adler32 checksum of all output produced so far (that is, 00410 total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described 00411 below. At the end of the stream, inflate() checks that its computed adler32 00412 checksum is equal to that saved by the compressor and returns Z_STREAM_END 00413 only if the checksum is correct. 00414 00415 inflate() will decompress and check either zlib-wrapped or gzip-wrapped 00416 deflate data. The header type is detected automatically. Any information 00417 contained in the gzip header is not retained, so applications that need that 00418 information should instead use raw inflate, see inflateInit2() below, or 00419 inflateBack() and perform their own processing of the gzip header and 00420 trailer. 00421 00422 inflate() returns Z_OK if some progress has been made (more input processed 00423 or more output produced), Z_STREAM_END if the end of the compressed data has 00424 been reached and all uncompressed output has been produced, Z_NEED_DICT if a 00425 preset dictionary is needed at this point, Z_DATA_ERROR if the input data was 00426 corrupted (input stream not conforming to the zlib format or incorrect check 00427 value), Z_STREAM_ERROR if the stream structure was inconsistent (for example 00428 if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, 00429 Z_BUF_ERROR if no progress is possible or if there was not enough room in the 00430 output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and 00431 inflate() can be called again with more input and more output space to 00432 continue decompressing. If Z_DATA_ERROR is returned, the application may then 00433 call inflateSync() to look for a good compression block if a partial recovery 00434 of the data is desired. 00435 */ 00436 00437 00438 ZEXTERN INT32 ZEXPORT inflateEnd OF((z_streamp strm)); 00439 /* 00440 All dynamically allocated data structures for this stream are freed. 00441 This function discards any unprocessed input and does not flush any 00442 pending output. 00443 00444 inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state 00445 was inconsistent. In the error case, msg may be set but then points to a 00446 static string (which must not be deallocated). 00447 */ 00448 00449 /* Advanced functions */ 00450 00451 /* 00452 The following functions are needed only in some special applications. 00453 */ 00454 00455 /* 00456 ZEXTERN INT32 ZEXPORT deflateInit2 OF((z_streamp strm, 00457 INT32 level, 00458 INT32 method, 00459 INT32 windowBits, 00460 INT32 memLevel, 00461 INT32 strategy)); 00462 00463 This is another version of deflateInit with more compression options. The 00464 fields next_in, zalloc, zfree and opaque must be initialized before by 00465 the caller. 00466 00467 The method parameter is the compression method. It must be Z_DEFLATED in 00468 this version of the library. 00469 00470 The windowBits parameter is the base two logarithm of the window size 00471 (the size of the history buffer). It should be in the range 8..15 for this 00472 version of the library. Larger values of this parameter result in better 00473 compression at the expense of memory usage. The default value is 15 if 00474 deflateInit is used instead. 00475 00476 windowBits can also be -8..-15 for raw deflate. In this case, -windowBits 00477 determines the window size. deflate() will then generate raw deflate data 00478 with no zlib header or trailer, and will not compute an adler32 check value. 00479 00480 windowBits can also be greater than 15 for optional gzip encoding. Add 00481 16 to windowBits to write a simple gzip header and trailer around the 00482 compressed data instead of a zlib wrapper. The gzip header will have no 00483 file name, no extra data, no comment, no modification time (set to zero), 00484 no header crc, and the operating system will be set to 255 (unknown). If a 00485 gzip stream is being written, strm->adler is a crc32 instead of an adler32. 00486 00487 The memLevel parameter specifies how much memory should be allocated 00488 for the internal compression state. memLevel=1 uses minimum memory but 00489 is slow and reduces compression ratio; memLevel=9 uses maximum memory 00490 for optimal speed. The default value is 8. See zconf.h for total memory 00491 usage as a function of windowBits and memLevel. 00492 00493 The strategy parameter is used to tune the compression algorithm. Use the 00494 value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a 00495 filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no 00496 string match), or Z_RLE to limit match distances to one (run-length 00497 encoding). Filtered data consists mostly of small values with a somewhat 00498 random distribution. In this case, the compression algorithm is tuned to 00499 compress them better. The effect of Z_FILTERED is to force more Huffman 00500 coding and less string matching; it is somewhat intermediate between 00501 Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as 00502 Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy 00503 parameter only affects the compression ratio but not the correctness of the 00504 compressed output even if it is not set appropriately. 00505 00506 deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 00507 memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid 00508 method). msg is set to null if there is no error message. deflateInit2 does 00509 not perform any compression: this will be done by deflate(). 00510 */ 00511 00512 ZEXTERN INT32 ZEXPORT deflateSetDictionary OF((z_streamp strm, 00513 const Bytef *dictionary, 00514 uInt dictLength)); 00515 /* 00516 Initializes the compression dictionary from the given byte sequence 00517 without producing any compressed output. This function must be called 00518 immediately after deflateInit, deflateInit2 or deflateReset, before any 00519 call of deflate. The compressor and decompressor must use exactly the same 00520 dictionary (see inflateSetDictionary). 00521 00522 The dictionary should consist of strings (byte sequences) that are likely 00523 to be encountered later in the data to be compressed, with the most commonly 00524 used strings preferably put towards the end of the dictionary. Using a 00525 dictionary is most useful when the data to be compressed is short and can be 00526 predicted with good accuracy; the data can then be compressed better than 00527 with the default empty dictionary. 00528 00529 Depending on the size of the compression data structures selected by 00530 deflateInit or deflateInit2, a part of the dictionary may in effect be 00531 discarded, for example if the dictionary is larger than the window size in 00532 deflate or deflate2. Thus the strings most likely to be useful should be 00533 put at the end of the dictionary, not at the front. 00534 00535 Upon return of this function, strm->adler is set to the adler32 value 00536 of the dictionary; the decompressor may later use this value to determine 00537 which dictionary has been used by the compressor. (The adler32 value 00538 applies to the whole dictionary even if only a subset of the dictionary is 00539 actually used by the compressor.) If a raw deflate was requested, then the 00540 adler32 value is not computed and strm->adler is not set. 00541 00542 deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a 00543 parameter is invalid (such as NULL dictionary) or the stream state is 00544 inconsistent (for example if deflate has already been called for this stream 00545 or if the compression method is bsort). deflateSetDictionary does not 00546 perform any compression: this will be done by deflate(). 00547 */ 00548 00549 ZEXTERN INT32 ZEXPORT deflateCopy OF((z_streamp dest, 00550 z_streamp source)); 00551 /* 00552 Sets the destination stream as a complete copy of the source stream. 00553 00554 This function can be useful when several compression strategies will be 00555 tried, for example when there are several ways of pre-processing the input 00556 data with a filter. The streams that will be discarded should then be freed 00557 by calling deflateEnd. Note that deflateCopy duplicates the internal 00558 compression state which can be quite large, so this strategy is slow and 00559 can consume lots of memory. 00560 00561 deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not 00562 enough memory, Z_STREAM_ERROR if the source stream state was inconsistent 00563 (such as zalloc being NULL). msg is left unchanged in both source and 00564 destination. 00565 */ 00566 00567 ZEXTERN INT32 ZEXPORT deflateReset OF((z_streamp strm)); 00568 /* 00569 This function is equivalent to deflateEnd followed by deflateInit, 00570 but does not free and reallocate all the internal compression state. 00571 The stream will keep the same compression level and any other attributes 00572 that may have been set by deflateInit2. 00573 00574 deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source 00575 stream state was inconsistent (such as zalloc or state being NULL). 00576 */ 00577 00578 ZEXTERN INT32 ZEXPORT deflateParams OF((z_streamp strm, 00579 INT32 level, 00580 INT32 strategy)); 00581 /* 00582 Dynamically update the compression level and compression strategy. The 00583 interpretation of level and strategy is as in deflateInit2. This can be 00584 used to switch between compression and straight copy of the input data, or 00585 to switch to a different kind of input data requiring a different 00586 strategy. If the compression level is changed, the input available so far 00587 is compressed with the old level (and may be flushed); the new level will 00588 take effect only at the next call of deflate(). 00589 00590 Before the call of deflateParams, the stream state must be set as for 00591 a call of deflate(), since the currently available input may have to 00592 be compressed and flushed. In particular, strm->avail_out must be non-zero. 00593 00594 deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source 00595 stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR 00596 if strm->avail_out was zero. 00597 */ 00598 00599 ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, 00600 uLong sourceLen)); 00601 /* 00602 deflateBound() returns an upper bound on the compressed size after 00603 deflation of sourceLen bytes. It must be called after deflateInit() 00604 or deflateInit2(). This would be used to allocate an output buffer 00605 for deflation in a single pass, and so would be called before deflate(). 00606 */ 00607 00608 ZEXTERN INT32 ZEXPORT deflatePrime OF((z_streamp strm, 00609 INT32 bits, 00610 INT32 value)); 00611 /* 00612 deflatePrime() inserts bits in the deflate output stream. The intent 00613 is that this function is used to start off the deflate output with the 00614 bits leftover from a previous deflate stream when appending to it. As such, 00615 this function can only be used for raw deflate, and must be used before the 00616 first deflate() call after a deflateInit2() or deflateReset(). bits must be 00617 less than or equal to 16, and that many of the least significant bits of 00618 value will be inserted in the output. 00619 00620 deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source 00621 stream state was inconsistent. 00622 */ 00623 00624 /* 00625 ZEXTERN INT32 ZEXPORT inflateInit2 OF((z_streamp strm, 00626 INT32 windowBits)); 00627 00628 This is another version of inflateInit with an extra parameter. The 00629 fields next_in, avail_in, zalloc, zfree and opaque must be initialized 00630 before by the caller. 00631 00632 The windowBits parameter is the base two logarithm of the maximum window 00633 size (the size of the history buffer). It should be in the range 8..15 for 00634 this version of the library. The default value is 15 if inflateInit is used 00635 instead. windowBits must be greater than or equal to the windowBits value 00636 provided to deflateInit2() while compressing, or it must be equal to 15 if 00637 deflateInit2() was not used. If a compressed stream with a larger window 00638 size is given as input, inflate() will return with the error code 00639 Z_DATA_ERROR instead of trying to allocate a larger window. 00640 00641 windowBits can also be -8..-15 for raw inflate. In this case, -windowBits 00642 determines the window size. inflate() will then process raw deflate data, 00643 not looking for a zlib or gzip header, not generating a check value, and not 00644 looking for any check values for comparison at the end of the stream. This 00645 is for use with other formats that use the deflate compressed data format 00646 such as zip. Those formats provide their own check values. If a custom 00647 format is developed using the raw deflate format for compressed data, it is 00648 recommended that a check value such as an adler32 or a crc32 be applied to 00649 the uncompressed data as is done in the zlib, gzip, and zip formats. For 00650 most applications, the zlib format should be used as is. Note that comments 00651 above on the use in deflateInit2() applies to the magnitude of windowBits. 00652 00653 windowBits can also be greater than 15 for optional gzip decoding. Add 00654 32 to windowBits to enable zlib and gzip decoding with automatic header 00655 detection, or add 16 to decode only the gzip format (the zlib format will 00656 return a Z_DATA_ERROR. If a gzip stream is being decoded, strm->adler is 00657 a crc32 instead of an adler32. 00658 00659 inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 00660 memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative 00661 memLevel). msg is set to null if there is no error message. inflateInit2 00662 does not perform any decompression apart from reading the zlib header if 00663 present: this will be done by inflate(). (So next_in and avail_in may be 00664 modified, but next_out and avail_out are unchanged.) 00665 */ 00666 00667 ZEXTERN INT32 ZEXPORT inflateSetDictionary OF((z_streamp strm, 00668 const Bytef *dictionary, 00669 uInt dictLength)); 00670 /* 00671 Initializes the decompression dictionary from the given uncompressed byte 00672 sequence. This function must be called immediately after a call of inflate 00673 if this call returned Z_NEED_DICT. The dictionary chosen by the compressor 00674 can be determined from the adler32 value returned by this call of 00675 inflate. The compressor and decompressor must use exactly the same 00676 dictionary (see deflateSetDictionary). 00677 00678 inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a 00679 parameter is invalid (such as NULL dictionary) or the stream state is 00680 inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the 00681 expected one (incorrect adler32 value). inflateSetDictionary does not 00682 perform any decompression: this will be done by subsequent calls of 00683 inflate(). 00684 */ 00685 00686 ZEXTERN INT32 ZEXPORT inflateSync OF((z_streamp strm)); 00687 /* 00688 Skips invalid compressed data until a full flush point (see above the 00689 description of deflate with Z_FULL_FLUSH) can be found, or until all 00690 available input is skipped. No output is provided. 00691 00692 inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR 00693 if no more input was provided, Z_DATA_ERROR if no flush point has been found, 00694 or Z_STREAM_ERROR if the stream structure was inconsistent. In the success 00695 case, the application may save the current current value of total_in which 00696 indicates where valid compressed data was found. In the error case, the 00697 application may repeatedly call inflateSync, providing more input each time, 00698 until success or end of the input data. 00699 */ 00700 00701 ZEXTERN INT32 ZEXPORT inflateCopy OF((z_streamp dest, 00702 z_streamp source)); 00703 /* 00704 Sets the destination stream as a complete copy of the source stream. 00705 00706 This function can be useful when randomly accessing a large stream. The 00707 first pass through the stream can periodically record the inflate state, 00708 allowing restarting inflate at those points when randomly accessing the 00709 stream. 00710 00711 inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not 00712 enough memory, Z_STREAM_ERROR if the source stream state was inconsistent 00713 (such as zalloc being NULL). msg is left unchanged in both source and 00714 destination. 00715 */ 00716 00717 ZEXTERN INT32 ZEXPORT inflateReset OF((z_streamp strm)); 00718 /* 00719 This function is equivalent to inflateEnd followed by inflateInit, 00720 but does not free and reallocate all the internal decompression state. 00721 The stream will keep attributes that may have been set by inflateInit2. 00722 00723 inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source 00724 stream state was inconsistent (such as zalloc or state being NULL). 00725 */ 00726 00727 /* 00728 ZEXTERN INT32 ZEXPORT inflateBackInit OF((z_stream FAR *strm, INT32 windowBits, 00729 unsigned char FAR *window)); 00730 00731 Initialize the internal stream state for decompression using inflateBack() 00732 calls. The fields zalloc, zfree and opaque in strm must be initialized 00733 before the call. If zalloc and zfree are Z_NULL, then the default library- 00734 derived memory allocation routines are used. windowBits is the base two 00735 logarithm of the window size, in the range 8..15. window is a caller 00736 supplied buffer of that size. Except for special applications where it is 00737 assured that deflate was used with small window sizes, windowBits must be 15 00738 and a 32K byte window must be supplied to be able to decompress general 00739 deflate streams. 00740 00741 See inflateBack() for the usage of these routines. 00742 00743 inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of 00744 the paramaters are invalid, Z_MEM_ERROR if the internal state could not 00745 be allocated, or Z_VERSION_ERROR if the version of the library does not 00746 match the version of the header file. 00747 */ 00748 00749 typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); 00750 typedef INT32 (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); 00751 00752 ZEXTERN INT32 ZEXPORT inflateBack OF((z_stream FAR *strm, 00753 in_func in, void FAR *in_desc, 00754 out_func out, void FAR *out_desc)); 00755 /* 00756 inflateBack() does a raw inflate with a single call using a call-back 00757 interface for input and output. This is more efficient than inflate() for 00758 file i/o applications in that it avoids copying between the output and the 00759 sliding window by simply making the window itself the output buffer. This 00760 function trusts the application to not change the output buffer passed by 00761 the output function, at least until inflateBack() returns. 00762 00763 inflateBackInit() must be called first to allocate the internal state 00764 and to initialize the state with the user-provided window buffer. 00765 inflateBack() may then be used multiple times to inflate a complete, raw 00766 deflate stream with each call. inflateBackEnd() is then called to free 00767 the allocated state. 00768 00769 A raw deflate stream is one with no zlib or gzip header or trailer. 00770 This routine would normally be used in a utility that reads zip or gzip 00771 files and writes out uncompressed files. The utility would decode the 00772 header and process the trailer on its own, hence this routine expects 00773 only the raw deflate stream to decompress. This is different from the 00774 normal behavior of inflate(), which expects either a zlib or gzip header and 00775 trailer around the deflate stream. 00776 00777 inflateBack() uses two subroutines supplied by the caller that are then 00778 called by inflateBack() for input and output. inflateBack() calls those 00779 routines until it reads a complete deflate stream and writes out all of the 00780 uncompressed data, or until it encounters an error. The function's 00781 parameters and return types are defined above in the in_func and out_func 00782 typedefs. inflateBack() will call in(in_desc, &buf) which should return the 00783 number of bytes of provided input, and a pointer to that input in buf. If 00784 there is no input available, in() must return zero--buf is ignored in that 00785 case--and inflateBack() will return a buffer error. inflateBack() will call 00786 out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() 00787 should return zero on success, or non-zero on failure. If out() returns 00788 non-zero, inflateBack() will return with an error. Neither in() nor out() 00789 are permitted to change the contents of the window provided to 00790 inflateBackInit(), which is also the buffer that out() uses to write from. 00791 The length written by out() will be at most the window size. Any non-zero 00792 amount of input may be provided by in(). 00793 00794 For convenience, inflateBack() can be provided input on the first call by 00795 setting strm->next_in and strm->avail_in. If that input is exhausted, then 00796 in() will be called. Therefore strm->next_in must be initialized before 00797 calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called 00798 immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in 00799 must also be initialized, and then if strm->avail_in is not zero, input will 00800 initially be taken from strm->next_in[0 .. strm->avail_in - 1]. 00801 00802 The in_desc and out_desc parameters of inflateBack() is passed as the 00803 first parameter of in() and out() respectively when they are called. These 00804 descriptors can be optionally used to pass any information that the caller- 00805 supplied in() and out() functions need to do their job. 00806 00807 On return, inflateBack() will set strm->next_in and strm->avail_in to 00808 pass back any unused input that was provided by the last in() call. The 00809 return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR 00810 if in() or out() returned an error, Z_DATA_ERROR if there was a format 00811 error in the deflate stream (in which case strm->msg is set to indicate the 00812 nature of the error), or Z_STREAM_ERROR if the stream was not properly 00813 initialized. In the case of Z_BUF_ERROR, an input or output error can be 00814 distinguished using strm->next_in which will be Z_NULL only if in() returned 00815 an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to 00816 out() returning non-zero. (in() will always be called before out(), so 00817 strm->next_in is assured to be defined if out() returns non-zero.) Note 00818 that inflateBack() cannot return Z_OK. 00819 */ 00820 00821 ZEXTERN INT32 ZEXPORT inflateBackEnd OF((z_stream FAR *strm)); 00822 /* 00823 All memory allocated by inflateBackInit() is freed. 00824 00825 inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream 00826 state was inconsistent. 00827 */ 00828 00829 ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); 00830 /* Return flags indicating compile-time options. 00831 00832 Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: 00833 1.0: size of uInt 00834 3.2: size of uLong 00835 5.4: size of voidpf (pointer) 00836 7.6: size of z_off_t 00837 00838 Compiler, assembler, and debug options: 00839 8: DEBUG 00840 9: ASMV or ASMINF -- use ASM code 00841 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention 00842 11: 0 (reserved) 00843 00844 One-time table building (smaller code, but not thread-safe if true): 00845 12: BUILDFIXED -- build static block decoding tables when needed 00846 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed 00847 14,15: 0 (reserved) 00848 00849 Library content (indicates missing functionality): 00850 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking 00851 deflate code when not needed) 00852 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect 00853 and decode gzip streams (to avoid linking crc code) 00854 18-19: 0 (reserved) 00855 00856 Operation variations (changes in library functionality): 00857 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate 00858 21: FASTEST -- deflate algorithm with only one, lowest compression level 00859 22,23: 0 (reserved) 00860 00861 The sprintf variant used by gzprintf (zero is best): 00862 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format 00863 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! 00864 26: 0 = returns value, 1 = void -- 1 means inferred string length returned 00865 00866 Remainder: 00867 27-31: 0 (reserved) 00868 */ 00869 00870 00871 /* utility functions */ 00872 00873 /* 00874 The following utility functions are implemented on top of the 00875 basic stream-oriented functions. To simplify the interface, some 00876 default options are assumed (compression level and memory usage, 00877 standard memory allocation functions). The source code of these 00878 utility functions can easily be modified if you need special options. 00879 */ 00880 00881 ZEXTERN INT32 ZEXPORT compress OF((Bytef *dest, uLongf *destLen, 00882 const Bytef *source, uLong sourceLen)); 00883 /* 00884 Compresses the source buffer into the destination buffer. sourceLen is 00885 the byte length of the source buffer. Upon entry, destLen is the total 00886 size of the destination buffer, which must be at least the value returned 00887 by compressBound(sourceLen). Upon exit, destLen is the actual size of the 00888 compressed buffer. 00889 This function can be used to compress a whole file at once if the 00890 input file is mmap'ed. 00891 compress returns Z_OK if success, Z_MEM_ERROR if there was not 00892 enough memory, Z_BUF_ERROR if there was not enough room in the output 00893 buffer. 00894 */ 00895 00896 ZEXTERN INT32 ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, 00897 const Bytef *source, uLong sourceLen, 00898 INT32 level)); 00899 /* 00900 Compresses the source buffer into the destination buffer. The level 00901 parameter has the same meaning as in deflateInit. sourceLen is the byte 00902 length of the source buffer. Upon entry, destLen is the total size of the 00903 destination buffer, which must be at least the value returned by 00904 compressBound(sourceLen). Upon exit, destLen is the actual size of the 00905 compressed buffer. 00906 00907 compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 00908 memory, Z_BUF_ERROR if there was not enough room in the output buffer, 00909 Z_STREAM_ERROR if the level parameter is invalid. 00910 */ 00911 00912 ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); 00913 /* 00914 compressBound() returns an upper bound on the compressed size after 00915 compress() or compress2() on sourceLen bytes. It would be used before 00916 a compress() or compress2() call to allocate the destination buffer. 00917 */ 00918 00919 ZEXTERN INT32 ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, 00920 const Bytef *source, uLong sourceLen)); 00921 /* 00922 Decompresses the source buffer into the destination buffer. sourceLen is 00923 the byte length of the source buffer. Upon entry, destLen is the total 00924 size of the destination buffer, which must be large enough to hold the 00925 entire uncompressed data. (The size of the uncompressed data must have 00926 been saved previously by the compressor and transmitted to the decompressor 00927 by some mechanism outside the scope of this compression library.) 00928 Upon exit, destLen is the actual size of the compressed buffer. 00929 This function can be used to decompress a whole file at once if the 00930 input file is mmap'ed. 00931 00932 uncompress returns Z_OK if success, Z_MEM_ERROR if there was not 00933 enough memory, Z_BUF_ERROR if there was not enough room in the output 00934 buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. 00935 */ 00936 00937 00938 typedef voidp gzFile; 00939 00940 ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); 00941 /* 00942 Opens a gzip (.gz) file for reading or writing. The mode parameter 00943 is as in fopen ("rb" or "wb") but can also include a compression level 00944 ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for 00945 Huffman only compression as in "wb1h", or 'R' for run-length encoding 00946 as in "wb1R". (See the description of deflateInit2 for more information 00947 about the strategy parameter.) 00948 00949 gzopen can be used to read a file which is not in gzip format; in this 00950 case gzread will directly read from the file without decompression. 00951 00952 gzopen returns NULL if the file could not be opened or if there was 00953 insufficient memory to allocate the (de)compression state; errno 00954 can be checked to distinguish the two cases (if errno is zero, the 00955 zlib error is Z_MEM_ERROR). */ 00956 00957 ZEXTERN gzFile ZEXPORT gzdopen OF((INT32 fd, const char *mode)); 00958 /* 00959 gzdopen() associates a gzFile with the file descriptor fd. File 00960 descriptors are obtained from calls like open, dup, creat, pipe or 00961 fileno (in the file has been previously opened with fopen). 00962 The mode parameter is as in gzopen. 00963 The next call of gzclose on the returned gzFile will also close the 00964 file descriptor fd, just like fclose(fdopen(fd), mode) closes the file 00965 descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). 00966 gzdopen returns NULL if there was insufficient memory to allocate 00967 the (de)compression state. 00968 */ 00969 00970 ZEXTERN INT32 ZEXPORT gzsetparams OF((gzFile file, INT32 level, INT32 strategy)); 00971 /* 00972 Dynamically update the compression level or strategy. See the description 00973 of deflateInit2 for the meaning of these parameters. 00974 gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not 00975 opened for writing. 00976 */ 00977 00978 ZEXTERN INT32 ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); 00979 /* 00980 Reads the given number of uncompressed bytes from the compressed file. 00981 If the input file was not in gzip format, gzread copies the given number 00982 of bytes into the buffer. 00983 gzread returns the number of uncompressed bytes actually read (0 for 00984 end of file, -1 for error). */ 00985 00986 ZEXTERN INT32 ZEXPORT gzwrite OF((gzFile file, 00987 voidpc buf, unsigned len)); 00988 /* 00989 Writes the given number of uncompressed bytes into the compressed file. 00990 gzwrite returns the number of uncompressed bytes actually written 00991 (0 in case of error). 00992 */ 00993 00994 ZEXTERN INT32 ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); 00995 /* 00996 Converts, formats, and writes the args to the compressed file under 00997 control of the format string, as in fprintf. gzprintf returns the number of 00998 uncompressed bytes actually written (0 in case of error). The number of 00999 uncompressed bytes written is limited to 4095. The caller should assure that 01000 this limit is not exceeded. If it is exceeded, then gzprintf() will return 01001 return an error (0) with nothing written. In this case, there may also be a 01002 buffer overflow with unpredictable consequences, which is possible only if 01003 zlib was compiled with the insecure functions sprintf() or vsprintf() 01004 because the secure snprintf() or vsnprintf() functions were not available. 01005 */ 01006 01007 ZEXTERN INT32 ZEXPORT gzputs OF((gzFile file, const char *s)); 01008 /* 01009 Writes the given null-terminated string to the compressed file, excluding 01010 the terminating null character. 01011 gzputs returns the number of characters written, or -1 in case of error. 01012 */ 01013 01014 ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, INT32 len)); 01015 /* 01016 Reads bytes from the compressed file until len-1 characters are read, or 01017 a newline character is read and transferred to buf, or an end-of-file 01018 condition is encountered. The string is then terminated with a null 01019 character. 01020 gzgets returns buf, or Z_NULL in case of error. 01021 */ 01022 01023 ZEXTERN INT32 ZEXPORT gzputc OF((gzFile file, INT32 c)); 01024 /* 01025 Writes c, converted to an unsigned char, into the compressed file. 01026 gzputc returns the value that was written, or -1 in case of error. 01027 */ 01028 01029 ZEXTERN INT32 ZEXPORT gzgetc OF((gzFile file)); 01030 /* 01031 Reads one byte from the compressed file. gzgetc returns this byte 01032 or -1 in case of end of file or error. 01033 */ 01034 01035 ZEXTERN INT32 ZEXPORT gzungetc OF((INT32 c, gzFile file)); 01036 /* 01037 Push one character back onto the stream to be read again later. 01038 Only one character of push-back is allowed. gzungetc() returns the 01039 character pushed, or -1 on failure. gzungetc() will fail if a 01040 character has been pushed but not read yet, or if c is -1. The pushed 01041 character will be discarded if the stream is repositioned with gzseek() 01042 or gzrewind(). 01043 */ 01044 01045 ZEXTERN INT32 ZEXPORT gzflush OF((gzFile file, INT32 flush)); 01046 /* 01047 Flushes all pending output into the compressed file. The parameter 01048 flush is as in the deflate() function. The return value is the zlib 01049 error number (see function gzerror below). gzflush returns Z_OK if 01050 the flush parameter is Z_FINISH and all output could be flushed. 01051 gzflush should be called only when strictly necessary because it can 01052 degrade compression. 01053 */ 01054 01055 ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, 01056 z_off_t offset, INT32 whence)); 01057 /* 01058 Sets the starting position for the next gzread or gzwrite on the 01059 given compressed file. The offset represents a number of bytes in the 01060 uncompressed data stream. The whence parameter is defined as in lseek(2); 01061 the value SEEK_END is not supported. 01062 If the file is opened for reading, this function is emulated but can be 01063 extremely slow. If the file is opened for writing, only forward seeks are 01064 supported; gzseek then compresses a sequence of zeroes up to the new 01065 starting position. 01066 01067 gzseek returns the resulting offset location as measured in bytes from 01068 the beginning of the uncompressed stream, or -1 in case of error, in 01069 particular if the file is opened for writing and the new starting position 01070 would be before the current position. 01071 */ 01072 01073 ZEXTERN INT32 ZEXPORT gzrewind OF((gzFile file)); 01074 /* 01075 Rewinds the given file. This function is supported only for reading. 01076 01077 gzrewind(file) is equivalent to (INT32)gzseek(file, 0L, SEEK_SET) 01078 */ 01079 01080 ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); 01081 /* 01082 Returns the starting position for the next gzread or gzwrite on the 01083 given compressed file. This position represents a number of bytes in the 01084 uncompressed data stream. 01085 01086 gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) 01087 */ 01088 01089 ZEXTERN INT32 ZEXPORT gzeof OF((gzFile file)); 01090 /* 01091 Returns 1 when EOF has previously been detected reading the given 01092 input stream, otherwise zero. 01093 */ 01094 01095 ZEXTERN INT32 ZEXPORT gzclose OF((gzFile file)); 01096 /* 01097 Flushes all pending output if necessary, closes the compressed file 01098 and deallocates all the (de)compression state. The return value is the zlib 01099 error number (see function gzerror below). 01100 */ 01101 01102 ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, INT32 *errnum)); 01103 /* 01104 Returns the error message for the last error which occurred on the 01105 given compressed file. errnum is set to zlib error number. If an 01106 error occurred in the file system and not in the compression library, 01107 errnum is set to Z_ERRNO and the application may consult errno 01108 to get the exact error code. 01109 */ 01110 01111 ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); 01112 /* 01113 Clears the error and end-of-file flags for file. This is analogous to the 01114 clearerr() function in stdio. This is useful for continuing to read a gzip 01115 file that is being written concurrently. 01116 */ 01117 01118 /* checksum functions */ 01119 01120 /* 01121 These functions are not related to compression but are exported 01122 anyway because they might be useful in applications using the 01123 compression library. 01124 */ 01125 01126 ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); 01127 01128 /* 01129 Update a running Adler-32 checksum with the bytes buf[0..len-1] and 01130 return the updated checksum. If buf is NULL, this function returns 01131 the required initial value for the checksum. 01132 An Adler-32 checksum is almost as reliable as a CRC32 but can be computed 01133 much faster. Usage example: 01134 01135 uLong adler = adler32(0L, Z_NULL, 0); 01136 01137 while (read_buffer(buffer, length) != EOF) { 01138 adler = adler32(adler, buffer, length); 01139 } 01140 if (adler != original_adler) error(); 01141 */ 01142 01143 ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); 01144 /* 01145 Update a running crc with the bytes buf[0..len-1] and return the updated 01146 crc. If buf is NULL, this function returns the required initial value 01147 for the crc. Pre- and post-conditioning (one's complement) is performed 01148 within this function so it shouldn't be done by the application. 01149 Usage example: 01150 01151 uLong crc = crc32(0L, Z_NULL, 0); 01152 01153 while (read_buffer(buffer, length) != EOF) { 01154 crc = crc32(crc, buffer, length); 01155 } 01156 if (crc != original_crc) error(); 01157 */ 01158 01159 01160 /* various hacks, don't look :) */ 01161 01162 /* deflateInit and inflateInit are macros to allow checking the zlib version 01163 * and the compiler's view of z_stream: 01164 */ 01165 ZEXTERN INT32 ZEXPORT deflateInit_ OF((z_streamp strm, INT32 level, 01166 const char *version, INT32 stream_size)); 01167 ZEXTERN INT32 ZEXPORT inflateInit_ OF((z_streamp strm, 01168 const char *version, INT32 stream_size)); 01169 ZEXTERN INT32 ZEXPORT deflateInit2_ OF((z_streamp strm, INT32 level, INT32 method, 01170 INT32 windowBits, INT32 memLevel, 01171 INT32 strategy, const char *version, 01172 INT32 stream_size)); 01173 ZEXTERN INT32 ZEXPORT inflateInit2_ OF((z_streamp strm, INT32 windowBits, 01174 const char *version, INT32 stream_size)); 01175 ZEXTERN INT32 ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, INT32 windowBits, 01176 unsigned char FAR *window, 01177 const char *version, 01178 INT32 stream_size)); 01179 #define deflateInit(strm, level) \ 01180 deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) 01181 #define inflateInit(strm) \ 01182 inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) 01183 #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ 01184 deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ 01185 (strategy), ZLIB_VERSION, sizeof(z_stream)) 01186 #define inflateInit2(strm, windowBits) \ 01187 inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) 01188 #define inflateBackInit(strm, windowBits, window) \ 01189 inflateBackInit_((strm), (windowBits), (window), \ 01190 ZLIB_VERSION, sizeof(z_stream)) 01191 01192 01193 #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) 01194 struct internal_state {INT32 dummy;}; /* hack for buggy compilers */ 01195 #endif 01196 01197 ZEXTERN const char * ZEXPORT zError OF((INT32)); 01198 ZEXTERN INT32 ZEXPORT inflateSyncPoint OF((z_streamp z)); 01199 ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); 01200 01201 #ifdef __cplusplus 01202 } 01203 #endif 01204 01205 #endif /* ZLIB_H */