Branch data Line data Source code
1 : : /* zlib.h -- interface of the 'zlib' general purpose compression library
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 : : jloup@gzip.org madler@alumni.caltech.edu
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 : : /* zlib deflate based on ZLIB_VERSION "1.1.3" */
36 : : /* zlib inflate based on ZLIB_VERSION "1.2.3" */
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; /* next input byte */
86 : : uLong avail_in; /* number of bytes available at next_in */
87 : : uLong total_in; /* total nb of input bytes read so far */
88 : :
89 : : Byte *next_out; /* next output byte should be put there */
90 : : uLong avail_out; /* remaining free space at next_out */
91 : : uLong total_out; /* total nb of bytes output so far */
92 : :
93 : : char *msg; /* last error message, NULL if no error */
94 : : struct internal_state *state; /* not visible by applications */
95 : :
96 : : void *workspace; /* memory allocated for this stream */
97 : :
98 : : int data_type; /* best guess about the data type: ascii or binary */
99 : : uLong adler; /* adler32 value of the uncompressed data */
100 : : uLong reserved; /* reserved for future use */
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 : : /* constants */
138 : :
139 : : #define Z_NO_FLUSH 0
140 : : #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
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 /* Only for inflate at present */
146 : : /* Allowed flush values; see deflate() and inflate() below for details */
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 : : /* Return codes for the compression/decompression functions. Negative
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 : : /* compression levels */
166 : :
167 : : #define Z_FILTERED 1
168 : : #define Z_HUFFMAN_ONLY 2
169 : : #define Z_DEFAULT_STRATEGY 0
170 : : /* compression strategy; see deflateInit2() below for details */
171 : :
172 : : #define Z_BINARY 0
173 : : #define Z_ASCII 1
174 : : #define Z_UNKNOWN 2
175 : : /* Possible values of the data_type field */
176 : :
177 : : #define Z_DEFLATED 8
178 : : /* The deflate compression method (the only one supported in this version) */
179 : :
180 : : /* basic functions */
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 : : extern int zlib_deflate_dfltcc_enabled (void);
195 : : /*
196 : : Returns 1 if Deflate-Conversion facility is installed and enabled,
197 : : otherwise 0.
198 : : */
199 : :
200 : : /*
201 : : extern int deflateInit (z_streamp strm, int level);
202 : :
203 : : Initializes the internal stream state for compression. The fields
204 : : zalloc, zfree and opaque must be initialized before by the caller.
205 : : If zalloc and zfree are set to NULL, deflateInit updates them to
206 : : use default allocation functions.
207 : :
208 : : The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
209 : : 1 gives best speed, 9 gives best compression, 0 gives no compression at
210 : : all (the input data is simply copied a block at a time).
211 : : Z_DEFAULT_COMPRESSION requests a default compromise between speed and
212 : : compression (currently equivalent to level 6).
213 : :
214 : : deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
215 : : enough memory, Z_STREAM_ERROR if level is not a valid compression level,
216 : : Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
217 : : with the version assumed by the caller (ZLIB_VERSION).
218 : : msg is set to null if there is no error message. deflateInit does not
219 : : perform any compression: this will be done by deflate().
220 : : */
221 : :
222 : :
223 : : extern int zlib_deflate (z_streamp strm, int flush);
224 : : /*
225 : : deflate compresses as much data as possible, and stops when the input
226 : : buffer becomes empty or the output buffer becomes full. It may introduce some
227 : : output latency (reading input without producing any output) except when
228 : : forced to flush.
229 : :
230 : : The detailed semantics are as follows. deflate performs one or both of the
231 : : following actions:
232 : :
233 : : - Compress more input starting at next_in and update next_in and avail_in
234 : : accordingly. If not all input can be processed (because there is not
235 : : enough room in the output buffer), next_in and avail_in are updated and
236 : : processing will resume at this point for the next call of deflate().
237 : :
238 : : - Provide more output starting at next_out and update next_out and avail_out
239 : : accordingly. This action is forced if the parameter flush is non zero.
240 : : Forcing flush frequently degrades the compression ratio, so this parameter
241 : : should be set only when necessary (in interactive applications).
242 : : Some output may be provided even if flush is not set.
243 : :
244 : : Before the call of deflate(), the application should ensure that at least
245 : : one of the actions is possible, by providing more input and/or consuming
246 : : more output, and updating avail_in or avail_out accordingly; avail_out
247 : : should never be zero before the call. The application can consume the
248 : : compressed output when it wants, for example when the output buffer is full
249 : : (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
250 : : and with zero avail_out, it must be called again after making room in the
251 : : output buffer because there might be more output pending.
252 : :
253 : : If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
254 : : flushed to the output buffer and the output is aligned on a byte boundary, so
255 : : that the decompressor can get all input data available so far. (In particular
256 : : avail_in is zero after the call if enough output space has been provided
257 : : before the call.) Flushing may degrade compression for some compression
258 : : algorithms and so it should be used only when necessary.
259 : :
260 : : If flush is set to Z_FULL_FLUSH, all output is flushed as with
261 : : Z_SYNC_FLUSH, and the compression state is reset so that decompression can
262 : : restart from this point if previous compressed data has been damaged or if
263 : : random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
264 : : the compression.
265 : :
266 : : If deflate returns with avail_out == 0, this function must be called again
267 : : with the same value of the flush parameter and more output space (updated
268 : : avail_out), until the flush is complete (deflate returns with non-zero
269 : : avail_out).
270 : :
271 : : If the parameter flush is set to Z_FINISH, pending input is processed,
272 : : pending output is flushed and deflate returns with Z_STREAM_END if there
273 : : was enough output space; if deflate returns with Z_OK, this function must be
274 : : called again with Z_FINISH and more output space (updated avail_out) but no
275 : : more input data, until it returns with Z_STREAM_END or an error. After
276 : : deflate has returned Z_STREAM_END, the only possible operations on the
277 : : stream are deflateReset or deflateEnd.
278 : :
279 : : Z_FINISH can be used immediately after deflateInit if all the compression
280 : : is to be done in a single step. In this case, avail_out must be at least
281 : : 0.1% larger than avail_in plus 12 bytes. If deflate does not return
282 : : Z_STREAM_END, then it must be called again as described above.
283 : :
284 : : deflate() sets strm->adler to the adler32 checksum of all input read
285 : : so far (that is, total_in bytes).
286 : :
287 : : deflate() may update data_type if it can make a good guess about
288 : : the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
289 : : binary. This field is only for information purposes and does not affect
290 : : the compression algorithm in any manner.
291 : :
292 : : deflate() returns Z_OK if some progress has been made (more input
293 : : processed or more output produced), Z_STREAM_END if all input has been
294 : : consumed and all output has been produced (only when flush is set to
295 : : Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
296 : : if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
297 : : (for example avail_in or avail_out was zero).
298 : : */
299 : :
300 : :
301 : : extern int zlib_deflateEnd (z_streamp strm);
302 : : /*
303 : : All dynamically allocated data structures for this stream are freed.
304 : : This function discards any unprocessed input and does not flush any
305 : : pending output.
306 : :
307 : : deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
308 : : stream state was inconsistent, Z_DATA_ERROR if the stream was freed
309 : : prematurely (some input or output was discarded). In the error case,
310 : : msg may be set but then points to a static string (which must not be
311 : : deallocated).
312 : : */
313 : :
314 : :
315 : : extern int zlib_inflate_workspacesize (void);
316 : : /*
317 : : Returns the number of bytes that needs to be allocated for a per-
318 : : stream workspace. A pointer to this number of bytes should be
319 : : returned in stream->workspace before calling zlib_inflateInit().
320 : : */
321 : :
322 : : /*
323 : : extern int zlib_inflateInit (z_streamp strm);
324 : :
325 : : Initializes the internal stream state for decompression. The fields
326 : : next_in, avail_in, and workspace must be initialized before by
327 : : the caller. If next_in is not NULL and avail_in is large enough (the exact
328 : : value depends on the compression method), inflateInit determines the
329 : : compression method from the zlib header and allocates all data structures
330 : : accordingly; otherwise the allocation will be deferred to the first call of
331 : : inflate. If zalloc and zfree are set to NULL, inflateInit updates them to
332 : : use default allocation functions.
333 : :
334 : : inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
335 : : memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
336 : : version assumed by the caller. msg is set to null if there is no error
337 : : message. inflateInit does not perform any decompression apart from reading
338 : : the zlib header if present: this will be done by inflate(). (So next_in and
339 : : avail_in may be modified, but next_out and avail_out are unchanged.)
340 : : */
341 : :
342 : :
343 : : extern int zlib_inflate (z_streamp strm, int flush);
344 : : /*
345 : : inflate decompresses as much data as possible, and stops when the input
346 : : buffer becomes empty or the output buffer becomes full. It may introduce
347 : : some output latency (reading input without producing any output) except when
348 : : forced to flush.
349 : :
350 : : The detailed semantics are as follows. inflate performs one or both of the
351 : : following actions:
352 : :
353 : : - Decompress more input starting at next_in and update next_in and avail_in
354 : : accordingly. If not all input can be processed (because there is not
355 : : enough room in the output buffer), next_in is updated and processing
356 : : will resume at this point for the next call of inflate().
357 : :
358 : : - Provide more output starting at next_out and update next_out and avail_out
359 : : accordingly. inflate() provides as much output as possible, until there
360 : : is no more input data or no more space in the output buffer (see below
361 : : about the flush parameter).
362 : :
363 : : Before the call of inflate(), the application should ensure that at least
364 : : one of the actions is possible, by providing more input and/or consuming
365 : : more output, and updating the next_* and avail_* values accordingly.
366 : : The application can consume the uncompressed output when it wants, for
367 : : example when the output buffer is full (avail_out == 0), or after each
368 : : call of inflate(). If inflate returns Z_OK and with zero avail_out, it
369 : : must be called again after making room in the output buffer because there
370 : : might be more output pending.
371 : :
372 : : The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
373 : : Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much
374 : : output as possible to the output buffer. Z_BLOCK requests that inflate() stop
375 : : if and when it gets to the next deflate block boundary. When decoding the
376 : : zlib or gzip format, this will cause inflate() to return immediately after
377 : : the header and before the first block. When doing a raw inflate, inflate()
378 : : will go ahead and process the first block, and will return when it gets to
379 : : the end of that block, or when it runs out of data.
380 : :
381 : : The Z_BLOCK option assists in appending to or combining deflate streams.
382 : : Also to assist in this, on return inflate() will set strm->data_type to the
383 : : number of unused bits in the last byte taken from strm->next_in, plus 64
384 : : if inflate() is currently decoding the last block in the deflate stream,
385 : : plus 128 if inflate() returned immediately after decoding an end-of-block
386 : : code or decoding the complete header up to just before the first byte of the
387 : : deflate stream. The end-of-block will not be indicated until all of the
388 : : uncompressed data from that block has been written to strm->next_out. The
389 : : number of unused bits may in general be greater than seven, except when
390 : : bit 7 of data_type is set, in which case the number of unused bits will be
391 : : less than eight.
392 : :
393 : : inflate() should normally be called until it returns Z_STREAM_END or an
394 : : error. However if all decompression is to be performed in a single step
395 : : (a single call of inflate), the parameter flush should be set to
396 : : Z_FINISH. In this case all pending input is processed and all pending
397 : : output is flushed; avail_out must be large enough to hold all the
398 : : uncompressed data. (The size of the uncompressed data may have been saved
399 : : by the compressor for this purpose.) The next operation on this stream must
400 : : be inflateEnd to deallocate the decompression state. The use of Z_FINISH
401 : : is never required, but can be used to inform inflate that a faster approach
402 : : may be used for the single inflate() call.
403 : :
404 : : In this implementation, inflate() always flushes as much output as
405 : : possible to the output buffer, and always uses the faster approach on the
406 : : first call. So the only effect of the flush parameter in this implementation
407 : : is on the return value of inflate(), as noted below, or when it returns early
408 : : because Z_BLOCK is used.
409 : :
410 : : If a preset dictionary is needed after this call (see inflateSetDictionary
411 : : below), inflate sets strm->adler to the adler32 checksum of the dictionary
412 : : chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
413 : : strm->adler to the adler32 checksum of all output produced so far (that is,
414 : : total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
415 : : below. At the end of the stream, inflate() checks that its computed adler32
416 : : checksum is equal to that saved by the compressor and returns Z_STREAM_END
417 : : only if the checksum is correct.
418 : :
419 : : inflate() will decompress and check either zlib-wrapped or gzip-wrapped
420 : : deflate data. The header type is detected automatically. Any information
421 : : contained in the gzip header is not retained, so applications that need that
422 : : information should instead use raw inflate, see inflateInit2() below, or
423 : : inflateBack() and perform their own processing of the gzip header and
424 : : trailer.
425 : :
426 : : inflate() returns Z_OK if some progress has been made (more input processed
427 : : or more output produced), Z_STREAM_END if the end of the compressed data has
428 : : been reached and all uncompressed output has been produced, Z_NEED_DICT if a
429 : : preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
430 : : corrupted (input stream not conforming to the zlib format or incorrect check
431 : : value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
432 : : if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
433 : : Z_BUF_ERROR if no progress is possible or if there was not enough room in the
434 : : output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
435 : : inflate() can be called again with more input and more output space to
436 : : continue decompressing. If Z_DATA_ERROR is returned, the application may then
437 : : call inflateSync() to look for a good compression block if a partial recovery
438 : : of the data is desired.
439 : : */
440 : :
441 : :
442 : : extern int zlib_inflateEnd (z_streamp strm);
443 : : /*
444 : : All dynamically allocated data structures for this stream are freed.
445 : : This function discards any unprocessed input and does not flush any
446 : : pending output.
447 : :
448 : : inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
449 : : was inconsistent. In the error case, msg may be set but then points to a
450 : : static string (which must not be deallocated).
451 : : */
452 : :
453 : : /* Advanced functions */
454 : :
455 : : /*
456 : : The following functions are needed only in some special applications.
457 : : */
458 : :
459 : : /*
460 : : extern int deflateInit2 (z_streamp strm,
461 : : int level,
462 : : int method,
463 : : int windowBits,
464 : : int memLevel,
465 : : int strategy);
466 : :
467 : : This is another version of deflateInit with more compression options. The
468 : : fields next_in, zalloc, zfree and opaque must be initialized before by
469 : : the caller.
470 : :
471 : : The method parameter is the compression method. It must be Z_DEFLATED in
472 : : this version of the library.
473 : :
474 : : The windowBits parameter is the base two logarithm of the window size
475 : : (the size of the history buffer). It should be in the range 8..15 for this
476 : : version of the library. Larger values of this parameter result in better
477 : : compression at the expense of memory usage. The default value is 15 if
478 : : deflateInit is used instead.
479 : :
480 : : The memLevel parameter specifies how much memory should be allocated
481 : : for the internal compression state. memLevel=1 uses minimum memory but
482 : : is slow and reduces compression ratio; memLevel=9 uses maximum memory
483 : : for optimal speed. The default value is 8. See zconf.h for total memory
484 : : usage as a function of windowBits and memLevel.
485 : :
486 : : The strategy parameter is used to tune the compression algorithm. Use the
487 : : value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
488 : : filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
489 : : string match). Filtered data consists mostly of small values with a
490 : : somewhat random distribution. In this case, the compression algorithm is
491 : : tuned to compress them better. The effect of Z_FILTERED is to force more
492 : : Huffman coding and less string matching; it is somewhat intermediate
493 : : between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
494 : : the compression ratio but not the correctness of the compressed output even
495 : : if it is not set appropriately.
496 : :
497 : : deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
498 : : memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
499 : : method). msg is set to null if there is no error message. deflateInit2 does
500 : : not perform any compression: this will be done by deflate().
501 : : */
502 : :
503 : : extern int zlib_deflateReset (z_streamp strm);
504 : : /*
505 : : This function is equivalent to deflateEnd followed by deflateInit,
506 : : but does not free and reallocate all the internal compression state.
507 : : The stream will keep the same compression level and any other attributes
508 : : that may have been set by deflateInit2.
509 : :
510 : : deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
511 : : stream state was inconsistent (such as zalloc or state being NULL).
512 : : */
513 : :
514 : 0 : static inline unsigned long deflateBound(unsigned long s)
515 : : {
516 [ # # ]: 0 : return s + ((s + 7) >> 3) + ((s + 63) >> 6) + 11;
517 : : }
518 : :
519 : : /*
520 : : extern int inflateInit2 (z_streamp strm, int windowBits);
521 : :
522 : : This is another version of inflateInit with an extra parameter. The
523 : : fields next_in, avail_in, zalloc, zfree and opaque must be initialized
524 : : before by the caller.
525 : :
526 : : The windowBits parameter is the base two logarithm of the maximum window
527 : : size (the size of the history buffer). It should be in the range 8..15 for
528 : : this version of the library. The default value is 15 if inflateInit is used
529 : : instead. windowBits must be greater than or equal to the windowBits value
530 : : provided to deflateInit2() while compressing, or it must be equal to 15 if
531 : : deflateInit2() was not used. If a compressed stream with a larger window
532 : : size is given as input, inflate() will return with the error code
533 : : Z_DATA_ERROR instead of trying to allocate a larger window.
534 : :
535 : : windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
536 : : determines the window size. inflate() will then process raw deflate data,
537 : : not looking for a zlib or gzip header, not generating a check value, and not
538 : : looking for any check values for comparison at the end of the stream. This
539 : : is for use with other formats that use the deflate compressed data format
540 : : such as zip. Those formats provide their own check values. If a custom
541 : : format is developed using the raw deflate format for compressed data, it is
542 : : recommended that a check value such as an adler32 or a crc32 be applied to
543 : : the uncompressed data as is done in the zlib, gzip, and zip formats. For
544 : : most applications, the zlib format should be used as is. Note that comments
545 : : above on the use in deflateInit2() applies to the magnitude of windowBits.
546 : :
547 : : windowBits can also be greater than 15 for optional gzip decoding. Add
548 : : 32 to windowBits to enable zlib and gzip decoding with automatic header
549 : : detection, or add 16 to decode only the gzip format (the zlib format will
550 : : return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is
551 : : a crc32 instead of an adler32.
552 : :
553 : : inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
554 : : memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
555 : : is set to null if there is no error message. inflateInit2 does not perform
556 : : any decompression apart from reading the zlib header if present: this will
557 : : be done by inflate(). (So next_in and avail_in may be modified, but next_out
558 : : and avail_out are unchanged.)
559 : : */
560 : :
561 : : extern int zlib_inflateReset (z_streamp strm);
562 : : /*
563 : : This function is equivalent to inflateEnd followed by inflateInit,
564 : : but does not free and reallocate all the internal decompression state.
565 : : The stream will keep attributes that may have been set by inflateInit2.
566 : :
567 : : inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
568 : : stream state was inconsistent (such as zalloc or state being NULL).
569 : : */
570 : :
571 : : extern int zlib_inflateIncomp (z_stream *strm);
572 : : /*
573 : : This function adds the data at next_in (avail_in bytes) to the output
574 : : history without performing any output. There must be no pending output,
575 : : and the decompressor must be expecting to see the start of a block.
576 : : Calling this function is equivalent to decompressing a stored block
577 : : containing the data at next_in (except that the data is not output).
578 : : */
579 : :
580 : : #define zlib_deflateInit(strm, level) \
581 : : zlib_deflateInit2((strm), (level), Z_DEFLATED, MAX_WBITS, \
582 : : DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY)
583 : : #define zlib_inflateInit(strm) \
584 : : zlib_inflateInit2((strm), DEF_WBITS)
585 : :
586 : : extern int zlib_deflateInit2(z_streamp strm, int level, int method,
587 : : int windowBits, int memLevel,
588 : : int strategy);
589 : : extern int zlib_inflateInit2(z_streamp strm, int windowBits);
590 : :
591 : : #if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
592 : : struct internal_state {int dummy;}; /* hack for buggy compilers */
593 : : #endif
594 : :
595 : : /* Utility function: initialize zlib, unpack binary blob, clean up zlib,
596 : : * return len or negative error code. */
597 : : extern int zlib_inflate_blob(void *dst, unsigned dst_sz, const void *src, unsigned src_sz);
598 : :
599 : : #endif /* _ZLIB_H */
|
