Lines Matching full:be
7 warranty. In no event will the authors be held liable for any damages
14 1. The origin of this software must not be misrepresented; you must not
16 in a product, an acknowledgment in the product documentation would be
18 2. Altered source versions must be plainly marked as such, and must not be
20 3. This notice may not be removed or altered from any source distribution.
47 (deflation) but other algorithms will be added later and will have the same
50 Compression can be done in a single step if the buffers are large
51 enough (for example if an input file is mmap'ed), or can be done by
67 The zlib format was designed to be compact and fast for use in memory
87 Bytef *next_out; /* next output byte should be put there */
110 int text; /* true if compressed data believed to be text */
121 int hcrc; /* true if there was or will be a header crc */
133 compression library and must not be updated by the application.
135 The opaque value provided by the application will be passed as the first
136 parameter for calls of zalloc and zfree. This can be useful for custom
141 If zlib is used in a multi-threaded application, zalloc and zfree must be
144 On 16-bit systems, the functions zalloc and zfree must be able to allocate
145 exactly 65536 bytes, but will not be required to allocate more than this
153 The fields total_in and total_out can be used for statistics or
155 the uncompressed data and may be saved for use in the decompressor
163 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
223 zalloc, zfree and opaque must be initialized before by the caller.
227 The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
238 perform any compression: this will be done by deflate().
253 accordingly. If not all input can be processed (because there is not
260 should be set only when necessary (in interactive applications).
261 Some output may be provided even if flush is not set.
266 should never be zero before the call. The application can consume the
269 and with zero avail_out, it must be called again after making room in the
270 output buffer because there might be more output pending.
281 algorithms and so it should be used only when necessary.
289 If deflate returns with avail_out == 0, this function must be called again
298 was enough output space; if deflate returns with Z_OK, this function must be
304 Z_FINISH can be used immediately after deflateInit if all the compression
305 is to be done in a single step. In this case, avail_out must be at least
307 Z_STREAM_END, then it must be called again as described above.
323 fatal, and deflate() can be called again with more input and more output
337 msg may be set but then points to a static string (which must not be
346 next_in, avail_in, zalloc, zfree and opaque must be initialized before by
350 accordingly; otherwise the allocation will be deferred to the first call of
358 the zlib header if present: this will be done by inflate(). (So next_in and
359 avail_in may be modified, but next_out and avail_out are unchanged.)
374 accordingly. If not all input can be processed (because there is not
389 must be called again after making room in the output buffer because there
390 might be more output pending.
392 The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
407 deflate stream. The end-of-block will not be indicated until all of the
409 number of unused bits may in general be greater than seven, except when
410 bit 7 of data_type is set, in which case the number of unused bits will be
413 inflate() should normally be called until it returns Z_STREAM_END or an
414 error. However if all decompression is to be performed in a single step
415 (a single call of inflate), the parameter flush should be set to
417 output is flushed; avail_out must be large enough to hold all the
420 be inflateEnd to deallocate the decompression state. The use of Z_FINISH
421 is never required, but can be used to inform inflate that a faster approach
422 may be used for the single inflate() call.
455 inflate() can be called again with more input and more output space to
469 was inconsistent. In the error case, msg may be set but then points to a
470 static string (which must not be deallocated).
488 fields next_in, zalloc, zfree and opaque must be initialized before by
491 The method parameter is the compression method. It must be Z_DEFLATED in
495 (the size of the history buffer). It should be in the range 8..15 for this
500 windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
504 windowBits can also be greater than 15 for optional gzip encoding. Add
508 no header crc, and the operating system will be set to 255 (unknown). If a
511 The memLevel parameter specifies how much memory should be allocated
525 Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as
535 not perform any compression: this will be done by deflate().
543 without producing any compressed output. This function must be called
549 to be encountered later in the data to be compressed, with the most commonly
551 dictionary is most useful when the data to be compressed is short and can be
552 predicted with good accuracy; the data can then be compressed better than
556 deflateInit or deflateInit2, a part of the dictionary may in effect be
558 deflate or deflate2. Thus the strings most likely to be useful should be
574 perform any compression: this will be done by deflate().
582 This function can be useful when several compression strategies will be
584 data with a filter. The streams that will be discarded should then be freed
586 compression state which can be quite large, so this strategy is slow and
611 interpretation of level and strategy is as in deflateInit2. This can be
615 is compressed with the old level (and may be flushed); the new level will
618 Before the call of deflateParams, the stream state must be set as for
620 be compressed and flushed. In particular, strm->avail_out must be non-zero.
633 Fine tune deflate's internal compression parameters. This should only be
640 deflateTune() can be called after deflateInit() or deflateInit2(), and
648 deflation of sourceLen bytes. It must be called after deflateInit()
649 or deflateInit2(). This would be used to allocate an output buffer
650 for deflation in a single pass, and so would be called before deflate().
660 this function can only be used for raw deflate, and must be used before the
661 first deflate() call after a deflateInit2() or deflateReset(). bits must be
663 value will be inserted in the output.
673 stream is requested by deflateInit2(). deflateSetHeader() may be called
698 fields next_in, avail_in, zalloc, zfree and opaque must be initialized
702 size (the size of the history buffer). It should be in the range 8..15 for
704 instead. windowBits must be greater than or equal to the windowBits value
705 provided to deflateInit2() while compressing, or it must be equal to 15 if
710 windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
717 recommended that a check value such as an adler32 or a crc32 be applied to
719 most applications, the zlib format should be used as is. Note that comments
722 windowBits can also be greater than 15 for optional gzip decoding. Add
732 be done by inflate(). (So next_in and avail_in may be modified, but next_out
741 sequence. This function must be called immediately after a call of inflate,
743 can be determined from the adler32 value returned by that call of inflate.
745 deflateSetDictionary). For raw inflate, this function can be called
754 perform any decompression: this will be done by subsequent calls of
761 description of deflate with Z_FULL_FLUSH) can be found, or until all
778 This function can be useful when randomly accessing a large stream. The
805 middle of a byte. The provided bits will be used before any bytes are used
806 from next_in. This function should only be used with raw inflate, and
807 should be used before the first inflate() call after inflateInit2() or
808 inflateReset(). bits must be less than or equal to 16, and that many of the
809 least significant bits of value will be inserted in the input.
818 inflateGetHeader() requests that gzip header information be stored in the
819 provided gz_header structure. inflateGetHeader() may be called after
823 being decoded, then head->done is set to -1 to indicate that there will be
824 no gzip header information forthcoming. Note that Z_BLOCK can be used to
843 elsewhere so that they can be eventually freed.
860 calls. The fields zalloc, zfree and opaque in strm must be initialized
865 assured that deflate was used with small window sizes, windowBits must be 15
866 and a 32K byte window must be supplied to be able to decompress general
873 be allocated, or Z_VERSION_ERROR if the version of the library does not
891 inflateBackInit() must be called first to allocate the internal state
893 inflateBack() may then be used multiple times to inflate a complete, raw
898 This routine would normally be used in a utility that reads zip or gzip
919 The length written by out() will be at most the window size. Any non-zero
920 amount of input may be provided by in().
922 For convenience, inflateBack() can be provided input on the first call by
924 in() will be called. Therefore strm->next_in must be initialized before
925 calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called
927 must also be initialized, and then if strm->avail_in is not zero, input will
928 initially be taken from strm->next_in[0 .. strm->avail_in - 1].
932 descriptors can be optionally used to pass any information that the caller-
937 return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
941 initialized. In the case of Z_BUF_ERROR, an input or output error can be
942 distinguished using strm->next_in which will be Z_NULL only if in() returned
944 out() returning non-zero. (in() will always be called before out(), so
945 strm->next_in is assured to be defined if out() returns non-zero.) Note
1006 utility functions can easily be modified if you need special options.
1014 size of the destination buffer, which must be at least the value returned
1017 This function can be used to compress a whole file at once if the
1031 destination buffer, which must be at least the value returned by
1043 compress() or compress2() on sourceLen bytes. It would be used before
1052 size of the destination buffer, which must be large enough to hold the
1057 This function can be used to decompress a whole file at once if the
1077 gzopen can be used to read a file which is not in gzip format; in this
1080 gzopen returns NULL if the file could not be opened or if there was
1082 can be checked to distinguish the two cases (if errno is zero, the
1129 return an error (0) with nothing written. In this case, there may also be a
1165 Push one character back onto the stream to be read again later.
1169 character will be discarded if the stream is repositioned with gzseek()
1178 the flush parameter is Z_FINISH and all output could be flushed.
1179 gzflush should be called only when strictly necessary because it can
1190 If the file is opened for reading, this function is emulated but can be
1198 would be before the current position.
1256 anyway because they might be useful in applications using the
1265 An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
1291 performed within this function so it shouldn't be done by the application.