| 1 | |
| 2 |
|
| 3 | Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
|
| 4 |
|
| 5 | This software is provided 'as-is', without any express or implied
|
| 6 | warranty. In no event will the authors be held liable for any damages
|
| 7 | arising from the use of this software.
|
| 8 |
|
| 9 | Permission is granted to anyone to use this software for any purpose,
|
| 10 | including commercial applications, and to alter it and redistribute it
|
| 11 | freely, subject to the following restrictions:
|
| 12 |
|
| 13 | 1. The origin of this software must not be misrepresented; you must not
|
| 14 | claim that you wrote the original software. If you use this software
|
| 15 | in a product, an acknowledgment in the product documentation would be
|
| 16 | appreciated but is not required.
|
| 17 | 2. Altered source versions must be plainly marked as such, and must not be
|
| 18 | misrepresented as being the original software.
|
| 19 | 3. This notice may not be removed or altered from any source distribution.
|
| 20 |
|
| 21 | Jean-loup Gailly Mark Adler
|
| 22 | [email protected] [email protected]
|
| 23 |
|
| 24 |
|
| 25 | The data format used by the zlib library is described by RFCs (Request for
|
| 26 | Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
|
| 27 | (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
|
| 28 |
|
| 29 |
|
| 30 | #ifndef _ZLIB_H
|
| 31 | #define _ZLIB_H
|
| 32 |
|
| 33 | #include <linux/zconf.h>
|
| 34 |
|
| 35 |
|
| 36 |
|
| 37 |
|
| 38 | |
| 39 | This is a modified version of zlib for use inside the Linux kernel.
|
| 40 | The main changes are to perform all memory allocation in advance.
|
| 41 |
|
| 42 | Inflation Changes:
|
| 43 | * Z_PACKET_FLUSH is added and used by ppp_deflate. Before returning
|
| 44 | this checks there is no more input data available and the next data
|
| 45 | is a STORED block. It also resets the mode to be read for the next
|
| 46 | data, all as per PPP requirements.
|
| 47 | * Addition of zlib_inflateIncomp which copies incompressible data into
|
| 48 | the history window and adjusts the accoutning without calling
|
| 49 | zlib_inflate itself to inflate the data.
|
| 50 |
|
| 51 |
|
| 52 | |
| 53 | The 'zlib' compression library provides in-memory compression and
|
| 54 | decompression functions, including integrity checks of the uncompressed
|
| 55 | data. This version of the library supports only one compression method
|
| 56 | (deflation) but other algorithms will be added later and will have the same
|
| 57 | stream interface.
|
| 58 |
|
| 59 | Compression can be done in a single step if the buffers are large
|
| 60 | enough (for example if an input file is mmap'ed), or can be done by
|
| 61 | repeated calls of the compression function. In the latter case, the
|
| 62 | application must provide more input and/or consume the output
|
| 63 | (providing more output space) before each call.
|
| 64 |
|
| 65 | The compressed data format used by default by the in-memory functions is
|
| 66 | the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
|
| 67 | around a deflate stream, which is itself documented in RFC 1951.
|
| 68 |
|
| 69 | The library also supports reading and writing files in gzip (.gz) format
|
| 70 | with an interface similar to that of stdio.
|
| 71 |
|
| 72 | The zlib format was designed to be compact and fast for use in memory
|
| 73 | and on communications channels. The gzip format was designed for single-
|
| 74 | file compression on file systems, has a larger header than zlib to maintain
|
| 75 | directory information, and uses a different, slower check method than zlib.
|
| 76 |
|
| 77 | The library does not install any signal handler. The decoder checks
|
| 78 | the consistency of the compressed data, so the library should never
|
| 79 | crash even in case of corrupted input.
|
| 80 |
|
| 81 |
|
| 82 | struct internal_state;
|
| 83 |
|
| 84 | typedef struct z_stream_s {
|
| 85 | const Byte *next_in;
|
| 86 | uInt avail_in;
|
| 87 | uLong total_in;
|
| 88 |
|
| 89 | Byte *next_out;
|
| 90 | uInt avail_out;
|
| 91 | uLong total_out;
|
| 92 |
|
| 93 | char *msg;
|
| 94 | struct internal_state *state;
|
| 95 |
|
| 96 | void *workspace;
|
| 97 |
|
| 98 | int data_type;
|
| 99 | uLong adler;
|
| 100 | uLong reserved;
|
| 101 | } z_stream;
|
| 102 |
|
| 103 | typedef z_stream *z_streamp;
|
| 104 |
|
| 105 | |
| 106 | The application must update next_in and avail_in when avail_in has
|
| 107 | dropped to zero. It must update next_out and avail_out when avail_out
|
| 108 | has dropped to zero. The application must initialize zalloc, zfree and
|
| 109 | opaque before calling the init function. All other fields are set by the
|
| 110 | compression library and must not be updated by the application.
|
| 111 |
|
| 112 | The opaque value provided by the application will be passed as the first
|
| 113 | parameter for calls of zalloc and zfree. This can be useful for custom
|
| 114 | memory management. The compression library attaches no meaning to the
|
| 115 | opaque value.
|
| 116 |
|
| 117 | zalloc must return NULL if there is not enough memory for the object.
|
| 118 | If zlib is used in a multi-threaded application, zalloc and zfree must be
|
| 119 | thread safe.
|
| 120 |
|
| 121 | On 16-bit systems, the functions zalloc and zfree must be able to allocate
|
| 122 | exactly 65536 bytes, but will not be required to allocate more than this
|
| 123 | if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
|
| 124 | pointers returned by zalloc for objects of exactly 65536 bytes *must*
|
| 125 | have their offset normalized to zero. The default allocation function
|
| 126 | provided by this library ensures this (see zutil.c). To reduce memory
|
| 127 | requirements and avoid any allocation of 64K objects, at the expense of
|
| 128 | compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
|
| 129 |
|
| 130 | The fields total_in and total_out can be used for statistics or
|
| 131 | progress reports. After compression, total_in holds the total size of
|
| 132 | the uncompressed data and may be saved for use in the decompressor
|
| 133 | (particularly if the decompressor wants to decompress everything in
|
| 134 | a single step).
|
| 135 |
|
| 136 |
|
| 137 |
|
| 138 |
|
| 139 | #define Z_NO_FLUSH 0
|
| 140 | #define Z_PARTIAL_FLUSH 1
|
| 141 | #define Z_PACKET_FLUSH 2
|
| 142 | #define Z_SYNC_FLUSH 3
|
| 143 | #define Z_FULL_FLUSH 4
|
| 144 | #define Z_FINISH 5
|
| 145 | #define Z_BLOCK 6
|
| 146 |
|
| 147 |
|
| 148 | #define Z_OK 0
|
| 149 | #define Z_STREAM_END 1
|
| 150 | #define Z_NEED_DICT 2
|
| 151 | #define Z_ERRNO (-1)
|
| 152 | #define Z_STREAM_ERROR (-2)
|
| 153 | #define Z_DATA_ERROR (-3)
|
| 154 | #define Z_MEM_ERROR (-4)
|
| 155 | #define Z_BUF_ERROR (-5)
|
| 156 | #define Z_VERSION_ERROR (-6)
|
| 157 | |
| 158 | * values are errors, positive values are used for special but normal events.
|
| 159 |
|
| 160 |
|
| 161 | #define Z_NO_COMPRESSION 0
|
| 162 | #define Z_BEST_SPEED 1
|
| 163 | #define Z_BEST_COMPRESSION 9
|
| 164 | #define Z_DEFAULT_COMPRESSION (-1)
|
| 165 |
|
| 166 |
|
| 167 | #define Z_FILTERED 1
|
| 168 | #define Z_HUFFMAN_ONLY 2
|
| 169 | #define Z_DEFAULT_STRATEGY 0
|
| 170 |
|
| 171 |
|
| 172 | #define Z_BINARY 0
|
| 173 | #define Z_ASCII 1
|
| 174 | #define Z_UNKNOWN 2
|
| 175 |
|
| 176 |
|
| 177 | #define Z_DEFLATED 8
|
| 178 |
|
| 179 |
|
| 180 |
|
| 181 |
|
| 182 | extern int zlib_deflate_workspacesize (int windowBits, int memLevel);
|
| 183 | |
| 184 | Returns the number of bytes that needs to be allocated for a per-
|
| 185 | stream workspace with the specified parameters. A pointer to this
|
| 186 | number of bytes should be returned in stream->workspace before
|
| 187 | you call zlib_deflateInit() or zlib_deflateInit2(). If you call
|
| 188 | zlib_deflateInit(), specify windowBits = MAX_WBITS and memLevel =
|
| 189 | MAX_MEM_LEVEL here. If you call zlib_deflateInit2(), the windowBits
|
| 190 | and memLevel parameters passed to zlib_deflateInit2() must not
|
| 191 | exceed those passed here.
|
| 192 |
|
| 193 |
|
| 194 | |
| 195 | extern int deflateInit (z_streamp strm, int level);
|
| 196 |
|
| 197 | Initializes the internal stream state for compression. The fields
|
| 198 | zalloc, zfree and opaque must be initialized before by the caller.
|
| 199 | If zalloc and zfree are set to NULL, deflateInit updates them to
|
| 200 | use default allocation functions.
|
| 201 |
|
| 202 | The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
|
| 203 | 1 gives best speed, 9 gives best compression, 0 gives no compression at
|
| 204 | all (the input data is simply copied a block at a time).
|
| 205 | Z_DEFAULT_COMPRESSION requests a default compromise between speed and
|
| 206 | compression (currently equivalent to level 6).
|
| 207 |
|
| 208 | deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
|
| 209 | enough memory, Z_STREAM_ERROR if level is not a valid compression level,
|
| 210 | Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
|
| 211 | with the version assumed by the caller (ZLIB_VERSION).
|
| 212 | msg is set to null if there is no error message. deflateInit does not
|
| 213 | perform any compression: this will be done by deflate().
|
| 214 |
|
| 215 |
|
| 216 |
|
| 217 | extern int zlib_deflate (z_streamp strm, int flush);
|
| 218 | |
| 219 | deflate compresses as much data as possible, and stops when the input
|
| 220 | buffer becomes empty or the output buffer becomes full. It may introduce some
|
| 221 | output latency (reading input without producing any output) except when
|
| 222 | forced to flush.
|
| 223 |
|
| 224 | The detailed semantics are as follows. deflate performs one or both of the
|
| 225 | following actions:
|
| 226 |
|
| 227 | - Compress more input starting at next_in and update next_in and avail_in
|
| 228 | accordingly. If not all input can be processed (because there is not
|
| 229 | enough room in the output buffer), next_in and avail_in are updated and
|
| 230 | processing will resume at this point for the next call of deflate().
|
| 231 |
|
| 232 | - Provide more output starting at next_out and update next_out and avail_out
|
| 233 | accordingly. This action is forced if the parameter flush is non zero.
|
| 234 | Forcing flush frequently degrades the compression ratio, so this parameter
|
| 235 | should be set only when necessary (in interactive applications).
|
| 236 | Some output may be provided even if flush is not set.
|
| 237 |
|
| 238 | Before the call of deflate(), the application should ensure that at least
|
| 239 | one of the actions is possible, by providing more input and/or consuming
|
| 240 | more output, and updating avail_in or avail_out accordingly; avail_out
|
| 241 | should never be zero before the call. The application can consume the
|
| 242 | compressed output when it wants, for example when the output buffer is full
|
| 243 | (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
|
| 244 | and with zero avail_out, it must be called again after making room in the
|
| 245 | output buffer because there might be more output pending.
|
| 246 |
|
| 247 | If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
|
| 248 | flushed to the output buffer and the output is aligned on a byte boundary, so
|
| 249 | that the decompressor can get all input data available so far. (In particular
|
| 250 | avail_in is zero after the call if enough output space has been provided
|
| 251 | before the call.) Flushing may degrade compression for some compression
|
| 252 | algorithms and so it should be used only when necessary.
|
| 253 |
|
| 254 | If flush is set to Z_FULL_FLUSH, all output is flushed as with
|
| 255 | Z_SYNC_FLUSH, and the compression state is reset so that decompression can
|
| 256 | restart from this point if previous compressed data has been damaged or if
|
| 257 | random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
|
| 258 | the compression.
|
| 259 |
|
| 260 | If deflate returns with avail_out == 0, this function must be called again
|
| 261 | with the same value of the flush parameter and more output space (updated
|
| 262 | avail_out), until the flush is complete (deflate returns with non-zero
|
| 263 | avail_out).
|
| 264 |
|
| 265 | If the parameter flush is set to Z_FINISH, pending input is processed,
|
| 266 | pending output is flushed and deflate returns with Z_STREAM_END if there
|
| 267 | was enough output space; if deflate returns with Z_OK, this function must be
|
| 268 | called again with Z_FINISH and more output space (updated avail_out) but no
|
| 269 | more input data, until it returns with Z_STREAM_END or an error. After
|
| 270 | deflate has returned Z_STREAM_END, the only possible operations on the
|
| 271 | stream are deflateReset or deflateEnd.
|
| 272 |
|
| 273 | Z_FINISH can be used immediately after deflateInit if all the compression
|
| 274 | is to be done in a single step. In this case, avail_out must be at least
|
| 275 | 0.1% larger than avail_in plus 12 bytes. If deflate does not return
|
| 276 | Z_STREAM_END, then it must be called again as described above.
|
| 277 |
|
| 278 | deflate() sets strm->adler to the adler32 checksum of all input read
|
| 279 | so far (that is, total_in bytes).
|
| 280 |
|
| 281 | deflate() may update data_type if it can make a good guess about
|
| 282 | the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
|
| 283 | binary. This field is only for information purposes and does not affect
|
| 284 | the compression algorithm in any manner.
|
| 285 |
|
| 286 | deflate() returns Z_OK if some progress has been made (more input
|
| 287 | processed or more output produced), Z_STREAM_END if all input has been
|
| 288 | consumed and all output has been produced (only when flush is set to
|
| 289 | Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
|
| 290 | if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
|
| 291 | (for example avail_in or avail_out was zero).
|
| 292 |
|
| 293 |
|
| 294 |
|
| 295 | extern int zlib_deflateEnd (z_streamp strm);
|
| 296 | |
| 297 | All dynamically allocated data structures for this stream are freed.
|
| 298 | This function discards any unprocessed input and does not flush any
|
| 299 | pending output.
|
| 300 |
|
| 301 | deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
|
| 302 | stream state was inconsistent, Z_DATA_ERROR if the stream was freed
|
| 303 | prematurely (some input or output was discarded). In the error case,
|
| 304 | msg may be set but then points to a static string (which must not be
|
| 305 | deallocated).
|
| 306 |
|
| 307 |
|
| 308 |
|
| 309 | extern int zlib_inflate_workspacesize (void);
|
| 310 | |
| 311 | Returns the number of bytes that needs to be allocated for a per-
|
| 312 | stream workspace. A pointer to this number of bytes should be
|
| 313 | returned in stream->workspace before calling zlib_inflateInit().
|
| 314 |
|
| 315 |
|
| 316 | |
| 317 | extern int zlib_inflateInit (z_streamp strm);
|
| 318 |
|
| 319 | Initializes the internal stream state for decompression. The fields
|
| 320 | next_in, avail_in, and workspace must be initialized before by
|
| 321 | the caller. If next_in is not NULL and avail_in is large enough (the exact
|
| 322 | value depends on the compression method), inflateInit determines the
|
| 323 | compression method from the zlib header and allocates all data structures
|
| 324 | accordingly; otherwise the allocation will be deferred to the first call of
|
| 325 | inflate. If zalloc and zfree are set to NULL, inflateInit updates them to
|
| 326 | use default allocation functions.
|
| 327 |
|
| 328 | inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
| 329 | memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
|
| 330 | version assumed by the caller. msg is set to null if there is no error
|
| 331 | message. inflateInit does not perform any decompression apart from reading
|
| 332 | the zlib header if present: this will be done by inflate(). (So next_in and
|
| 333 | avail_in may be modified, but next_out and avail_out are unchanged.)
|
| 334 |
|
| 335 |
|
| 336 |
|
| 337 | extern int zlib_inflate (z_streamp strm, int flush);
|
| 338 | |
| 339 | inflate decompresses as much data as possible, and stops when the input
|
| 340 | buffer becomes empty or the output buffer becomes full. It may introduce
|
| 341 | some output latency (reading input without producing any output) except when
|
| 342 | forced to flush.
|
| 343 |
|
| 344 | The detailed semantics are as follows. inflate performs one or both of the
|
| 345 | following actions:
|
| 346 |
|
| 347 | - Decompress more input starting at next_in and update next_in and avail_in
|
| 348 | accordingly. If not all input can be processed (because there is not
|
| 349 | enough room in the output buffer), next_in is updated and processing
|
| 350 | will resume at this point for the next call of inflate().
|
| 351 |
|
| 352 | - Provide more output starting at next_out and update next_out and avail_out
|
| 353 | accordingly. inflate() provides as much output as possible, until there
|
| 354 | is no more input data or no more space in the output buffer (see below
|
| 355 | about the flush parameter).
|
| 356 |
|
| 357 | Before the call of inflate(), the application should ensure that at least
|
| 358 | one of the actions is possible, by providing more input and/or consuming
|
| 359 | more output, and updating the next_* and avail_* values accordingly.
|
| 360 | The application can consume the uncompressed output when it wants, for
|
| 361 | example when the output buffer is full (avail_out == 0), or after each
|
| 362 | call of inflate(). If inflate returns Z_OK and with zero avail_out, it
|
| 363 | must be called again after making room in the output buffer because there
|
| 364 | might be more output pending.
|
| 365 |
|
| 366 | The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
|
| 367 | Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much
|
| 368 | output as possible to the output buffer. Z_BLOCK requests that inflate() stop
|
| 369 | if and when it gets to the next deflate block boundary. When decoding the
|
| 370 | zlib or gzip format, this will cause inflate() to return immediately after
|
| 371 | the header and before the first block. When doing a raw inflate, inflate()
|
| 372 | will go ahead and process the first block, and will return when it gets to
|
| 373 | the end of that block, or when it runs out of data.
|
| 374 |
|
| 375 | The Z_BLOCK option assists in appending to or combining deflate streams.
|
| 376 | Also to assist in this, on return inflate() will set strm->data_type to the
|
| 377 | number of unused bits in the last byte taken from strm->next_in, plus 64
|
| 378 | if inflate() is currently decoding the last block in the deflate stream,
|
| 379 | plus 128 if inflate() returned immediately after decoding an end-of-block
|
| 380 | code or decoding the complete header up to just before the first byte of the
|
| 381 | deflate stream. The end-of-block will not be indicated until all of the
|
| 382 | uncompressed data from that block has been written to strm->next_out. The
|
| 383 | number of unused bits may in general be greater than seven, except when
|
| 384 | bit 7 of data_type is set, in which case the number of unused bits will be
|
| 385 | less than eight.
|
| 386 |
|
| 387 | inflate() should normally be called until it returns Z_STREAM_END or an
|
| 388 | error. However if all decompression is to be performed in a single step
|
| 389 | (a single call of inflate), the parameter flush should be set to
|
| 390 | Z_FINISH. In this case all pending input is processed and all pending
|
| 391 | output is flushed; avail_out must be large enough to hold all the
|
| 392 | uncompressed data. (The size of the uncompressed data may have been saved
|
| 393 | by the compressor for this purpose.) The next operation on this stream must
|
| 394 | be inflateEnd to deallocate the decompression state. The use of Z_FINISH
|
| 395 | is never required, but can be used to inform inflate that a faster approach
|
| 396 | may be used for the single inflate() call.
|
| 397 |
|
| 398 | In this implementation, inflate() always flushes as much output as
|
| 399 | possible to the output buffer, and always uses the faster approach on the
|
| 400 | first call. So the only effect of the flush parameter in this implementation
|
| 401 | is on the return value of inflate(), as noted below, or when it returns early
|
| 402 | because Z_BLOCK is used.
|
| 403 |
|
| 404 | If a preset dictionary is needed after this call (see inflateSetDictionary
|
| 405 | below), inflate sets strm->adler to the adler32 checksum of the dictionary
|
| 406 | chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
|
| 407 | strm->adler to the adler32 checksum of all output produced so far (that is,
|
| 408 | total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
|
| 409 | below. At the end of the stream, inflate() checks that its computed adler32
|
| 410 | checksum is equal to that saved by the compressor and returns Z_STREAM_END
|
| 411 | only if the checksum is correct.
|
| 412 |
|
| 413 | inflate() will decompress and check either zlib-wrapped or gzip-wrapped
|
| 414 | deflate data. The header type is detected automatically. Any information
|
| 415 | contained in the gzip header is not retained, so applications that need that
|
| 416 | information should instead use raw inflate, see inflateInit2() below, or
|
| 417 | inflateBack() and perform their own processing of the gzip header and
|
| 418 | trailer.
|
| 419 |
|
| 420 | inflate() returns Z_OK if some progress has been made (more input processed
|
| 421 | or more output produced), Z_STREAM_END if the end of the compressed data has
|
| 422 | been reached and all uncompressed output has been produced, Z_NEED_DICT if a
|
| 423 | preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
|
| 424 | corrupted (input stream not conforming to the zlib format or incorrect check
|
| 425 | value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
|
| 426 | if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
|
| 427 | Z_BUF_ERROR if no progress is possible or if there was not enough room in the
|
| 428 | output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
|
| 429 | inflate() can be called again with more input and more output space to
|
| 430 | continue decompressing. If Z_DATA_ERROR is returned, the application may then
|
| 431 | call inflateSync() to look for a good compression block if a partial recovery
|
| 432 | of the data is desired.
|
| 433 |
|
| 434 |
|
| 435 |
|
| 436 | extern int zlib_inflateEnd (z_streamp strm);
|
| 437 | |
| 438 | All dynamically allocated data structures for this stream are freed.
|
| 439 | This function discards any unprocessed input and does not flush any
|
| 440 | pending output.
|
| 441 |
|
| 442 | inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
|
| 443 | was inconsistent. In the error case, msg may be set but then points to a
|
| 444 | static string (which must not be deallocated).
|
| 445 |
|
| 446 |
|
| 447 |
|
| 448 |
|
| 449 | |
| 450 | The following functions are needed only in some special applications.
|
| 451 |
|
| 452 |
|
| 453 | |
| 454 | extern int deflateInit2 (z_streamp strm,
|
| 455 | int level,
|
| 456 | int method,
|
| 457 | int windowBits,
|
| 458 | int memLevel,
|
| 459 | int strategy);
|
| 460 |
|
| 461 | This is another version of deflateInit with more compression options. The
|
| 462 | fields next_in, zalloc, zfree and opaque must be initialized before by
|
| 463 | the caller.
|
| 464 |
|
| 465 | The method parameter is the compression method. It must be Z_DEFLATED in
|
| 466 | this version of the library.
|
| 467 |
|
| 468 | The windowBits parameter is the base two logarithm of the window size
|
| 469 | (the size of the history buffer). It should be in the range 8..15 for this
|
| 470 | version of the library. Larger values of this parameter result in better
|
| 471 | compression at the expense of memory usage. The default value is 15 if
|
| 472 | deflateInit is used instead.
|
| 473 |
|
| 474 | The memLevel parameter specifies how much memory should be allocated
|
| 475 | for the internal compression state. memLevel=1 uses minimum memory but
|
| 476 | is slow and reduces compression ratio; memLevel=9 uses maximum memory
|
| 477 | for optimal speed. The default value is 8. See zconf.h for total memory
|
| 478 | usage as a function of windowBits and memLevel.
|
| 479 |
|
| 480 | The strategy parameter is used to tune the compression algorithm. Use the
|
| 481 | value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
|
| 482 | filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
|
| 483 | string match). Filtered data consists mostly of small values with a
|
| 484 | somewhat random distribution. In this case, the compression algorithm is
|
| 485 | tuned to compress them better. The effect of Z_FILTERED is to force more
|
| 486 | Huffman coding and less string matching; it is somewhat intermediate
|
| 487 | between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
|
| 488 | the compression ratio but not the correctness of the compressed output even
|
| 489 | if it is not set appropriately.
|
| 490 |
|
| 491 | deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
| 492 | memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
|
| 493 | method). msg is set to null if there is no error message. deflateInit2 does
|
| 494 | not perform any compression: this will be done by deflate().
|
| 495 |
|
| 496 |
|
| 497 | #if 0 |
| 498 | extern int zlib_deflateSetDictionary (z_streamp strm,
|
| 499 | const Byte *dictionary,
|
| 500 | uInt dictLength);
|
| 501 | #endif
|
| 502 | |
| 503 | Initializes the compression dictionary from the given byte sequence
|
| 504 | without producing any compressed output. This function must be called
|
| 505 | immediately after deflateInit, deflateInit2 or deflateReset, before any
|
| 506 | call of deflate. The compressor and decompressor must use exactly the same
|
| 507 | dictionary (see inflateSetDictionary).
|
| 508 |
|
| 509 | The dictionary should consist of strings (byte sequences) that are likely
|
| 510 | to be encountered later in the data to be compressed, with the most commonly
|
| 511 | used strings preferably put towards the end of the dictionary. Using a
|
| 512 | dictionary is most useful when the data to be compressed is short and can be
|
| 513 | predicted with good accuracy; the data can then be compressed better than
|
| 514 | with the default empty dictionary.
|
| 515 |
|
| 516 | Depending on the size of the compression data structures selected by
|
| 517 | deflateInit or deflateInit2, a part of the dictionary may in effect be
|
| 518 | discarded, for example if the dictionary is larger than the window size in
|
| 519 | deflate or deflate2. Thus the strings most likely to be useful should be
|
| 520 | put at the end of the dictionary, not at the front.
|
| 521 |
|
| 522 | Upon return of this function, strm->adler is set to the Adler32 value
|
| 523 | of the dictionary; the decompressor may later use this value to determine
|
| 524 | which dictionary has been used by the compressor. (The Adler32 value
|
| 525 | applies to the whole dictionary even if only a subset of the dictionary is
|
| 526 | actually used by the compressor.)
|
| 527 |
|
| 528 | deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
|
| 529 | parameter is invalid (such as NULL dictionary) or the stream state is
|
| 530 | inconsistent (for example if deflate has already been called for this stream
|
| 531 | or if the compression method is bsort). deflateSetDictionary does not
|
| 532 | perform any compression: this will be done by deflate().
|
| 533 |
|
| 534 |
|
| 535 | #if 0 |
| 536 | extern int zlib_deflateCopy (z_streamp dest, z_streamp source);
|
| 537 | #endif
|
| 538 |
|
| 539 | |
| 540 | Sets the destination stream as a complete copy of the source stream.
|
| 541 |
|
| 542 | This function can be useful when several compression strategies will be
|
| 543 | tried, for example when there are several ways of pre-processing the input
|
| 544 | data with a filter. The streams that will be discarded should then be freed
|
| 545 | by calling deflateEnd. Note that deflateCopy duplicates the internal
|
| 546 | compression state which can be quite large, so this strategy is slow and
|
| 547 | can consume lots of memory.
|
| 548 |
|
| 549 | deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
|
| 550 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
|
| 551 | (such as zalloc being NULL). msg is left unchanged in both source and
|
| 552 | destination.
|
| 553 |
|
| 554 |
|
| 555 | extern int zlib_deflateReset (z_streamp strm);
|
| 556 | |
| 557 | This function is equivalent to deflateEnd followed by deflateInit,
|
| 558 | but does not free and reallocate all the internal compression state.
|
| 559 | The stream will keep the same compression level and any other attributes
|
| 560 | that may have been set by deflateInit2.
|
| 561 |
|
| 562 | deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
| 563 | stream state was inconsistent (such as zalloc or state being NULL).
|
| 564 |
|
| 565 |
|
| 566 | static inline unsigned long deflateBound(unsigned long s)
|
| 567 | {
|
| 568 | return s + ((s + 7) >> 3) + ((s + 63) >> 6) + 11;
|
| 569 | }
|
| 570 |
|
| 571 | #if 0 |
| 572 | extern int zlib_deflateParams (z_streamp strm, int level, int strategy);
|
| 573 | #endif
|
| 574 | |
| 575 | Dynamically update the compression level and compression strategy. The
|
| 576 | interpretation of level and strategy is as in deflateInit2. This can be
|
| 577 | used to switch between compression and straight copy of the input data, or
|
| 578 | to switch to a different kind of input data requiring a different
|
| 579 | strategy. If the compression level is changed, the input available so far
|
| 580 | is compressed with the old level (and may be flushed); the new level will
|
| 581 | take effect only at the next call of deflate().
|
| 582 |
|
| 583 | Before the call of deflateParams, the stream state must be set as for
|
| 584 | a call of deflate(), since the currently available input may have to
|
| 585 | be compressed and flushed. In particular, strm->avail_out must be non-zero.
|
| 586 |
|
| 587 | deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
|
| 588 | stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
|
| 589 | if strm->avail_out was zero.
|
| 590 |
|
| 591 |
|
| 592 | |
| 593 | extern int inflateInit2 (z_streamp strm, int windowBits);
|
| 594 |
|
| 595 | This is another version of inflateInit with an extra parameter. The
|
| 596 | fields next_in, avail_in, zalloc, zfree and opaque must be initialized
|
| 597 | before by the caller.
|
| 598 |
|
| 599 | The windowBits parameter is the base two logarithm of the maximum window
|
| 600 | size (the size of the history buffer). It should be in the range 8..15 for
|
| 601 | this version of the library. The default value is 15 if inflateInit is used
|
| 602 | instead. windowBits must be greater than or equal to the windowBits value
|
| 603 | provided to deflateInit2() while compressing, or it must be equal to 15 if
|
| 604 | deflateInit2() was not used. If a compressed stream with a larger window
|
| 605 | size is given as input, inflate() will return with the error code
|
| 606 | Z_DATA_ERROR instead of trying to allocate a larger window.
|
| 607 |
|
| 608 | windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
|
| 609 | determines the window size. inflate() will then process raw deflate data,
|
| 610 | not looking for a zlib or gzip header, not generating a check value, and not
|
| 611 | looking for any check values for comparison at the end of the stream. This
|
| 612 | is for use with other formats that use the deflate compressed data format
|
| 613 | such as zip. Those formats provide their own check values. If a custom
|
| 614 | format is developed using the raw deflate format for compressed data, it is
|
| 615 | recommended that a check value such as an adler32 or a crc32 be applied to
|
| 616 | the uncompressed data as is done in the zlib, gzip, and zip formats. For
|
| 617 | most applications, the zlib format should be used as is. Note that comments
|
| 618 | above on the use in deflateInit2() applies to the magnitude of windowBits.
|
| 619 |
|
| 620 | windowBits can also be greater than 15 for optional gzip decoding. Add
|
| 621 | 32 to windowBits to enable zlib and gzip decoding with automatic header
|
| 622 | detection, or add 16 to decode only the gzip format (the zlib format will
|
| 623 | return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is
|
| 624 | a crc32 instead of an adler32.
|
| 625 |
|
| 626 | inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
| 627 | memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
|
| 628 | is set to null if there is no error message. inflateInit2 does not perform
|
| 629 | any decompression apart from reading the zlib header if present: this will
|
| 630 | be done by inflate(). (So next_in and avail_in may be modified, but next_out
|
| 631 | and avail_out are unchanged.)
|
| 632 |
|
| 633 |
|
| 634 | extern int zlib_inflateSetDictionary (z_streamp strm,
|
| 635 | const Byte *dictionary,
|
| 636 | uInt dictLength);
|
| 637 | |
| 638 | Initializes the decompression dictionary from the given uncompressed byte
|
| 639 | sequence. This function must be called immediately after a call of inflate,
|
| 640 | if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
|
| 641 | can be determined from the adler32 value returned by that call of inflate.
|
| 642 | The compressor and decompressor must use exactly the same dictionary (see
|
| 643 | deflateSetDictionary). For raw inflate, this function can be called
|
| 644 | immediately after inflateInit2() or inflateReset() and before any call of
|
| 645 | inflate() to set the dictionary. The application must insure that the
|
| 646 | dictionary that was used for compression is provided.
|
| 647 |
|
| 648 | inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
|
| 649 | parameter is invalid (such as NULL dictionary) or the stream state is
|
| 650 | inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
|
| 651 | expected one (incorrect adler32 value). inflateSetDictionary does not
|
| 652 | perform any decompression: this will be done by subsequent calls of
|
| 653 | inflate().
|
| 654 |
|
| 655 |
|
| 656 | #if 0 |
| 657 | extern int zlib_inflateSync (z_streamp strm);
|
| 658 | #endif
|
| 659 | |
| 660 | Skips invalid compressed data until a full flush point (see above the
|
| 661 | description of deflate with Z_FULL_FLUSH) can be found, or until all
|
| 662 | available input is skipped. No output is provided.
|
| 663 |
|
| 664 | inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
|
| 665 | if no more input was provided, Z_DATA_ERROR if no flush point has been found,
|
| 666 | or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
|
| 667 | case, the application may save the current current value of total_in which
|
| 668 | indicates where valid compressed data was found. In the error case, the
|
| 669 | application may repeatedly call inflateSync, providing more input each time,
|
| 670 | until success or end of the input data.
|
| 671 |
|
| 672 |
|
| 673 | extern int zlib_inflateReset (z_streamp strm);
|
| 674 | |
| 675 | This function is equivalent to inflateEnd followed by inflateInit,
|
| 676 | but does not free and reallocate all the internal decompression state.
|
| 677 | The stream will keep attributes that may have been set by inflateInit2.
|
| 678 |
|
| 679 | inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
| 680 | stream state was inconsistent (such as zalloc or state being NULL).
|
| 681 |
|
| 682 |
|
| 683 | extern int zlib_inflateIncomp (z_stream *strm);
|
| 684 | |
| 685 | This function adds the data at next_in (avail_in bytes) to the output
|
| 686 | history without performing any output. There must be no pending output,
|
| 687 | and the decompressor must be expecting to see the start of a block.
|
| 688 | Calling this function is equivalent to decompressing a stored block
|
| 689 | containing the data at next_in (except that the data is not output).
|
| 690 |
|
| 691 |
|
| 692 | #define zlib_deflateInit(strm, level) \
|
| 693 | zlib_deflateInit2((strm), (level), Z_DEFLATED, MAX_WBITS, \
|
| 694 | DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY)
|
| 695 | #define zlib_inflateInit(strm) \
|
| 696 | zlib_inflateInit2((strm), DEF_WBITS)
|
| 697 |
|
| 698 | extern int zlib_deflateInit2(z_streamp strm, int level, int method,
|
| 699 | int windowBits, int memLevel,
|
| 700 | int strategy);
|
| 701 | extern int zlib_inflateInit2(z_streamp strm, int windowBits);
|
| 702 |
|
| 703 | #if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
|
| 704 | struct internal_state {int dummy;};
|
| 705 | #endif
|
| 706 |
|
| 707 | |
| 708 | * return len or negative error code.
|
| 709 | extern int zlib_inflate_blob(void *dst, unsigned dst_sz, const void *src, unsigned src_sz);
|
| 710 |
|
| 711 | #endif
|