| 1 | /* $Id$ */ |
| 2 | |
| 3 | /* |
| 4 | * This file is derived from zlib.h and zconf.h from the zlib-0.95 |
| 5 | * distribution by Jean-loup Gailly and Mark Adler, with some additions |
| 6 | * by Paul Mackerras to aid in implementing Deflate compression and |
| 7 | * decompression for PPP packets. |
| 8 | */ |
| 9 | |
| 10 | /* zlib.h -- interface of the 'zlib' general purpose compression library |
| 11 | version 0.95, Aug 16th, 1995. |
| 12 | |
| 13 | Copyright (C) 1995 Jean-loup Gailly and Mark Adler |
| 14 | |
| 15 | This software is provided 'as-is', without any express or implied |
| 16 | warranty. In no event will the authors be held liable for any damages |
| 17 | arising from the use of this software. |
| 18 | |
| 19 | Permission is granted to anyone to use this software for any purpose, |
| 20 | including commercial applications, and to alter it and redistribute it |
| 21 | freely, subject to the following restrictions: |
| 22 | |
| 23 | 1. The origin of this software must not be misrepresented; you must not |
| 24 | claim that you wrote the original software. If you use this software |
| 25 | in a product, an acknowledgment in the product documentation would be |
| 26 | appreciated but is not required. |
| 27 | 2. Altered source versions must be plainly marked as such, and must not be |
| 28 | misrepresented as being the original software. |
| 29 | 3. This notice may not be removed or altered from any source distribution. |
| 30 | |
| 31 | Jean-loup Gailly Mark Adler |
| 32 | gzip@prep.ai.mit.edu madler@alumni.caltech.edu |
| 33 | */ |
| 34 | |
| 35 | #ifndef _ZLIB_H |
| 36 | #define _ZLIB_H |
| 37 | |
| 38 | /* #include "zconf.h" */ /* included directly here */ |
| 39 | |
| 40 | /* zconf.h -- configuration of the zlib compression library |
| 41 | * Copyright (C) 1995 Jean-loup Gailly. |
| 42 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 43 | */ |
| 44 | |
| 45 | /* From: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp */ |
| 46 | |
| 47 | /* |
| 48 | The library does not install any signal handler. It is recommended to |
| 49 | add at least a handler for SIGSEGV when decompressing; the library checks |
| 50 | the consistency of the input data whenever possible but may go nuts |
| 51 | for some forms of corrupted input. |
| 52 | */ |
| 53 | |
| 54 | /* |
| 55 | * Compile with -DMAXSEG_64K if the alloc function cannot allocate more |
| 56 | * than 64k bytes at a time (needed on systems with 16-bit int). |
| 57 | * Compile with -DUNALIGNED_OK if it is OK to access shorts or ints |
| 58 | * at addresses which are not a multiple of their size. |
| 59 | * Under DOS, -DFAR=far or -DFAR=__far may be needed. |
| 60 | */ |
| 61 | |
| 62 | #ifndef STDC |
| 63 | # if defined(MSDOS) || defined(__STDC__) || defined(__cplusplus) |
| 64 | # define STDC |
| 65 | # endif |
| 66 | #endif |
| 67 | |
| 68 | #ifdef __MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */ |
| 69 | # include <unix.h> |
| 70 | #endif |
| 71 | |
| 72 | /* Maximum value for memLevel in deflateInit2 */ |
| 73 | #ifndef MAX_MEM_LEVEL |
| 74 | # ifdef MAXSEG_64K |
| 75 | # define MAX_MEM_LEVEL 8 |
| 76 | # else |
| 77 | # define MAX_MEM_LEVEL 9 |
| 78 | # endif |
| 79 | #endif |
| 80 | |
| 81 | #ifndef FAR |
| 82 | # define FAR |
| 83 | #endif |
| 84 | |
| 85 | /* Maximum value for windowBits in deflateInit2 and inflateInit2 */ |
| 86 | #ifndef MAX_WBITS |
| 87 | # define MAX_WBITS 15 /* 32K LZ77 window */ |
| 88 | #endif |
| 89 | |
| 90 | /* The memory requirements for deflate are (in bytes): |
| 91 | 1 << (windowBits+2) + 1 << (memLevel+9) |
| 92 | that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) |
| 93 | plus a few kilobytes for small objects. For example, if you want to reduce |
| 94 | the default memory requirements from 256K to 128K, compile with |
| 95 | make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" |
| 96 | Of course this will generally degrade compression (there's no free lunch). |
| 97 | |
| 98 | The memory requirements for inflate are (in bytes) 1 << windowBits |
| 99 | that is, 32K for windowBits=15 (default value) plus a few kilobytes |
| 100 | for small objects. |
| 101 | */ |
| 102 | |
| 103 | /* Type declarations */ |
| 104 | |
| 105 | #ifndef OF /* function prototypes */ |
| 106 | # ifdef STDC |
| 107 | # define OF(args) args |
| 108 | # else |
| 109 | # define OF(args) () |
| 110 | # endif |
| 111 | #endif |
| 112 | |
| 113 | typedef unsigned char Byte; /* 8 bits */ |
| 114 | typedef unsigned int uInt; /* 16 bits or more */ |
| 115 | typedef unsigned long uLong; /* 32 bits or more */ |
| 116 | |
| 117 | typedef Byte FAR Bytef; |
| 118 | typedef char FAR charf; |
| 119 | typedef int FAR intf; |
| 120 | typedef uInt FAR uIntf; |
| 121 | typedef uLong FAR uLongf; |
| 122 | |
| 123 | #ifdef STDC |
| 124 | typedef void FAR *voidpf; |
| 125 | typedef void *voidp; |
| 126 | #else |
| 127 | typedef Byte FAR *voidpf; |
| 128 | typedef Byte *voidp; |
| 129 | #endif |
| 130 | |
| 131 | /* end of original zconf.h */ |
| 132 | |
| 133 | #define ZLIB_VERSION "0.95P" |
| 134 | |
| 135 | /* |
| 136 | The 'zlib' compression library provides in-memory compression and |
| 137 | decompression functions, including integrity checks of the uncompressed |
| 138 | data. This version of the library supports only one compression method |
| 139 | (deflation) but other algorithms may be added later and will have the same |
| 140 | stream interface. |
| 141 | |
| 142 | For compression the application must provide the output buffer and |
| 143 | may optionally provide the input buffer for optimization. For decompression, |
| 144 | the application must provide the input buffer and may optionally provide |
| 145 | the output buffer for optimization. |
| 146 | |
| 147 | Compression can be done in a single step if the buffers are large |
| 148 | enough (for example if an input file is mmap'ed), or can be done by |
| 149 | repeated calls of the compression function. In the latter case, the |
| 150 | application must provide more input and/or consume the output |
| 151 | (providing more output space) before each call. |
| 152 | */ |
| 153 | |
| 154 | typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); |
| 155 | typedef void (*free_func) OF((voidpf opaque, voidpf address, uInt nbytes)); |
| 156 | |
| 157 | struct internal_state; |
| 158 | |
| 159 | typedef struct z_stream_s { |
| 160 | Bytef *next_in; /* next input byte */ |
| 161 | uInt avail_in; /* number of bytes available at next_in */ |
| 162 | uLong total_in; /* total nb of input bytes read so far */ |
| 163 | |
| 164 | Bytef *next_out; /* next output byte should be put there */ |
| 165 | uInt avail_out; /* remaining free space at next_out */ |
| 166 | uLong total_out; /* total nb of bytes output so far */ |
| 167 | |
| 168 | char *msg; /* last error message, NULL if no error */ |
| 169 | struct internal_state FAR *state; /* not visible by applications */ |
| 170 | |
| 171 | alloc_func zalloc; /* used to allocate the internal state */ |
| 172 | free_func zfree; /* used to free the internal state */ |
| 173 | voidp opaque; /* private data object passed to zalloc and zfree */ |
| 174 | |
| 175 | Byte data_type; /* best guess about the data type: ascii or binary */ |
| 176 | |
| 177 | } z_stream; |
| 178 | |
| 179 | /* |
| 180 | The application must update next_in and avail_in when avail_in has |
| 181 | dropped to zero. It must update next_out and avail_out when avail_out |
| 182 | has dropped to zero. The application must initialize zalloc, zfree and |
| 183 | opaque before calling the init function. All other fields are set by the |
| 184 | compression library and must not be updated by the application. |
| 185 | |
| 186 | The opaque value provided by the application will be passed as the first |
| 187 | parameter for calls of zalloc and zfree. This can be useful for custom |
| 188 | memory management. The compression library attaches no meaning to the |
| 189 | opaque value. |
| 190 | |
| 191 | zalloc must return Z_NULL if there is not enough memory for the object. |
| 192 | On 16-bit systems, the functions zalloc and zfree must be able to allocate |
| 193 | exactly 65536 bytes, but will not be required to allocate more than this |
| 194 | if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, |
| 195 | pointers returned by zalloc for objects of exactly 65536 bytes *must* |
| 196 | have their offset normalized to zero. The default allocation function |
| 197 | provided by this library ensures this (see zutil.c). To reduce memory |
| 198 | requirements and avoid any allocation of 64K objects, at the expense of |
| 199 | compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). |
| 200 | |
| 201 | The fields total_in and total_out can be used for statistics or |
| 202 | progress reports. After compression, total_in holds the total size of |
| 203 | the uncompressed data and may be saved for use in the decompressor |
| 204 | (particularly if the decompressor wants to decompress everything in |
| 205 | a single step). |
| 206 | */ |
| 207 | |
| 208 | /* constants */ |
| 209 | |
| 210 | #define Z_NO_FLUSH 0 |
| 211 | #define Z_PARTIAL_FLUSH 1 |
| 212 | #define Z_FULL_FLUSH 2 |
| 213 | #define Z_SYNC_FLUSH 3 /* experimental: partial_flush + byte align */ |
| 214 | #define Z_FINISH 4 |
| 215 | #define Z_PACKET_FLUSH 5 |
| 216 | #define Z_INSERT_ONLY 6 /* update hash table etc., produce no output */ |
| 217 | /* See deflate() below for the usage of these constants */ |
| 218 | |
| 219 | #define Z_OK 0 |
| 220 | #define Z_STREAM_END 1 |
| 221 | #define Z_ERRNO (-1) |
| 222 | #define Z_STREAM_ERROR (-2) |
| 223 | #define Z_DATA_ERROR (-3) |
| 224 | #define Z_MEM_ERROR (-4) |
| 225 | #define Z_BUF_ERROR (-5) |
| 226 | /* error codes for the compression/decompression functions */ |
| 227 | |
| 228 | #define Z_BEST_SPEED 1 |
| 229 | #define Z_BEST_COMPRESSION 9 |
| 230 | #define Z_DEFAULT_COMPRESSION (-1) |
| 231 | /* compression levels */ |
| 232 | |
| 233 | #define Z_FILTERED 1 |
| 234 | #define Z_HUFFMAN_ONLY 2 |
| 235 | #define Z_DEFAULT_STRATEGY 0 |
| 236 | |
| 237 | #define Z_BINARY 0 |
| 238 | #define Z_ASCII 1 |
| 239 | #define Z_UNKNOWN 2 |
| 240 | /* Used to set the data_type field */ |
| 241 | |
| 242 | #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ |
| 243 | |
| 244 | extern char *zlib_version; |
| 245 | /* The application can compare zlib_version and ZLIB_VERSION for consistency. |
| 246 | If the first character differs, the library code actually used is |
| 247 | not compatible with the zlib.h header file used by the application. |
| 248 | */ |
| 249 | |
| 250 | /* basic functions */ |
| 251 | |
| 252 | extern int deflateInit OF((z_stream *strm, int level)); |
| 253 | /* |
| 254 | Initializes the internal stream state for compression. The fields |
| 255 | zalloc, zfree and opaque must be initialized before by the caller. |
| 256 | If zalloc and zfree are set to Z_NULL, deflateInit updates them to |
| 257 | use default allocation functions. |
| 258 | |
| 259 | The compression level must be Z_DEFAULT_COMPRESSION, or between 1 and 9: |
| 260 | 1 gives best speed, 9 gives best compression. Z_DEFAULT_COMPRESSION requests |
| 261 | a default compromise between speed and compression (currently equivalent |
| 262 | to level 6). |
| 263 | |
| 264 | deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not |
| 265 | enough memory, Z_STREAM_ERROR if level is not a valid compression level. |
| 266 | msg is set to null if there is no error message. deflateInit does not |
| 267 | perform any compression: this will be done by deflate(). |
| 268 | */ |
| 269 | |
| 270 | |
| 271 | extern int deflate OF((z_stream *strm, int flush)); |
| 272 | /* |
| 273 | Performs one or both of the following actions: |
| 274 | |
| 275 | - Compress more input starting at next_in and update next_in and avail_in |
| 276 | accordingly. If not all input can be processed (because there is not |
| 277 | enough room in the output buffer), next_in and avail_in are updated and |
| 278 | processing will resume at this point for the next call of deflate(). |
| 279 | |
| 280 | - Provide more output starting at next_out and update next_out and avail_out |
| 281 | accordingly. This action is forced if the parameter flush is non zero. |
| 282 | Forcing flush frequently degrades the compression ratio, so this parameter |
| 283 | should be set only when necessary (in interactive applications). |
| 284 | Some output may be provided even if flush is not set. |
| 285 | |
| 286 | Before the call of deflate(), the application should ensure that at least |
| 287 | one of the actions is possible, by providing more input and/or consuming |
| 288 | more output, and updating avail_in or avail_out accordingly; avail_out |
| 289 | should never be zero before the call. The application can consume the |
| 290 | compressed output when it wants, for example when the output buffer is full |
| 291 | (avail_out == 0), or after each call of deflate(). |
| 292 | |
| 293 | If the parameter flush is set to Z_PARTIAL_FLUSH, the current compression |
| 294 | block is terminated and flushed to the output buffer so that the |
| 295 | decompressor can get all input data available so far. For method 9, a future |
| 296 | variant on method 8, the current block will be flushed but not terminated. |
| 297 | If flush is set to Z_FULL_FLUSH, the compression block is terminated, a |
| 298 | special marker is output and the compression dictionary is discarded; this |
| 299 | is useful to allow the decompressor to synchronize if one compressed block |
| 300 | has been damaged (see inflateSync below). Flushing degrades compression and |
| 301 | so should be used only when necessary. Using Z_FULL_FLUSH too often can |
| 302 | seriously degrade the compression. If deflate returns with avail_out == 0, |
| 303 | this function must be called again with the same value of the flush |
| 304 | parameter and more output space (updated avail_out), until the flush is |
| 305 | complete (deflate returns with non-zero avail_out). |
| 306 | |
| 307 | If the parameter flush is set to Z_PACKET_FLUSH, the compression |
| 308 | block is terminated, and a zero-length stored block is output, |
| 309 | omitting the length bytes (the effect of this is that the 3-bit type |
| 310 | code 000 for a stored block is output, and the output is then |
| 311 | byte-aligned). This is designed for use at the end of a PPP packet. |
| 312 | In addition, if the current compression block contains all the data |
| 313 | since the last Z_PACKET_FLUSH, it is never output as a stored block. |
| 314 | If the current compression block output as a static or dynamic block |
| 315 | would not be at least `minCompression' bytes smaller than the |
| 316 | original data, then nothing is output for that block. (The type |
| 317 | code for the zero-length stored block is still output, resulting in |
| 318 | a single zero byte being output for the whole packet.) |
| 319 | `MinCompression' is a parameter to deflateInit2, or 0 if deflateInit |
| 320 | is used. |
| 321 | |
| 322 | If the parameter flush is set to Z_FINISH, all pending input is processed, |
| 323 | all pending output is flushed and deflate returns with Z_STREAM_END if there |
| 324 | was enough output space; if deflate returns with Z_OK, this function must be |
| 325 | called again with Z_FINISH and more output space (updated avail_out) but no |
| 326 | more input data, until it returns with Z_STREAM_END or an error. After |
| 327 | deflate has returned Z_STREAM_END, the only possible operations on the |
| 328 | stream are deflateReset or deflateEnd. |
| 329 | |
| 330 | Z_FINISH can be used immediately after deflateInit if all the compression |
| 331 | is to be done in a single step. In this case, avail_out must be at least |
| 332 | 0.1% larger than avail_in plus 12 bytes. If deflate does not return |
| 333 | Z_STREAM_END, then it must be called again as described above. |
| 334 | |
| 335 | deflate() may update data_type if it can make a good guess about |
| 336 | the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered |
| 337 | binary. This field is only for information purposes and does not affect |
| 338 | the compression algorithm in any manner. |
| 339 | |
| 340 | deflate() returns Z_OK if some progress has been made (more input |
| 341 | processed or more output produced), Z_STREAM_END if all input has been |
| 342 | consumed and all output has been produced (only when flush is set to |
| 343 | Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example |
| 344 | if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible. |
| 345 | */ |
| 346 | |
| 347 | |
| 348 | extern int deflateEnd OF((z_stream *strm)); |
| 349 | /* |
| 350 | All dynamically allocated data structures for this stream are freed. |
| 351 | This function discards any unprocessed input and does not flush any |
| 352 | pending output. |
| 353 | |
| 354 | deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the |
| 355 | stream state was inconsistent. In the error case, msg may be set |
| 356 | but then points to a static string (which must not be deallocated). |
| 357 | */ |
| 358 | |
| 359 | |
| 360 | extern int inflateInit OF((z_stream *strm)); |
| 361 | /* |
| 362 | Initializes the internal stream state for decompression. The fields |
| 363 | zalloc and zfree must be initialized before by the caller. If zalloc and |
| 364 | zfree are set to Z_NULL, inflateInit updates them to use default allocation |
| 365 | functions. |
| 366 | |
| 367 | inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not |
| 368 | enough memory. msg is set to null if there is no error message. |
| 369 | inflateInit does not perform any decompression: this will be done by |
| 370 | inflate(). |
| 371 | */ |
| 372 | |
| 373 | |
| 374 | extern int inflate OF((z_stream *strm, int flush)); |
| 375 | /* |
| 376 | Performs one or both of the following actions: |
| 377 | |
| 378 | - Decompress more input starting at next_in and update next_in and avail_in |
| 379 | accordingly. If not all input can be processed (because there is not |
| 380 | enough room in the output buffer), next_in is updated and processing |
| 381 | will resume at this point for the next call of inflate(). |
| 382 | |
| 383 | - Provide more output starting at next_out and update next_out and avail_out |
| 384 | accordingly. inflate() always provides as much output as possible |
| 385 | (until there is no more input data or no more space in the output buffer). |
| 386 | |
| 387 | Before the call of inflate(), the application should ensure that at least |
| 388 | one of the actions is possible, by providing more input and/or consuming |
| 389 | more output, and updating the next_* and avail_* values accordingly. |
| 390 | The application can consume the uncompressed output when it wants, for |
| 391 | example when the output buffer is full (avail_out == 0), or after each |
| 392 | call of inflate(). |
| 393 | |
| 394 | If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH, |
| 395 | inflate flushes as much output as possible to the output buffer. The |
| 396 | flushing behavior of inflate is not specified for values of the flush |
| 397 | parameter other than Z_PARTIAL_FLUSH, Z_PACKET_FLUSH or Z_FINISH, but the |
| 398 | current implementation actually flushes as much output as possible |
| 399 | anyway. For Z_PACKET_FLUSH, inflate checks that once all the input data |
| 400 | has been consumed, it is expecting to see the length field of a stored |
| 401 | block; if not, it returns Z_DATA_ERROR. |
| 402 | |
| 403 | inflate() should normally be called until it returns Z_STREAM_END or an |
| 404 | error. However if all decompression is to be performed in a single step |
| 405 | (a single call of inflate), the parameter flush should be set to |
| 406 | Z_FINISH. In this case all pending input is processed and all pending |
| 407 | output is flushed; avail_out must be large enough to hold all the |
| 408 | uncompressed data. (The size of the uncompressed data may have been saved |
| 409 | by the compressor for this purpose.) The next operation on this stream must |
| 410 | be inflateEnd to deallocate the decompression state. The use of Z_FINISH |
| 411 | is never required, but can be used to inform inflate that a faster routine |
| 412 | may be used for the single inflate() call. |
| 413 | |
| 414 | inflate() returns Z_OK if some progress has been made (more input |
| 415 | processed or more output produced), Z_STREAM_END if the end of the |
| 416 | compressed data has been reached and all uncompressed output has been |
| 417 | produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if |
| 418 | the stream structure was inconsistent (for example if next_in or next_out |
| 419 | was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no |
| 420 | progress is possible or if there was not enough room in the output buffer |
| 421 | when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then |
| 422 | call inflateSync to look for a good compression block. */ |
| 423 | |
| 424 | |
| 425 | extern int inflateEnd OF((z_stream *strm)); |
| 426 | /* |
| 427 | All dynamically allocated data structures for this stream are freed. |
| 428 | This function discards any unprocessed input and does not flush any |
| 429 | pending output. |
| 430 | |
| 431 | inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state |
| 432 | was inconsistent. In the error case, msg may be set but then points to a |
| 433 | static string (which must not be deallocated). |
| 434 | */ |
| 435 | |
| 436 | /* advanced functions */ |
| 437 | |
| 438 | /* |
| 439 | The following functions are needed only in some special applications. |
| 440 | */ |
| 441 | |
| 442 | extern int deflateInit2 OF((z_stream *strm, |
| 443 | int level, |
| 444 | int method, |
| 445 | int windowBits, |
| 446 | int memLevel, |
| 447 | int strategy, |
| 448 | int minCompression)); |
| 449 | /* |
| 450 | This is another version of deflateInit with more compression options. The |
| 451 | fields next_in, zalloc and zfree must be initialized before by the caller. |
| 452 | |
| 453 | The method parameter is the compression method. It must be 8 in this |
| 454 | version of the library. (Method 9 will allow a 64K history buffer and |
| 455 | partial block flushes.) |
| 456 | |
| 457 | The windowBits parameter is the base two logarithm of the window size |
| 458 | (the size of the history buffer). It should be in the range 8..15 for this |
| 459 | version of the library (the value 16 will be allowed for method 9). Larger |
| 460 | values of this parameter result in better compression at the expense of |
| 461 | memory usage. The default value is 15 if deflateInit is used instead. |
| 462 | |
| 463 | The memLevel parameter specifies how much memory should be allocated |
| 464 | for the internal compression state. memLevel=1 uses minimum memory but |
| 465 | is slow and reduces compression ratio; memLevel=9 uses maximum memory |
| 466 | for optimal speed. The default value is 8. See zconf.h for total memory |
| 467 | usage as a function of windowBits and memLevel. |
| 468 | |
| 469 | The strategy parameter is used to tune the compression algorithm. Use |
| 470 | the value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data |
| 471 | produced by a filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman |
| 472 | encoding only (no string match). Filtered data consists mostly of small |
| 473 | values with a somewhat random distribution. In this case, the |
| 474 | compression algorithm is tuned to compress them better. The strategy |
| 475 | parameter only affects the compression ratio but not the correctness of |
| 476 | the compressed output even if it is not set appropriately. |
| 477 | |
| 478 | The minCompression parameter specifies the minimum reduction in size |
| 479 | required for a compressed block to be output when Z_PACKET_FLUSH is |
| 480 | used (see the description of deflate above). |
| 481 | |
| 482 | If next_in is not null, the library will use this buffer to hold also |
| 483 | some history information; the buffer must either hold the entire input |
| 484 | data, or have at least 1<<(windowBits+1) bytes and be writable. If next_in |
| 485 | is null, the library will allocate its own history buffer (and leave next_in |
| 486 | null). next_out need not be provided here but must be provided by the |
| 487 | application for the next call of deflate(). |
| 488 | |
| 489 | If the history buffer is provided by the application, next_in must |
| 490 | must never be changed by the application since the compressor maintains |
| 491 | information inside this buffer from call to call; the application |
| 492 | must provide more input only by increasing avail_in. next_in is always |
| 493 | reset by the library in this case. |
| 494 | |
| 495 | deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was |
| 496 | not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as |
| 497 | an invalid method). msg is set to null if there is no error message. |
| 498 | deflateInit2 does not perform any compression: this will be done by |
| 499 | deflate(). |
| 500 | */ |
| 501 | |
| 502 | extern int deflateCopy OF((z_stream *dest, |
| 503 | z_stream *source)); |
| 504 | /* |
| 505 | Sets the destination stream as a complete copy of the source stream. If |
| 506 | the source stream is using an application-supplied history buffer, a new |
| 507 | buffer is allocated for the destination stream. The compressed output |
| 508 | buffer is always application-supplied. It's the responsibility of the |
| 509 | application to provide the correct values of next_out and avail_out for the |
| 510 | next call of deflate. |
| 511 | |
| 512 | This function is useful when several compression strategies will be |
| 513 | tried, for example when there are several ways of pre-processing the input |
| 514 | data with a filter. The streams that will be discarded should then be freed |
| 515 | by calling deflateEnd. Note that deflateCopy duplicates the internal |
| 516 | compression state which can be quite large, so this strategy is slow and |
| 517 | can consume lots of memory. |
| 518 | |
| 519 | deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not |
| 520 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent |
| 521 | (such as zalloc being NULL). msg is left unchanged in both source and |
| 522 | destination. |
| 523 | */ |
| 524 | |
| 525 | extern int deflateReset OF((z_stream *strm)); |
| 526 | /* |
| 527 | This function is equivalent to deflateEnd followed by deflateInit, |
| 528 | but does not free and reallocate all the internal compression state. |
| 529 | The stream will keep the same compression level and any other attributes |
| 530 | that may have been set by deflateInit2. |
| 531 | |
| 532 | deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
| 533 | stream state was inconsistent (such as zalloc or state being NULL). |
| 534 | */ |
| 535 | |
| 536 | extern int inflateInit2 OF((z_stream *strm, |
| 537 | int windowBits)); |
| 538 | /* |
| 539 | This is another version of inflateInit with more compression options. The |
| 540 | fields next_out, zalloc and zfree must be initialized before by the caller. |
| 541 | |
| 542 | The windowBits parameter is the base two logarithm of the maximum window |
| 543 | size (the size of the history buffer). It should be in the range 8..15 for |
| 544 | this version of the library (the value 16 will be allowed soon). The |
| 545 | default value is 15 if inflateInit is used instead. If a compressed stream |
| 546 | with a larger window size is given as input, inflate() will return with |
| 547 | the error code Z_DATA_ERROR instead of trying to allocate a larger window. |
| 548 | |
| 549 | If next_out is not null, the library will use this buffer for the history |
| 550 | buffer; the buffer must either be large enough to hold the entire output |
| 551 | data, or have at least 1<<windowBits bytes. If next_out is null, the |
| 552 | library will allocate its own buffer (and leave next_out null). next_in |
| 553 | need not be provided here but must be provided by the application for the |
| 554 | next call of inflate(). |
| 555 | |
| 556 | If the history buffer is provided by the application, next_out must |
| 557 | never be changed by the application since the decompressor maintains |
| 558 | history information inside this buffer from call to call; the application |
| 559 | can only reset next_out to the beginning of the history buffer when |
| 560 | avail_out is zero and all output has been consumed. |
| 561 | |
| 562 | inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was |
| 563 | not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as |
| 564 | windowBits < 8). msg is set to null if there is no error message. |
| 565 | inflateInit2 does not perform any decompression: this will be done by |
| 566 | inflate(). |
| 567 | */ |
| 568 | |
| 569 | extern int inflateSync OF((z_stream *strm)); |
| 570 | /* |
| 571 | Skips invalid compressed data until the special marker (see deflate() |
| 572 | above) can be found, or until all available input is skipped. No output |
| 573 | is provided. |
| 574 | |
| 575 | inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR |
| 576 | if no more input was provided, Z_DATA_ERROR if no marker has been found, |
| 577 | or Z_STREAM_ERROR if the stream structure was inconsistent. In the success |
| 578 | case, the application may save the current current value of total_in which |
| 579 | indicates where valid compressed data was found. In the error case, the |
| 580 | application may repeatedly call inflateSync, providing more input each time, |
| 581 | until success or end of the input data. |
| 582 | */ |
| 583 | |
| 584 | extern int inflateReset OF((z_stream *strm)); |
| 585 | /* |
| 586 | This function is equivalent to inflateEnd followed by inflateInit, |
| 587 | but does not free and reallocate all the internal decompression state. |
| 588 | The stream will keep attributes that may have been set by inflateInit2. |
| 589 | |
| 590 | inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
| 591 | stream state was inconsistent (such as zalloc or state being NULL). |
| 592 | */ |
| 593 | |
| 594 | extern int inflateIncomp OF((z_stream *strm)); |
| 595 | /* |
| 596 | This function adds the data at next_in (avail_in bytes) to the output |
| 597 | history without performing any output. There must be no pending output, |
| 598 | and the decompressor must be expecting to see the start of a block. |
| 599 | Calling this function is equivalent to decompressing a stored block |
| 600 | containing the data at next_in (except that the data is not output). |
| 601 | */ |
| 602 | |
| 603 | /* checksum functions */ |
| 604 | |
| 605 | /* |
| 606 | This function is not related to compression but is exported |
| 607 | anyway because it might be useful in applications using the |
| 608 | compression library. |
| 609 | */ |
| 610 | |
| 611 | extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len)); |
| 612 | |
| 613 | /* |
| 614 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and |
| 615 | return the updated checksum. If buf is NULL, this function returns |
| 616 | the required initial value for the checksum. |
| 617 | An Adler-32 checksum is almost as reliable as a CRC32 but can be computed |
| 618 | much faster. Usage example: |
| 619 | |
| 620 | uLong adler = adler32(0L, Z_NULL, 0); |
| 621 | |
| 622 | while (read_buffer(buffer, length) != EOF) { |
| 623 | adler = adler32(adler, buffer, length); |
| 624 | } |
| 625 | if (adler != original_adler) error(); |
| 626 | */ |
| 627 | |
| 628 | #ifndef _Z_UTIL_H |
| 629 | struct internal_state {int dummy;}; /* hack for buggy compilers */ |
| 630 | #endif |
| 631 | |
| 632 | #endif /* _ZLIB_H */ |