diff options
Diffstat (limited to 'rbutil/rbutilqt/zlib/zlib.h')
-rw-r--r-- | rbutil/rbutilqt/zlib/zlib.h | 2400 |
1 files changed, 1200 insertions, 1200 deletions
diff --git a/rbutil/rbutilqt/zlib/zlib.h b/rbutil/rbutilqt/zlib/zlib.h index e067b127bf..b4ddd34395 100644 --- a/rbutil/rbutilqt/zlib/zlib.h +++ b/rbutil/rbutilqt/zlib/zlib.h | |||
@@ -1,1200 +1,1200 @@ | |||
1 | /* zlib.h -- interface of the 'zlib' general purpose compression library | 1 | /* zlib.h -- interface of the 'zlib' general purpose compression library |
2 | version 1.2.2, October 3rd, 2004 | 2 | version 1.2.2, October 3rd, 2004 |
3 | 3 | ||
4 | Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler | 4 | Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler |
5 | 5 | ||
6 | This software is provided 'as-is', without any express or implied | 6 | This software is provided 'as-is', without any express or implied |
7 | warranty. In no event will the authors be held liable for any damages | 7 | warranty. In no event will the authors be held liable for any damages |
8 | arising from the use of this software. | 8 | arising from the use of this software. |
9 | 9 | ||
10 | Permission is granted to anyone to use this software for any purpose, | 10 | Permission is granted to anyone to use this software for any purpose, |
11 | including commercial applications, and to alter it and redistribute it | 11 | including commercial applications, and to alter it and redistribute it |
12 | freely, subject to the following restrictions: | 12 | freely, subject to the following restrictions: |
13 | 13 | ||
14 | 1. The origin of this software must not be misrepresented; you must not | 14 | 1. The origin of this software must not be misrepresented; you must not |
15 | claim that you wrote the original software. If you use this software | 15 | claim that you wrote the original software. If you use this software |
16 | in a product, an acknowledgment in the product documentation would be | 16 | in a product, an acknowledgment in the product documentation would be |
17 | appreciated but is not required. | 17 | appreciated but is not required. |
18 | 2. Altered source versions must be plainly marked as such, and must not be | 18 | 2. Altered source versions must be plainly marked as such, and must not be |
19 | misrepresented as being the original software. | 19 | misrepresented as being the original software. |
20 | 3. This notice may not be removed or altered from any source distribution. | 20 | 3. This notice may not be removed or altered from any source distribution. |
21 | 21 | ||
22 | Jean-loup Gailly Mark Adler | 22 | Jean-loup Gailly Mark Adler |
23 | jloup@gzip.org madler@alumni.caltech.edu | 23 | jloup@gzip.org madler@alumni.caltech.edu |
24 | 24 | ||
25 | 25 | ||
26 | The data format used by the zlib library is described by RFCs (Request for | 26 | The data format used by the zlib library is described by RFCs (Request for |
27 | Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt | 27 | Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt |
28 | (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). | 28 | (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). |
29 | */ | 29 | */ |
30 | 30 | ||
31 | #ifndef ZLIB_H | 31 | #ifndef ZLIB_H |
32 | #define ZLIB_H | 32 | #define ZLIB_H |
33 | 33 | ||
34 | #include "zconf.h" | 34 | #include "zconf.h" |
35 | 35 | ||
36 | #ifdef __cplusplus | 36 | #ifdef __cplusplus |
37 | extern "C" { | 37 | extern "C" { |
38 | #endif | 38 | #endif |
39 | 39 | ||
40 | #define ZLIB_VERSION "1.2.2" | 40 | #define ZLIB_VERSION "1.2.2" |
41 | #define ZLIB_VERNUM 0x1220 | 41 | #define ZLIB_VERNUM 0x1220 |
42 | 42 | ||
43 | /* | 43 | /* |
44 | The 'zlib' compression library provides in-memory compression and | 44 | The 'zlib' compression library provides in-memory compression and |
45 | decompression functions, including integrity checks of the uncompressed | 45 | decompression functions, including integrity checks of the uncompressed |
46 | data. This version of the library supports only one compression method | 46 | data. This version of the library supports only one compression method |
47 | (deflation) but other algorithms will be added later and will have the same | 47 | (deflation) but other algorithms will be added later and will have the same |
48 | stream interface. | 48 | stream interface. |
49 | 49 | ||
50 | Compression can be done in a single step if the buffers are large | 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 | 51 | enough (for example if an input file is mmap'ed), or can be done by |
52 | repeated calls of the compression function. In the latter case, the | 52 | repeated calls of the compression function. In the latter case, the |
53 | application must provide more input and/or consume the output | 53 | application must provide more input and/or consume the output |
54 | (providing more output space) before each call. | 54 | (providing more output space) before each call. |
55 | 55 | ||
56 | The compressed data format used by default by the in-memory functions is | 56 | The compressed data format used by default by the in-memory functions is |
57 | the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped | 57 | the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped |
58 | around a deflate stream, which is itself documented in RFC 1951. | 58 | around a deflate stream, which is itself documented in RFC 1951. |
59 | 59 | ||
60 | The library also supports reading and writing files in gzip (.gz) format | 60 | The library also supports reading and writing files in gzip (.gz) format |
61 | with an interface similar to that of stdio using the functions that start | 61 | with an interface similar to that of stdio using the functions that start |
62 | with "gz". The gzip format is different from the zlib format. gzip is a | 62 | with "gz". The gzip format is different from the zlib format. gzip is a |
63 | gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. | 63 | gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. |
64 | 64 | ||
65 | This library can optionally read and write gzip streams in memory as well. | 65 | This library can optionally read and write gzip streams in memory as well. |
66 | 66 | ||
67 | The zlib format was designed to be compact and fast for use in memory | 67 | The zlib format was designed to be compact and fast for use in memory |
68 | and on communications channels. The gzip format was designed for single- | 68 | and on communications channels. The gzip format was designed for single- |
69 | file compression on file systems, has a larger header than zlib to maintain | 69 | file compression on file systems, has a larger header than zlib to maintain |
70 | directory information, and uses a different, slower check method than zlib. | 70 | directory information, and uses a different, slower check method than zlib. |
71 | 71 | ||
72 | The library does not install any signal handler. The decoder checks | 72 | The library does not install any signal handler. The decoder checks |
73 | the consistency of the compressed data, so the library should never | 73 | the consistency of the compressed data, so the library should never |
74 | crash even in case of corrupted input. | 74 | crash even in case of corrupted input. |
75 | */ | 75 | */ |
76 | 76 | ||
77 | typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); | 77 | typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); |
78 | typedef void (*free_func) OF((voidpf opaque, voidpf address)); | 78 | typedef void (*free_func) OF((voidpf opaque, voidpf address)); |
79 | 79 | ||
80 | struct internal_state; | 80 | struct internal_state; |
81 | 81 | ||
82 | typedef struct z_stream_s { | 82 | typedef struct z_stream_s { |
83 | Bytef *next_in; /* next input byte */ | 83 | Bytef *next_in; /* next input byte */ |
84 | uInt avail_in; /* number of bytes available at next_in */ | 84 | uInt avail_in; /* number of bytes available at next_in */ |
85 | uLong total_in; /* total nb of input bytes read so far */ | 85 | uLong total_in; /* total nb of input bytes read so far */ |
86 | 86 | ||
87 | Bytef *next_out; /* next output byte should be put there */ | 87 | Bytef *next_out; /* next output byte should be put there */ |
88 | uInt avail_out; /* remaining free space at next_out */ | 88 | uInt avail_out; /* remaining free space at next_out */ |
89 | uLong total_out; /* total nb of bytes output so far */ | 89 | uLong total_out; /* total nb of bytes output so far */ |
90 | 90 | ||
91 | char *msg; /* last error message, NULL if no error */ | 91 | char *msg; /* last error message, NULL if no error */ |
92 | struct internal_state FAR *state; /* not visible by applications */ | 92 | struct internal_state FAR *state; /* not visible by applications */ |
93 | 93 | ||
94 | alloc_func zalloc; /* used to allocate the internal state */ | 94 | alloc_func zalloc; /* used to allocate the internal state */ |
95 | free_func zfree; /* used to free the internal state */ | 95 | free_func zfree; /* used to free the internal state */ |
96 | voidpf opaque; /* private data object passed to zalloc and zfree */ | 96 | voidpf opaque; /* private data object passed to zalloc and zfree */ |
97 | 97 | ||
98 | int data_type; /* best guess about the data type: ascii or binary */ | 98 | int data_type; /* best guess about the data type: ascii or binary */ |
99 | uLong adler; /* adler32 value of the uncompressed data */ | 99 | uLong adler; /* adler32 value of the uncompressed data */ |
100 | uLong reserved; /* reserved for future use */ | 100 | uLong reserved; /* reserved for future use */ |
101 | } z_stream; | 101 | } z_stream; |
102 | 102 | ||
103 | typedef z_stream FAR *z_streamp; | 103 | typedef z_stream FAR *z_streamp; |
104 | 104 | ||
105 | /* | 105 | /* |
106 | The application must update next_in and avail_in when avail_in has | 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 | 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 | 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 | 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. | 110 | compression library and must not be updated by the application. |
111 | 111 | ||
112 | The opaque value provided by the application will be passed as the first | 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 | 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 | 114 | memory management. The compression library attaches no meaning to the |
115 | opaque value. | 115 | opaque value. |
116 | 116 | ||
117 | zalloc must return Z_NULL if there is not enough memory for the object. | 117 | zalloc must return Z_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 | 118 | If zlib is used in a multi-threaded application, zalloc and zfree must be |
119 | thread safe. | 119 | thread safe. |
120 | 120 | ||
121 | On 16-bit systems, the functions zalloc and zfree must be able to allocate | 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 | 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, | 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* | 124 | pointers returned by zalloc for objects of exactly 65536 bytes *must* |
125 | have their offset normalized to zero. The default allocation function | 125 | have their offset normalized to zero. The default allocation function |
126 | provided by this library ensures this (see zutil.c). To reduce memory | 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 | 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). | 128 | compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). |
129 | 129 | ||
130 | The fields total_in and total_out can be used for statistics or | 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 | 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 | 132 | the uncompressed data and may be saved for use in the decompressor |
133 | (particularly if the decompressor wants to decompress everything in | 133 | (particularly if the decompressor wants to decompress everything in |
134 | a single step). | 134 | a single step). |
135 | */ | 135 | */ |
136 | 136 | ||
137 | /* constants */ | 137 | /* constants */ |
138 | 138 | ||
139 | #define Z_NO_FLUSH 0 | 139 | #define Z_NO_FLUSH 0 |
140 | #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ | 140 | #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ |
141 | #define Z_SYNC_FLUSH 2 | 141 | #define Z_SYNC_FLUSH 2 |
142 | #define Z_FULL_FLUSH 3 | 142 | #define Z_FULL_FLUSH 3 |
143 | #define Z_FINISH 4 | 143 | #define Z_FINISH 4 |
144 | #define Z_BLOCK 5 | 144 | #define Z_BLOCK 5 |
145 | /* Allowed flush values; see deflate() and inflate() below for details */ | 145 | /* Allowed flush values; see deflate() and inflate() below for details */ |
146 | 146 | ||
147 | #define Z_OK 0 | 147 | #define Z_OK 0 |
148 | #define Z_STREAM_END 1 | 148 | #define Z_STREAM_END 1 |
149 | #define Z_NEED_DICT 2 | 149 | #define Z_NEED_DICT 2 |
150 | #define Z_ERRNO (-1) | 150 | #define Z_ERRNO (-1) |
151 | #define Z_STREAM_ERROR (-2) | 151 | #define Z_STREAM_ERROR (-2) |
152 | #define Z_DATA_ERROR (-3) | 152 | #define Z_DATA_ERROR (-3) |
153 | #define Z_MEM_ERROR (-4) | 153 | #define Z_MEM_ERROR (-4) |
154 | #define Z_BUF_ERROR (-5) | 154 | #define Z_BUF_ERROR (-5) |
155 | #define Z_VERSION_ERROR (-6) | 155 | #define Z_VERSION_ERROR (-6) |
156 | /* Return codes for the compression/decompression functions. Negative | 156 | /* Return codes for the compression/decompression functions. Negative |
157 | * values are errors, positive values are used for special but normal events. | 157 | * values are errors, positive values are used for special but normal events. |
158 | */ | 158 | */ |
159 | 159 | ||
160 | #define Z_NO_COMPRESSION 0 | 160 | #define Z_NO_COMPRESSION 0 |
161 | #define Z_BEST_SPEED 1 | 161 | #define Z_BEST_SPEED 1 |
162 | #define Z_BEST_COMPRESSION 9 | 162 | #define Z_BEST_COMPRESSION 9 |
163 | #define Z_DEFAULT_COMPRESSION (-1) | 163 | #define Z_DEFAULT_COMPRESSION (-1) |
164 | /* compression levels */ | 164 | /* compression levels */ |
165 | 165 | ||
166 | #define Z_FILTERED 1 | 166 | #define Z_FILTERED 1 |
167 | #define Z_HUFFMAN_ONLY 2 | 167 | #define Z_HUFFMAN_ONLY 2 |
168 | #define Z_RLE 3 | 168 | #define Z_RLE 3 |
169 | #define Z_DEFAULT_STRATEGY 0 | 169 | #define Z_DEFAULT_STRATEGY 0 |
170 | /* compression strategy; see deflateInit2() below for details */ | 170 | /* compression strategy; see deflateInit2() below for details */ |
171 | 171 | ||
172 | #define Z_BINARY 0 | 172 | #define Z_BINARY 0 |
173 | #define Z_ASCII 1 | 173 | #define Z_ASCII 1 |
174 | #define Z_UNKNOWN 2 | 174 | #define Z_UNKNOWN 2 |
175 | /* Possible values of the data_type field (though see inflate()) */ | 175 | /* Possible values of the data_type field (though see inflate()) */ |
176 | 176 | ||
177 | #define Z_DEFLATED 8 | 177 | #define Z_DEFLATED 8 |
178 | /* The deflate compression method (the only one supported in this version) */ | 178 | /* The deflate compression method (the only one supported in this version) */ |
179 | 179 | ||
180 | #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ | 180 | #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ |
181 | 181 | ||
182 | #define zlib_version zlibVersion() | 182 | #define zlib_version zlibVersion() |
183 | /* for compatibility with versions < 1.0.2 */ | 183 | /* for compatibility with versions < 1.0.2 */ |
184 | 184 | ||
185 | /* basic functions */ | 185 | /* basic functions */ |
186 | 186 | ||
187 | ZEXTERN const char * ZEXPORT zlibVersion OF((void)); | 187 | ZEXTERN const char * ZEXPORT zlibVersion OF((void)); |
188 | /* The application can compare zlibVersion and ZLIB_VERSION for consistency. | 188 | /* The application can compare zlibVersion and ZLIB_VERSION for consistency. |
189 | If the first character differs, the library code actually used is | 189 | If the first character differs, the library code actually used is |
190 | not compatible with the zlib.h header file used by the application. | 190 | not compatible with the zlib.h header file used by the application. |
191 | This check is automatically made by deflateInit and inflateInit. | 191 | This check is automatically made by deflateInit and inflateInit. |
192 | */ | 192 | */ |
193 | 193 | ||
194 | /* | 194 | /* |
195 | ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); | 195 | ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); |
196 | 196 | ||
197 | Initializes the internal stream state for compression. The fields | 197 | Initializes the internal stream state for compression. The fields |
198 | zalloc, zfree and opaque must be initialized before by the caller. | 198 | zalloc, zfree and opaque must be initialized before by the caller. |
199 | If zalloc and zfree are set to Z_NULL, deflateInit updates them to | 199 | If zalloc and zfree are set to Z_NULL, deflateInit updates them to |
200 | use default allocation functions. | 200 | use default allocation functions. |
201 | 201 | ||
202 | The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: | 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 | 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). | 204 | all (the input data is simply copied a block at a time). |
205 | Z_DEFAULT_COMPRESSION requests a default compromise between speed and | 205 | Z_DEFAULT_COMPRESSION requests a default compromise between speed and |
206 | compression (currently equivalent to level 6). | 206 | compression (currently equivalent to level 6). |
207 | 207 | ||
208 | deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not | 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, | 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 | 210 | Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible |
211 | with the version assumed by the caller (ZLIB_VERSION). | 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 | 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(). | 213 | perform any compression: this will be done by deflate(). |
214 | */ | 214 | */ |
215 | 215 | ||
216 | 216 | ||
217 | ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); | 217 | ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); |
218 | /* | 218 | /* |
219 | deflate compresses as much data as possible, and stops when the input | 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 | 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 | 221 | output latency (reading input without producing any output) except when |
222 | forced to flush. | 222 | forced to flush. |
223 | 223 | ||
224 | The detailed semantics are as follows. deflate performs one or both of the | 224 | The detailed semantics are as follows. deflate performs one or both of the |
225 | following actions: | 225 | following actions: |
226 | 226 | ||
227 | - Compress more input starting at next_in and update next_in and avail_in | 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 | 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 | 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(). | 230 | processing will resume at this point for the next call of deflate(). |
231 | 231 | ||
232 | - Provide more output starting at next_out and update next_out and avail_out | 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. | 233 | accordingly. This action is forced if the parameter flush is non zero. |
234 | Forcing flush frequently degrades the compression ratio, so this parameter | 234 | Forcing flush frequently degrades the compression ratio, so this parameter |
235 | should be set only when necessary (in interactive applications). | 235 | should be set only when necessary (in interactive applications). |
236 | Some output may be provided even if flush is not set. | 236 | Some output may be provided even if flush is not set. |
237 | 237 | ||
238 | Before the call of deflate(), the application should ensure that at least | 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 | 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 | 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 | 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 | 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 | 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 | 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. | 245 | output buffer because there might be more output pending. |
246 | 246 | ||
247 | If the parameter flush is set to Z_SYNC_FLUSH, all pending output is | 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 | 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 | 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 | 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 | 251 | before the call.) Flushing may degrade compression for some compression |
252 | algorithms and so it should be used only when necessary. | 252 | algorithms and so it should be used only when necessary. |
253 | 253 | ||
254 | If flush is set to Z_FULL_FLUSH, all output is flushed as with | 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 | 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 | 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 | 257 | random access is desired. Using Z_FULL_FLUSH too often can seriously degrade |
258 | the compression. | 258 | the compression. |
259 | 259 | ||
260 | If deflate returns with avail_out == 0, this function must be called again | 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 | 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 | 262 | avail_out), until the flush is complete (deflate returns with non-zero |
263 | avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that | 263 | avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that |
264 | avail_out is greater than six to avoid repeated flush markers due to | 264 | avail_out is greater than six to avoid repeated flush markers due to |
265 | avail_out == 0 on return. | 265 | avail_out == 0 on return. |
266 | 266 | ||
267 | If the parameter flush is set to Z_FINISH, pending input is processed, | 267 | If the parameter flush is set to Z_FINISH, pending input is processed, |
268 | pending output is flushed and deflate returns with Z_STREAM_END if there | 268 | pending output is flushed and deflate returns with Z_STREAM_END if there |
269 | was enough output space; if deflate returns with Z_OK, this function must be | 269 | was enough output space; if deflate returns with Z_OK, this function must be |
270 | called again with Z_FINISH and more output space (updated avail_out) but no | 270 | called again with Z_FINISH and more output space (updated avail_out) but no |
271 | more input data, until it returns with Z_STREAM_END or an error. After | 271 | more input data, until it returns with Z_STREAM_END or an error. After |
272 | deflate has returned Z_STREAM_END, the only possible operations on the | 272 | deflate has returned Z_STREAM_END, the only possible operations on the |
273 | stream are deflateReset or deflateEnd. | 273 | stream are deflateReset or deflateEnd. |
274 | 274 | ||
275 | Z_FINISH can be used immediately after deflateInit if all the compression | 275 | Z_FINISH can be used immediately after deflateInit if all the compression |
276 | is to be done in a single step. In this case, avail_out must be at least | 276 | is to be done in a single step. In this case, avail_out must be at least |
277 | the value returned by deflateBound (see below). If deflate does not return | 277 | the value returned by deflateBound (see below). If deflate does not return |
278 | Z_STREAM_END, then it must be called again as described above. | 278 | Z_STREAM_END, then it must be called again as described above. |
279 | 279 | ||
280 | deflate() sets strm->adler to the adler32 checksum of all input read | 280 | deflate() sets strm->adler to the adler32 checksum of all input read |
281 | so far (that is, total_in bytes). | 281 | so far (that is, total_in bytes). |
282 | 282 | ||
283 | deflate() may update data_type if it can make a good guess about | 283 | deflate() may update data_type if it can make a good guess about |
284 | the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered | 284 | the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered |
285 | binary. This field is only for information purposes and does not affect | 285 | binary. This field is only for information purposes and does not affect |
286 | the compression algorithm in any manner. | 286 | the compression algorithm in any manner. |
287 | 287 | ||
288 | deflate() returns Z_OK if some progress has been made (more input | 288 | deflate() returns Z_OK if some progress has been made (more input |
289 | processed or more output produced), Z_STREAM_END if all input has been | 289 | processed or more output produced), Z_STREAM_END if all input has been |
290 | consumed and all output has been produced (only when flush is set to | 290 | consumed and all output has been produced (only when flush is set to |
291 | Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example | 291 | Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example |
292 | if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible | 292 | if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible |
293 | (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not | 293 | (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not |
294 | fatal, and deflate() can be called again with more input and more output | 294 | fatal, and deflate() can be called again with more input and more output |
295 | space to continue compressing. | 295 | space to continue compressing. |
296 | */ | 296 | */ |
297 | 297 | ||
298 | 298 | ||
299 | ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); | 299 | ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); |
300 | /* | 300 | /* |
301 | All dynamically allocated data structures for this stream are freed. | 301 | All dynamically allocated data structures for this stream are freed. |
302 | This function discards any unprocessed input and does not flush any | 302 | This function discards any unprocessed input and does not flush any |
303 | pending output. | 303 | pending output. |
304 | 304 | ||
305 | deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the | 305 | deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the |
306 | stream state was inconsistent, Z_DATA_ERROR if the stream was freed | 306 | stream state was inconsistent, Z_DATA_ERROR if the stream was freed |
307 | prematurely (some input or output was discarded). In the error case, | 307 | prematurely (some input or output was discarded). In the error case, |
308 | msg may be set but then points to a static string (which must not be | 308 | msg may be set but then points to a static string (which must not be |
309 | deallocated). | 309 | deallocated). |
310 | */ | 310 | */ |
311 | 311 | ||
312 | 312 | ||
313 | /* | 313 | /* |
314 | ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); | 314 | ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); |
315 | 315 | ||
316 | Initializes the internal stream state for decompression. The fields | 316 | Initializes the internal stream state for decompression. The fields |
317 | next_in, avail_in, zalloc, zfree and opaque must be initialized before by | 317 | next_in, avail_in, zalloc, zfree and opaque must be initialized before by |
318 | the caller. If next_in is not Z_NULL and avail_in is large enough (the exact | 318 | the caller. If next_in is not Z_NULL and avail_in is large enough (the exact |
319 | value depends on the compression method), inflateInit determines the | 319 | value depends on the compression method), inflateInit determines the |
320 | compression method from the zlib header and allocates all data structures | 320 | compression method from the zlib header and allocates all data structures |
321 | accordingly; otherwise the allocation will be deferred to the first call of | 321 | accordingly; otherwise the allocation will be deferred to the first call of |
322 | inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to | 322 | inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to |
323 | use default allocation functions. | 323 | use default allocation functions. |
324 | 324 | ||
325 | inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough | 325 | inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough |
326 | memory, Z_VERSION_ERROR if the zlib library version is incompatible with the | 326 | memory, Z_VERSION_ERROR if the zlib library version is incompatible with the |
327 | version assumed by the caller. msg is set to null if there is no error | 327 | version assumed by the caller. msg is set to null if there is no error |
328 | message. inflateInit does not perform any decompression apart from reading | 328 | message. inflateInit does not perform any decompression apart from reading |
329 | the zlib header if present: this will be done by inflate(). (So next_in and | 329 | the zlib header if present: this will be done by inflate(). (So next_in and |
330 | avail_in may be modified, but next_out and avail_out are unchanged.) | 330 | avail_in may be modified, but next_out and avail_out are unchanged.) |
331 | */ | 331 | */ |
332 | 332 | ||
333 | 333 | ||
334 | ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); | 334 | ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); |
335 | /* | 335 | /* |
336 | inflate decompresses as much data as possible, and stops when the input | 336 | inflate decompresses as much data as possible, and stops when the input |
337 | buffer becomes empty or the output buffer becomes full. It may introduce | 337 | buffer becomes empty or the output buffer becomes full. It may introduce |
338 | some output latency (reading input without producing any output) except when | 338 | some output latency (reading input without producing any output) except when |
339 | forced to flush. | 339 | forced to flush. |
340 | 340 | ||
341 | The detailed semantics are as follows. inflate performs one or both of the | 341 | The detailed semantics are as follows. inflate performs one or both of the |
342 | following actions: | 342 | following actions: |
343 | 343 | ||
344 | - Decompress more input starting at next_in and update next_in and avail_in | 344 | - Decompress more input starting at next_in and update next_in and avail_in |
345 | accordingly. If not all input can be processed (because there is not | 345 | accordingly. If not all input can be processed (because there is not |
346 | enough room in the output buffer), next_in is updated and processing | 346 | enough room in the output buffer), next_in is updated and processing |
347 | will resume at this point for the next call of inflate(). | 347 | will resume at this point for the next call of inflate(). |
348 | 348 | ||
349 | - Provide more output starting at next_out and update next_out and avail_out | 349 | - Provide more output starting at next_out and update next_out and avail_out |
350 | accordingly. inflate() provides as much output as possible, until there | 350 | accordingly. inflate() provides as much output as possible, until there |
351 | is no more input data or no more space in the output buffer (see below | 351 | is no more input data or no more space in the output buffer (see below |
352 | about the flush parameter). | 352 | about the flush parameter). |
353 | 353 | ||
354 | Before the call of inflate(), the application should ensure that at least | 354 | Before the call of inflate(), the application should ensure that at least |
355 | one of the actions is possible, by providing more input and/or consuming | 355 | one of the actions is possible, by providing more input and/or consuming |
356 | more output, and updating the next_* and avail_* values accordingly. | 356 | more output, and updating the next_* and avail_* values accordingly. |
357 | The application can consume the uncompressed output when it wants, for | 357 | The application can consume the uncompressed output when it wants, for |
358 | example when the output buffer is full (avail_out == 0), or after each | 358 | example when the output buffer is full (avail_out == 0), or after each |
359 | call of inflate(). If inflate returns Z_OK and with zero avail_out, it | 359 | call of inflate(). If inflate returns Z_OK and with zero avail_out, it |
360 | must be called again after making room in the output buffer because there | 360 | must be called again after making room in the output buffer because there |
361 | might be more output pending. | 361 | might be more output pending. |
362 | 362 | ||
363 | The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, | 363 | The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, |
364 | Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much | 364 | Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much |
365 | output as possible to the output buffer. Z_BLOCK requests that inflate() stop | 365 | output as possible to the output buffer. Z_BLOCK requests that inflate() stop |
366 | if and when it get to the next deflate block boundary. When decoding the zlib | 366 | if and when it get to the next deflate block boundary. When decoding the zlib |
367 | or gzip format, this will cause inflate() to return immediately after the | 367 | or gzip format, this will cause inflate() to return immediately after the |
368 | header and before the first block. When doing a raw inflate, inflate() will | 368 | header and before the first block. When doing a raw inflate, inflate() will |
369 | go ahead and process the first block, and will return when it gets to the end | 369 | go ahead and process the first block, and will return when it gets to the end |
370 | of that block, or when it runs out of data. | 370 | of that block, or when it runs out of data. |
371 | 371 | ||
372 | The Z_BLOCK option assists in appending to or combining deflate streams. | 372 | The Z_BLOCK option assists in appending to or combining deflate streams. |
373 | Also to assist in this, on return inflate() will set strm->data_type to the | 373 | Also to assist in this, on return inflate() will set strm->data_type to the |
374 | number of unused bits in the last byte taken from strm->next_in, plus 64 | 374 | number of unused bits in the last byte taken from strm->next_in, plus 64 |
375 | if inflate() is currently decoding the last block in the deflate stream, | 375 | if inflate() is currently decoding the last block in the deflate stream, |
376 | plus 128 if inflate() returned immediately after decoding an end-of-block | 376 | plus 128 if inflate() returned immediately after decoding an end-of-block |
377 | code or decoding the complete header up to just before the first byte of the | 377 | code or decoding the complete header up to just before the first byte of the |
378 | deflate stream. The end-of-block will not be indicated until all of the | 378 | deflate stream. The end-of-block will not be indicated until all of the |
379 | uncompressed data from that block has been written to strm->next_out. The | 379 | uncompressed data from that block has been written to strm->next_out. The |
380 | number of unused bits may in general be greater than seven, except when | 380 | number of unused bits may in general be greater than seven, except when |
381 | bit 7 of data_type is set, in which case the number of unused bits will be | 381 | bit 7 of data_type is set, in which case the number of unused bits will be |
382 | less than eight. | 382 | less than eight. |
383 | 383 | ||
384 | inflate() should normally be called until it returns Z_STREAM_END or an | 384 | inflate() should normally be called until it returns Z_STREAM_END or an |
385 | error. However if all decompression is to be performed in a single step | 385 | error. However if all decompression is to be performed in a single step |
386 | (a single call of inflate), the parameter flush should be set to | 386 | (a single call of inflate), the parameter flush should be set to |
387 | Z_FINISH. In this case all pending input is processed and all pending | 387 | Z_FINISH. In this case all pending input is processed and all pending |
388 | output is flushed; avail_out must be large enough to hold all the | 388 | output is flushed; avail_out must be large enough to hold all the |
389 | uncompressed data. (The size of the uncompressed data may have been saved | 389 | uncompressed data. (The size of the uncompressed data may have been saved |
390 | by the compressor for this purpose.) The next operation on this stream must | 390 | by the compressor for this purpose.) The next operation on this stream must |
391 | be inflateEnd to deallocate the decompression state. The use of Z_FINISH | 391 | be inflateEnd to deallocate the decompression state. The use of Z_FINISH |
392 | is never required, but can be used to inform inflate that a faster approach | 392 | is never required, but can be used to inform inflate that a faster approach |
393 | may be used for the single inflate() call. | 393 | may be used for the single inflate() call. |
394 | 394 | ||
395 | In this implementation, inflate() always flushes as much output as | 395 | In this implementation, inflate() always flushes as much output as |
396 | possible to the output buffer, and always uses the faster approach on the | 396 | possible to the output buffer, and always uses the faster approach on the |
397 | first call. So the only effect of the flush parameter in this implementation | 397 | first call. So the only effect of the flush parameter in this implementation |
398 | is on the return value of inflate(), as noted below, or when it returns early | 398 | is on the return value of inflate(), as noted below, or when it returns early |
399 | because Z_BLOCK is used. | 399 | because Z_BLOCK is used. |
400 | 400 | ||
401 | If a preset dictionary is needed after this call (see inflateSetDictionary | 401 | If a preset dictionary is needed after this call (see inflateSetDictionary |
402 | below), inflate sets strm->adler to the adler32 checksum of the dictionary | 402 | below), inflate sets strm->adler to the adler32 checksum of the dictionary |
403 | chosen by the compressor and returns Z_NEED_DICT; otherwise it sets | 403 | chosen by the compressor and returns Z_NEED_DICT; otherwise it sets |
404 | strm->adler to the adler32 checksum of all output produced so far (that is, | 404 | strm->adler to the adler32 checksum of all output produced so far (that is, |
405 | total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described | 405 | total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described |
406 | below. At the end of the stream, inflate() checks that its computed adler32 | 406 | below. At the end of the stream, inflate() checks that its computed adler32 |
407 | checksum is equal to that saved by the compressor and returns Z_STREAM_END | 407 | checksum is equal to that saved by the compressor and returns Z_STREAM_END |
408 | only if the checksum is correct. | 408 | only if the checksum is correct. |
409 | 409 | ||
410 | inflate() will decompress and check either zlib-wrapped or gzip-wrapped | 410 | inflate() will decompress and check either zlib-wrapped or gzip-wrapped |
411 | deflate data. The header type is detected automatically. Any information | 411 | deflate data. The header type is detected automatically. Any information |
412 | contained in the gzip header is not retained, so applications that need that | 412 | contained in the gzip header is not retained, so applications that need that |
413 | information should instead use raw inflate, see inflateInit2() below, or | 413 | information should instead use raw inflate, see inflateInit2() below, or |
414 | inflateBack() and perform their own processing of the gzip header and | 414 | inflateBack() and perform their own processing of the gzip header and |
415 | trailer. | 415 | trailer. |
416 | 416 | ||
417 | inflate() returns Z_OK if some progress has been made (more input processed | 417 | inflate() returns Z_OK if some progress has been made (more input processed |
418 | or more output produced), Z_STREAM_END if the end of the compressed data has | 418 | or more output produced), Z_STREAM_END if the end of the compressed data has |
419 | been reached and all uncompressed output has been produced, Z_NEED_DICT if a | 419 | been reached and all uncompressed output has been produced, Z_NEED_DICT if a |
420 | preset dictionary is needed at this point, Z_DATA_ERROR if the input data was | 420 | preset dictionary is needed at this point, Z_DATA_ERROR if the input data was |
421 | corrupted (input stream not conforming to the zlib format or incorrect check | 421 | corrupted (input stream not conforming to the zlib format or incorrect check |
422 | value), Z_STREAM_ERROR if the stream structure was inconsistent (for example | 422 | value), Z_STREAM_ERROR if the stream structure was inconsistent (for example |
423 | if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, | 423 | if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, |
424 | Z_BUF_ERROR if no progress is possible or if there was not enough room in the | 424 | Z_BUF_ERROR if no progress is possible or if there was not enough room in the |
425 | output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and | 425 | output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and |
426 | inflate() can be called again with more input and more output space to | 426 | inflate() can be called again with more input and more output space to |
427 | continue decompressing. If Z_DATA_ERROR is returned, the application may then | 427 | continue decompressing. If Z_DATA_ERROR is returned, the application may then |
428 | call inflateSync() to look for a good compression block if a partial recovery | 428 | call inflateSync() to look for a good compression block if a partial recovery |
429 | of the data is desired. | 429 | of the data is desired. |
430 | */ | 430 | */ |
431 | 431 | ||
432 | 432 | ||
433 | ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); | 433 | ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); |
434 | /* | 434 | /* |
435 | All dynamically allocated data structures for this stream are freed. | 435 | All dynamically allocated data structures for this stream are freed. |
436 | This function discards any unprocessed input and does not flush any | 436 | This function discards any unprocessed input and does not flush any |
437 | pending output. | 437 | pending output. |
438 | 438 | ||
439 | inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state | 439 | inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state |
440 | was inconsistent. In the error case, msg may be set but then points to a | 440 | was inconsistent. In the error case, msg may be set but then points to a |
441 | static string (which must not be deallocated). | 441 | static string (which must not be deallocated). |
442 | */ | 442 | */ |
443 | 443 | ||
444 | /* Advanced functions */ | 444 | /* Advanced functions */ |
445 | 445 | ||
446 | /* | 446 | /* |
447 | The following functions are needed only in some special applications. | 447 | The following functions are needed only in some special applications. |
448 | */ | 448 | */ |
449 | 449 | ||
450 | /* | 450 | /* |
451 | ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, | 451 | ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, |
452 | int level, | 452 | int level, |
453 | int method, | 453 | int method, |
454 | int windowBits, | 454 | int windowBits, |
455 | int memLevel, | 455 | int memLevel, |
456 | int strategy)); | 456 | int strategy)); |
457 | 457 | ||
458 | This is another version of deflateInit with more compression options. The | 458 | This is another version of deflateInit with more compression options. The |
459 | fields next_in, zalloc, zfree and opaque must be initialized before by | 459 | fields next_in, zalloc, zfree and opaque must be initialized before by |
460 | the caller. | 460 | the caller. |
461 | 461 | ||
462 | The method parameter is the compression method. It must be Z_DEFLATED in | 462 | The method parameter is the compression method. It must be Z_DEFLATED in |
463 | this version of the library. | 463 | this version of the library. |
464 | 464 | ||
465 | The windowBits parameter is the base two logarithm of the window size | 465 | The windowBits parameter is the base two logarithm of the window size |
466 | (the size of the history buffer). It should be in the range 8..15 for this | 466 | (the size of the history buffer). It should be in the range 8..15 for this |
467 | version of the library. Larger values of this parameter result in better | 467 | version of the library. Larger values of this parameter result in better |
468 | compression at the expense of memory usage. The default value is 15 if | 468 | compression at the expense of memory usage. The default value is 15 if |
469 | deflateInit is used instead. | 469 | deflateInit is used instead. |
470 | 470 | ||
471 | windowBits can also be -8..-15 for raw deflate. In this case, -windowBits | 471 | windowBits can also be -8..-15 for raw deflate. In this case, -windowBits |
472 | determines the window size. deflate() will then generate raw deflate data | 472 | determines the window size. deflate() will then generate raw deflate data |
473 | with no zlib header or trailer, and will not compute an adler32 check value. | 473 | with no zlib header or trailer, and will not compute an adler32 check value. |
474 | 474 | ||
475 | windowBits can also be greater than 15 for optional gzip encoding. Add | 475 | windowBits can also be greater than 15 for optional gzip encoding. Add |
476 | 16 to windowBits to write a simple gzip header and trailer around the | 476 | 16 to windowBits to write a simple gzip header and trailer around the |
477 | compressed data instead of a zlib wrapper. The gzip header will have no | 477 | compressed data instead of a zlib wrapper. The gzip header will have no |
478 | file name, no extra data, no comment, no modification time (set to zero), | 478 | file name, no extra data, no comment, no modification time (set to zero), |
479 | no header crc, and the operating system will be set to 255 (unknown). If a | 479 | no header crc, and the operating system will be set to 255 (unknown). If a |
480 | gzip stream is being written, strm->adler is a crc32 instead of an adler32. | 480 | gzip stream is being written, strm->adler is a crc32 instead of an adler32. |
481 | 481 | ||
482 | The memLevel parameter specifies how much memory should be allocated | 482 | The memLevel parameter specifies how much memory should be allocated |
483 | for the internal compression state. memLevel=1 uses minimum memory but | 483 | for the internal compression state. memLevel=1 uses minimum memory but |
484 | is slow and reduces compression ratio; memLevel=9 uses maximum memory | 484 | is slow and reduces compression ratio; memLevel=9 uses maximum memory |
485 | for optimal speed. The default value is 8. See zconf.h for total memory | 485 | for optimal speed. The default value is 8. See zconf.h for total memory |
486 | usage as a function of windowBits and memLevel. | 486 | usage as a function of windowBits and memLevel. |
487 | 487 | ||
488 | The strategy parameter is used to tune the compression algorithm. Use the | 488 | The strategy parameter is used to tune the compression algorithm. Use the |
489 | value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a | 489 | value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a |
490 | filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no | 490 | filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no |
491 | string match), or Z_RLE to limit match distances to one (run-length | 491 | string match), or Z_RLE to limit match distances to one (run-length |
492 | encoding). Filtered data consists mostly of small values with a somewhat | 492 | encoding). Filtered data consists mostly of small values with a somewhat |
493 | random distribution. In this case, the compression algorithm is tuned to | 493 | random distribution. In this case, the compression algorithm is tuned to |
494 | compress them better. The effect of Z_FILTERED is to force more Huffman | 494 | compress them better. The effect of Z_FILTERED is to force more Huffman |
495 | coding and less string matching; it is somewhat intermediate between | 495 | coding and less string matching; it is somewhat intermediate between |
496 | Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as | 496 | Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as |
497 | Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy | 497 | Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy |
498 | parameter only affects the compression ratio but not the correctness of the | 498 | parameter only affects the compression ratio but not the correctness of the |
499 | compressed output even if it is not set appropriately. | 499 | compressed output even if it is not set appropriately. |
500 | 500 | ||
501 | deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough | 501 | deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
502 | memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid | 502 | memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid |
503 | method). msg is set to null if there is no error message. deflateInit2 does | 503 | method). msg is set to null if there is no error message. deflateInit2 does |
504 | not perform any compression: this will be done by deflate(). | 504 | not perform any compression: this will be done by deflate(). |
505 | */ | 505 | */ |
506 | 506 | ||
507 | ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, | 507 | ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, |
508 | const Bytef *dictionary, | 508 | const Bytef *dictionary, |
509 | uInt dictLength)); | 509 | uInt dictLength)); |
510 | /* | 510 | /* |
511 | Initializes the compression dictionary from the given byte sequence | 511 | Initializes the compression dictionary from the given byte sequence |
512 | without producing any compressed output. This function must be called | 512 | without producing any compressed output. This function must be called |
513 | immediately after deflateInit, deflateInit2 or deflateReset, before any | 513 | immediately after deflateInit, deflateInit2 or deflateReset, before any |
514 | call of deflate. The compressor and decompressor must use exactly the same | 514 | call of deflate. The compressor and decompressor must use exactly the same |
515 | dictionary (see inflateSetDictionary). | 515 | dictionary (see inflateSetDictionary). |
516 | 516 | ||
517 | The dictionary should consist of strings (byte sequences) that are likely | 517 | The dictionary should consist of strings (byte sequences) that are likely |
518 | to be encountered later in the data to be compressed, with the most commonly | 518 | to be encountered later in the data to be compressed, with the most commonly |
519 | used strings preferably put towards the end of the dictionary. Using a | 519 | used strings preferably put towards the end of the dictionary. Using a |
520 | dictionary is most useful when the data to be compressed is short and can be | 520 | dictionary is most useful when the data to be compressed is short and can be |
521 | predicted with good accuracy; the data can then be compressed better than | 521 | predicted with good accuracy; the data can then be compressed better than |
522 | with the default empty dictionary. | 522 | with the default empty dictionary. |
523 | 523 | ||
524 | Depending on the size of the compression data structures selected by | 524 | Depending on the size of the compression data structures selected by |
525 | deflateInit or deflateInit2, a part of the dictionary may in effect be | 525 | deflateInit or deflateInit2, a part of the dictionary may in effect be |
526 | discarded, for example if the dictionary is larger than the window size in | 526 | discarded, for example if the dictionary is larger than the window size in |
527 | deflate or deflate2. Thus the strings most likely to be useful should be | 527 | deflate or deflate2. Thus the strings most likely to be useful should be |
528 | put at the end of the dictionary, not at the front. | 528 | put at the end of the dictionary, not at the front. |
529 | 529 | ||
530 | Upon return of this function, strm->adler is set to the adler32 value | 530 | Upon return of this function, strm->adler is set to the adler32 value |
531 | of the dictionary; the decompressor may later use this value to determine | 531 | of the dictionary; the decompressor may later use this value to determine |
532 | which dictionary has been used by the compressor. (The adler32 value | 532 | which dictionary has been used by the compressor. (The adler32 value |
533 | applies to the whole dictionary even if only a subset of the dictionary is | 533 | applies to the whole dictionary even if only a subset of the dictionary is |
534 | actually used by the compressor.) If a raw deflate was requested, then the | 534 | actually used by the compressor.) If a raw deflate was requested, then the |
535 | adler32 value is not computed and strm->adler is not set. | 535 | adler32 value is not computed and strm->adler is not set. |
536 | 536 | ||
537 | deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a | 537 | deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a |
538 | parameter is invalid (such as NULL dictionary) or the stream state is | 538 | parameter is invalid (such as NULL dictionary) or the stream state is |
539 | inconsistent (for example if deflate has already been called for this stream | 539 | inconsistent (for example if deflate has already been called for this stream |
540 | or if the compression method is bsort). deflateSetDictionary does not | 540 | or if the compression method is bsort). deflateSetDictionary does not |
541 | perform any compression: this will be done by deflate(). | 541 | perform any compression: this will be done by deflate(). |
542 | */ | 542 | */ |
543 | 543 | ||
544 | ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, | 544 | ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, |
545 | z_streamp source)); | 545 | z_streamp source)); |
546 | /* | 546 | /* |
547 | Sets the destination stream as a complete copy of the source stream. | 547 | Sets the destination stream as a complete copy of the source stream. |
548 | 548 | ||
549 | This function can be useful when several compression strategies will be | 549 | This function can be useful when several compression strategies will be |
550 | tried, for example when there are several ways of pre-processing the input | 550 | tried, for example when there are several ways of pre-processing the input |
551 | data with a filter. The streams that will be discarded should then be freed | 551 | data with a filter. The streams that will be discarded should then be freed |
552 | by calling deflateEnd. Note that deflateCopy duplicates the internal | 552 | by calling deflateEnd. Note that deflateCopy duplicates the internal |
553 | compression state which can be quite large, so this strategy is slow and | 553 | compression state which can be quite large, so this strategy is slow and |
554 | can consume lots of memory. | 554 | can consume lots of memory. |
555 | 555 | ||
556 | deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not | 556 | deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not |
557 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent | 557 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent |
558 | (such as zalloc being NULL). msg is left unchanged in both source and | 558 | (such as zalloc being NULL). msg is left unchanged in both source and |
559 | destination. | 559 | destination. |
560 | */ | 560 | */ |
561 | 561 | ||
562 | ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); | 562 | ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); |
563 | /* | 563 | /* |
564 | This function is equivalent to deflateEnd followed by deflateInit, | 564 | This function is equivalent to deflateEnd followed by deflateInit, |
565 | but does not free and reallocate all the internal compression state. | 565 | but does not free and reallocate all the internal compression state. |
566 | The stream will keep the same compression level and any other attributes | 566 | The stream will keep the same compression level and any other attributes |
567 | that may have been set by deflateInit2. | 567 | that may have been set by deflateInit2. |
568 | 568 | ||
569 | deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source | 569 | deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
570 | stream state was inconsistent (such as zalloc or state being NULL). | 570 | stream state was inconsistent (such as zalloc or state being NULL). |
571 | */ | 571 | */ |
572 | 572 | ||
573 | ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, | 573 | ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, |
574 | int level, | 574 | int level, |
575 | int strategy)); | 575 | int strategy)); |
576 | /* | 576 | /* |
577 | Dynamically update the compression level and compression strategy. The | 577 | Dynamically update the compression level and compression strategy. The |
578 | interpretation of level and strategy is as in deflateInit2. This can be | 578 | interpretation of level and strategy is as in deflateInit2. This can be |
579 | used to switch between compression and straight copy of the input data, or | 579 | used to switch between compression and straight copy of the input data, or |
580 | to switch to a different kind of input data requiring a different | 580 | to switch to a different kind of input data requiring a different |
581 | strategy. If the compression level is changed, the input available so far | 581 | strategy. If the compression level is changed, the input available so far |
582 | is compressed with the old level (and may be flushed); the new level will | 582 | is compressed with the old level (and may be flushed); the new level will |
583 | take effect only at the next call of deflate(). | 583 | take effect only at the next call of deflate(). |
584 | 584 | ||
585 | Before the call of deflateParams, the stream state must be set as for | 585 | Before the call of deflateParams, the stream state must be set as for |
586 | a call of deflate(), since the currently available input may have to | 586 | a call of deflate(), since the currently available input may have to |
587 | be compressed and flushed. In particular, strm->avail_out must be non-zero. | 587 | be compressed and flushed. In particular, strm->avail_out must be non-zero. |
588 | 588 | ||
589 | deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source | 589 | deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source |
590 | stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR | 590 | stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR |
591 | if strm->avail_out was zero. | 591 | if strm->avail_out was zero. |
592 | */ | 592 | */ |
593 | 593 | ||
594 | ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, | 594 | ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, |
595 | uLong sourceLen)); | 595 | uLong sourceLen)); |
596 | /* | 596 | /* |
597 | deflateBound() returns an upper bound on the compressed size after | 597 | deflateBound() returns an upper bound on the compressed size after |
598 | deflation of sourceLen bytes. It must be called after deflateInit() | 598 | deflation of sourceLen bytes. It must be called after deflateInit() |
599 | or deflateInit2(). This would be used to allocate an output buffer | 599 | or deflateInit2(). This would be used to allocate an output buffer |
600 | for deflation in a single pass, and so would be called before deflate(). | 600 | for deflation in a single pass, and so would be called before deflate(). |
601 | */ | 601 | */ |
602 | 602 | ||
603 | ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, | 603 | ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, |
604 | int bits, | 604 | int bits, |
605 | int value)); | 605 | int value)); |
606 | /* | 606 | /* |
607 | deflatePrime() inserts bits in the deflate output stream. The intent | 607 | deflatePrime() inserts bits in the deflate output stream. The intent |
608 | is that this function is used to start off the deflate output with the | 608 | is that this function is used to start off the deflate output with the |
609 | bits leftover from a previous deflate stream when appending to it. As such, | 609 | bits leftover from a previous deflate stream when appending to it. As such, |
610 | this function can only be used for raw deflate, and must be used before the | 610 | this function can only be used for raw deflate, and must be used before the |
611 | first deflate() call after a deflateInit2() or deflateReset(). bits must be | 611 | first deflate() call after a deflateInit2() or deflateReset(). bits must be |
612 | less than or equal to 16, and that many of the least significant bits of | 612 | less than or equal to 16, and that many of the least significant bits of |
613 | value will be inserted in the output. | 613 | value will be inserted in the output. |
614 | 614 | ||
615 | deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source | 615 | deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source |
616 | stream state was inconsistent. | 616 | stream state was inconsistent. |
617 | */ | 617 | */ |
618 | 618 | ||
619 | /* | 619 | /* |
620 | ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, | 620 | ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, |
621 | int windowBits)); | 621 | int windowBits)); |
622 | 622 | ||
623 | This is another version of inflateInit with an extra parameter. The | 623 | This is another version of inflateInit with an extra parameter. The |
624 | fields next_in, avail_in, zalloc, zfree and opaque must be initialized | 624 | fields next_in, avail_in, zalloc, zfree and opaque must be initialized |
625 | before by the caller. | 625 | before by the caller. |
626 | 626 | ||
627 | The windowBits parameter is the base two logarithm of the maximum window | 627 | The windowBits parameter is the base two logarithm of the maximum window |
628 | size (the size of the history buffer). It should be in the range 8..15 for | 628 | size (the size of the history buffer). It should be in the range 8..15 for |
629 | this version of the library. The default value is 15 if inflateInit is used | 629 | this version of the library. The default value is 15 if inflateInit is used |
630 | instead. windowBits must be greater than or equal to the windowBits value | 630 | instead. windowBits must be greater than or equal to the windowBits value |
631 | provided to deflateInit2() while compressing, or it must be equal to 15 if | 631 | provided to deflateInit2() while compressing, or it must be equal to 15 if |
632 | deflateInit2() was not used. If a compressed stream with a larger window | 632 | deflateInit2() was not used. If a compressed stream with a larger window |
633 | size is given as input, inflate() will return with the error code | 633 | size is given as input, inflate() will return with the error code |
634 | Z_DATA_ERROR instead of trying to allocate a larger window. | 634 | Z_DATA_ERROR instead of trying to allocate a larger window. |
635 | 635 | ||
636 | windowBits can also be -8..-15 for raw inflate. In this case, -windowBits | 636 | windowBits can also be -8..-15 for raw inflate. In this case, -windowBits |
637 | determines the window size. inflate() will then process raw deflate data, | 637 | determines the window size. inflate() will then process raw deflate data, |
638 | not looking for a zlib or gzip header, not generating a check value, and not | 638 | not looking for a zlib or gzip header, not generating a check value, and not |
639 | looking for any check values for comparison at the end of the stream. This | 639 | looking for any check values for comparison at the end of the stream. This |
640 | is for use with other formats that use the deflate compressed data format | 640 | is for use with other formats that use the deflate compressed data format |
641 | such as zip. Those formats provide their own check values. If a custom | 641 | such as zip. Those formats provide their own check values. If a custom |
642 | format is developed using the raw deflate format for compressed data, it is | 642 | format is developed using the raw deflate format for compressed data, it is |
643 | recommended that a check value such as an adler32 or a crc32 be applied to | 643 | recommended that a check value such as an adler32 or a crc32 be applied to |
644 | the uncompressed data as is done in the zlib, gzip, and zip formats. For | 644 | the uncompressed data as is done in the zlib, gzip, and zip formats. For |
645 | most applications, the zlib format should be used as is. Note that comments | 645 | most applications, the zlib format should be used as is. Note that comments |
646 | above on the use in deflateInit2() applies to the magnitude of windowBits. | 646 | above on the use in deflateInit2() applies to the magnitude of windowBits. |
647 | 647 | ||
648 | windowBits can also be greater than 15 for optional gzip decoding. Add | 648 | windowBits can also be greater than 15 for optional gzip decoding. Add |
649 | 32 to windowBits to enable zlib and gzip decoding with automatic header | 649 | 32 to windowBits to enable zlib and gzip decoding with automatic header |
650 | detection, or add 16 to decode only the gzip format (the zlib format will | 650 | detection, or add 16 to decode only the gzip format (the zlib format will |
651 | return a Z_DATA_ERROR. If a gzip stream is being decoded, strm->adler is | 651 | return a Z_DATA_ERROR. If a gzip stream is being decoded, strm->adler is |
652 | a crc32 instead of an adler32. | 652 | a crc32 instead of an adler32. |
653 | 653 | ||
654 | inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough | 654 | inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
655 | memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative | 655 | memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative |
656 | memLevel). msg is set to null if there is no error message. inflateInit2 | 656 | memLevel). msg is set to null if there is no error message. inflateInit2 |
657 | does not perform any decompression apart from reading the zlib header if | 657 | does not perform any decompression apart from reading the zlib header if |
658 | present: this will be done by inflate(). (So next_in and avail_in may be | 658 | present: this will be done by inflate(). (So next_in and avail_in may be |
659 | modified, but next_out and avail_out are unchanged.) | 659 | modified, but next_out and avail_out are unchanged.) |
660 | */ | 660 | */ |
661 | 661 | ||
662 | ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, | 662 | ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, |
663 | const Bytef *dictionary, | 663 | const Bytef *dictionary, |
664 | uInt dictLength)); | 664 | uInt dictLength)); |
665 | /* | 665 | /* |
666 | Initializes the decompression dictionary from the given uncompressed byte | 666 | Initializes the decompression dictionary from the given uncompressed byte |
667 | sequence. This function must be called immediately after a call of inflate | 667 | sequence. This function must be called immediately after a call of inflate |
668 | if this call returned Z_NEED_DICT. The dictionary chosen by the compressor | 668 | if this call returned Z_NEED_DICT. The dictionary chosen by the compressor |
669 | can be determined from the adler32 value returned by this call of | 669 | can be determined from the adler32 value returned by this call of |
670 | inflate. The compressor and decompressor must use exactly the same | 670 | inflate. The compressor and decompressor must use exactly the same |
671 | dictionary (see deflateSetDictionary). | 671 | dictionary (see deflateSetDictionary). |
672 | 672 | ||
673 | inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a | 673 | inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a |
674 | parameter is invalid (such as NULL dictionary) or the stream state is | 674 | parameter is invalid (such as NULL dictionary) or the stream state is |
675 | inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the | 675 | inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the |
676 | expected one (incorrect adler32 value). inflateSetDictionary does not | 676 | expected one (incorrect adler32 value). inflateSetDictionary does not |
677 | perform any decompression: this will be done by subsequent calls of | 677 | perform any decompression: this will be done by subsequent calls of |
678 | inflate(). | 678 | inflate(). |
679 | */ | 679 | */ |
680 | 680 | ||
681 | ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); | 681 | ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); |
682 | /* | 682 | /* |
683 | Skips invalid compressed data until a full flush point (see above the | 683 | Skips invalid compressed data until a full flush point (see above the |
684 | description of deflate with Z_FULL_FLUSH) can be found, or until all | 684 | description of deflate with Z_FULL_FLUSH) can be found, or until all |
685 | available input is skipped. No output is provided. | 685 | available input is skipped. No output is provided. |
686 | 686 | ||
687 | inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR | 687 | inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR |
688 | if no more input was provided, Z_DATA_ERROR if no flush point has been found, | 688 | if no more input was provided, Z_DATA_ERROR if no flush point has been found, |
689 | or Z_STREAM_ERROR if the stream structure was inconsistent. In the success | 689 | or Z_STREAM_ERROR if the stream structure was inconsistent. In the success |
690 | case, the application may save the current current value of total_in which | 690 | case, the application may save the current current value of total_in which |
691 | indicates where valid compressed data was found. In the error case, the | 691 | indicates where valid compressed data was found. In the error case, the |
692 | application may repeatedly call inflateSync, providing more input each time, | 692 | application may repeatedly call inflateSync, providing more input each time, |
693 | until success or end of the input data. | 693 | until success or end of the input data. |
694 | */ | 694 | */ |
695 | 695 | ||
696 | ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, | 696 | ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, |
697 | z_streamp source)); | 697 | z_streamp source)); |
698 | /* | 698 | /* |
699 | Sets the destination stream as a complete copy of the source stream. | 699 | Sets the destination stream as a complete copy of the source stream. |
700 | 700 | ||
701 | This function can be useful when randomly accessing a large stream. The | 701 | This function can be useful when randomly accessing a large stream. The |
702 | first pass through the stream can periodically record the inflate state, | 702 | first pass through the stream can periodically record the inflate state, |
703 | allowing restarting inflate at those points when randomly accessing the | 703 | allowing restarting inflate at those points when randomly accessing the |
704 | stream. | 704 | stream. |
705 | 705 | ||
706 | inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not | 706 | inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not |
707 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent | 707 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent |
708 | (such as zalloc being NULL). msg is left unchanged in both source and | 708 | (such as zalloc being NULL). msg is left unchanged in both source and |
709 | destination. | 709 | destination. |
710 | */ | 710 | */ |
711 | 711 | ||
712 | ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); | 712 | ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); |
713 | /* | 713 | /* |
714 | This function is equivalent to inflateEnd followed by inflateInit, | 714 | This function is equivalent to inflateEnd followed by inflateInit, |
715 | but does not free and reallocate all the internal decompression state. | 715 | but does not free and reallocate all the internal decompression state. |
716 | The stream will keep attributes that may have been set by inflateInit2. | 716 | The stream will keep attributes that may have been set by inflateInit2. |
717 | 717 | ||
718 | inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source | 718 | inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
719 | stream state was inconsistent (such as zalloc or state being NULL). | 719 | stream state was inconsistent (such as zalloc or state being NULL). |
720 | */ | 720 | */ |
721 | 721 | ||
722 | /* | 722 | /* |
723 | ZEXTERN int ZEXPORT inflateBackInit OF((z_stream FAR *strm, int windowBits, | 723 | ZEXTERN int ZEXPORT inflateBackInit OF((z_stream FAR *strm, int windowBits, |
724 | unsigned char FAR *window)); | 724 | unsigned char FAR *window)); |
725 | 725 | ||
726 | Initialize the internal stream state for decompression using inflateBack() | 726 | Initialize the internal stream state for decompression using inflateBack() |
727 | calls. The fields zalloc, zfree and opaque in strm must be initialized | 727 | calls. The fields zalloc, zfree and opaque in strm must be initialized |
728 | before the call. If zalloc and zfree are Z_NULL, then the default library- | 728 | before the call. If zalloc and zfree are Z_NULL, then the default library- |
729 | derived memory allocation routines are used. windowBits is the base two | 729 | derived memory allocation routines are used. windowBits is the base two |
730 | logarithm of the window size, in the range 8..15. window is a caller | 730 | logarithm of the window size, in the range 8..15. window is a caller |
731 | supplied buffer of that size. Except for special applications where it is | 731 | supplied buffer of that size. Except for special applications where it is |
732 | assured that deflate was used with small window sizes, windowBits must be 15 | 732 | assured that deflate was used with small window sizes, windowBits must be 15 |
733 | and a 32K byte window must be supplied to be able to decompress general | 733 | and a 32K byte window must be supplied to be able to decompress general |
734 | deflate streams. | 734 | deflate streams. |
735 | 735 | ||
736 | See inflateBack() for the usage of these routines. | 736 | See inflateBack() for the usage of these routines. |
737 | 737 | ||
738 | inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of | 738 | inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of |
739 | the paramaters are invalid, Z_MEM_ERROR if the internal state could not | 739 | the paramaters are invalid, Z_MEM_ERROR if the internal state could not |
740 | be allocated, or Z_VERSION_ERROR if the version of the library does not | 740 | be allocated, or Z_VERSION_ERROR if the version of the library does not |
741 | match the version of the header file. | 741 | match the version of the header file. |
742 | */ | 742 | */ |
743 | 743 | ||
744 | typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); | 744 | typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); |
745 | typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); | 745 | typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); |
746 | 746 | ||
747 | ZEXTERN int ZEXPORT inflateBack OF((z_stream FAR *strm, | 747 | ZEXTERN int ZEXPORT inflateBack OF((z_stream FAR *strm, |
748 | in_func in, void FAR *in_desc, | 748 | in_func in, void FAR *in_desc, |
749 | out_func out, void FAR *out_desc)); | 749 | out_func out, void FAR *out_desc)); |
750 | /* | 750 | /* |
751 | inflateBack() does a raw inflate with a single call using a call-back | 751 | inflateBack() does a raw inflate with a single call using a call-back |
752 | interface for input and output. This is more efficient than inflate() for | 752 | interface for input and output. This is more efficient than inflate() for |
753 | file i/o applications in that it avoids copying between the output and the | 753 | file i/o applications in that it avoids copying between the output and the |
754 | sliding window by simply making the window itself the output buffer. This | 754 | sliding window by simply making the window itself the output buffer. This |
755 | function trusts the application to not change the output buffer passed by | 755 | function trusts the application to not change the output buffer passed by |
756 | the output function, at least until inflateBack() returns. | 756 | the output function, at least until inflateBack() returns. |
757 | 757 | ||
758 | inflateBackInit() must be called first to allocate the internal state | 758 | inflateBackInit() must be called first to allocate the internal state |
759 | and to initialize the state with the user-provided window buffer. | 759 | and to initialize the state with the user-provided window buffer. |
760 | inflateBack() may then be used multiple times to inflate a complete, raw | 760 | inflateBack() may then be used multiple times to inflate a complete, raw |
761 | deflate stream with each call. inflateBackEnd() is then called to free | 761 | deflate stream with each call. inflateBackEnd() is then called to free |
762 | the allocated state. | 762 | the allocated state. |
763 | 763 | ||
764 | A raw deflate stream is one with no zlib or gzip header or trailer. | 764 | A raw deflate stream is one with no zlib or gzip header or trailer. |
765 | This routine would normally be used in a utility that reads zip or gzip | 765 | This routine would normally be used in a utility that reads zip or gzip |
766 | files and writes out uncompressed files. The utility would decode the | 766 | files and writes out uncompressed files. The utility would decode the |
767 | header and process the trailer on its own, hence this routine expects | 767 | header and process the trailer on its own, hence this routine expects |
768 | only the raw deflate stream to decompress. This is different from the | 768 | only the raw deflate stream to decompress. This is different from the |
769 | normal behavior of inflate(), which expects either a zlib or gzip header and | 769 | normal behavior of inflate(), which expects either a zlib or gzip header and |
770 | trailer around the deflate stream. | 770 | trailer around the deflate stream. |
771 | 771 | ||
772 | inflateBack() uses two subroutines supplied by the caller that are then | 772 | inflateBack() uses two subroutines supplied by the caller that are then |
773 | called by inflateBack() for input and output. inflateBack() calls those | 773 | called by inflateBack() for input and output. inflateBack() calls those |
774 | routines until it reads a complete deflate stream and writes out all of the | 774 | routines until it reads a complete deflate stream and writes out all of the |
775 | uncompressed data, or until it encounters an error. The function's | 775 | uncompressed data, or until it encounters an error. The function's |
776 | parameters and return types are defined above in the in_func and out_func | 776 | parameters and return types are defined above in the in_func and out_func |
777 | typedefs. inflateBack() will call in(in_desc, &buf) which should return the | 777 | typedefs. inflateBack() will call in(in_desc, &buf) which should return the |
778 | number of bytes of provided input, and a pointer to that input in buf. If | 778 | number of bytes of provided input, and a pointer to that input in buf. If |
779 | there is no input available, in() must return zero--buf is ignored in that | 779 | there is no input available, in() must return zero--buf is ignored in that |
780 | case--and inflateBack() will return a buffer error. inflateBack() will call | 780 | case--and inflateBack() will return a buffer error. inflateBack() will call |
781 | out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() | 781 | out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() |
782 | should return zero on success, or non-zero on failure. If out() returns | 782 | should return zero on success, or non-zero on failure. If out() returns |
783 | non-zero, inflateBack() will return with an error. Neither in() nor out() | 783 | non-zero, inflateBack() will return with an error. Neither in() nor out() |
784 | are permitted to change the contents of the window provided to | 784 | are permitted to change the contents of the window provided to |
785 | inflateBackInit(), which is also the buffer that out() uses to write from. | 785 | inflateBackInit(), which is also the buffer that out() uses to write from. |
786 | The length written by out() will be at most the window size. Any non-zero | 786 | The length written by out() will be at most the window size. Any non-zero |
787 | amount of input may be provided by in(). | 787 | amount of input may be provided by in(). |
788 | 788 | ||
789 | For convenience, inflateBack() can be provided input on the first call by | 789 | For convenience, inflateBack() can be provided input on the first call by |
790 | setting strm->next_in and strm->avail_in. If that input is exhausted, then | 790 | setting strm->next_in and strm->avail_in. If that input is exhausted, then |
791 | in() will be called. Therefore strm->next_in must be initialized before | 791 | in() will be called. Therefore strm->next_in must be initialized before |
792 | calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called | 792 | calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called |
793 | immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in | 793 | immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in |
794 | must also be initialized, and then if strm->avail_in is not zero, input will | 794 | must also be initialized, and then if strm->avail_in is not zero, input will |
795 | initially be taken from strm->next_in[0 .. strm->avail_in - 1]. | 795 | initially be taken from strm->next_in[0 .. strm->avail_in - 1]. |
796 | 796 | ||
797 | The in_desc and out_desc parameters of inflateBack() is passed as the | 797 | The in_desc and out_desc parameters of inflateBack() is passed as the |
798 | first parameter of in() and out() respectively when they are called. These | 798 | first parameter of in() and out() respectively when they are called. These |
799 | descriptors can be optionally used to pass any information that the caller- | 799 | descriptors can be optionally used to pass any information that the caller- |
800 | supplied in() and out() functions need to do their job. | 800 | supplied in() and out() functions need to do their job. |
801 | 801 | ||
802 | On return, inflateBack() will set strm->next_in and strm->avail_in to | 802 | On return, inflateBack() will set strm->next_in and strm->avail_in to |
803 | pass back any unused input that was provided by the last in() call. The | 803 | pass back any unused input that was provided by the last in() call. The |
804 | return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR | 804 | return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR |
805 | if in() or out() returned an error, Z_DATA_ERROR if there was a format | 805 | if in() or out() returned an error, Z_DATA_ERROR if there was a format |
806 | error in the deflate stream (in which case strm->msg is set to indicate the | 806 | error in the deflate stream (in which case strm->msg is set to indicate the |
807 | nature of the error), or Z_STREAM_ERROR if the stream was not properly | 807 | nature of the error), or Z_STREAM_ERROR if the stream was not properly |
808 | initialized. In the case of Z_BUF_ERROR, an input or output error can be | 808 | initialized. In the case of Z_BUF_ERROR, an input or output error can be |
809 | distinguished using strm->next_in which will be Z_NULL only if in() returned | 809 | distinguished using strm->next_in which will be Z_NULL only if in() returned |
810 | an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to | 810 | an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to |
811 | out() returning non-zero. (in() will always be called before out(), so | 811 | out() returning non-zero. (in() will always be called before out(), so |
812 | strm->next_in is assured to be defined if out() returns non-zero.) Note | 812 | strm->next_in is assured to be defined if out() returns non-zero.) Note |
813 | that inflateBack() cannot return Z_OK. | 813 | that inflateBack() cannot return Z_OK. |
814 | */ | 814 | */ |
815 | 815 | ||
816 | ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm)); | 816 | ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm)); |
817 | /* | 817 | /* |
818 | All memory allocated by inflateBackInit() is freed. | 818 | All memory allocated by inflateBackInit() is freed. |
819 | 819 | ||
820 | inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream | 820 | inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream |
821 | state was inconsistent. | 821 | state was inconsistent. |
822 | */ | 822 | */ |
823 | 823 | ||
824 | ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); | 824 | ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); |
825 | /* Return flags indicating compile-time options. | 825 | /* Return flags indicating compile-time options. |
826 | 826 | ||
827 | Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: | 827 | Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: |
828 | 1.0: size of uInt | 828 | 1.0: size of uInt |
829 | 3.2: size of uLong | 829 | 3.2: size of uLong |
830 | 5.4: size of voidpf (pointer) | 830 | 5.4: size of voidpf (pointer) |
831 | 7.6: size of z_off_t | 831 | 7.6: size of z_off_t |
832 | 832 | ||
833 | Compiler, assembler, and debug options: | 833 | Compiler, assembler, and debug options: |
834 | 8: DEBUG | 834 | 8: DEBUG |
835 | 9: ASMV or ASMINF -- use ASM code | 835 | 9: ASMV or ASMINF -- use ASM code |
836 | 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention | 836 | 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention |
837 | 11: 0 (reserved) | 837 | 11: 0 (reserved) |
838 | 838 | ||
839 | One-time table building (smaller code, but not thread-safe if true): | 839 | One-time table building (smaller code, but not thread-safe if true): |
840 | 12: BUILDFIXED -- build static block decoding tables when needed | 840 | 12: BUILDFIXED -- build static block decoding tables when needed |
841 | 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed | 841 | 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed |
842 | 14,15: 0 (reserved) | 842 | 14,15: 0 (reserved) |
843 | 843 | ||
844 | Library content (indicates missing functionality): | 844 | Library content (indicates missing functionality): |
845 | 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking | 845 | 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking |
846 | deflate code when not needed) | 846 | deflate code when not needed) |
847 | 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect | 847 | 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect |
848 | and decode gzip streams (to avoid linking crc code) | 848 | and decode gzip streams (to avoid linking crc code) |
849 | 18-19: 0 (reserved) | 849 | 18-19: 0 (reserved) |
850 | 850 | ||
851 | Operation variations (changes in library functionality): | 851 | Operation variations (changes in library functionality): |
852 | 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate | 852 | 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate |
853 | 21: FASTEST -- deflate algorithm with only one, lowest compression level | 853 | 21: FASTEST -- deflate algorithm with only one, lowest compression level |
854 | 22,23: 0 (reserved) | 854 | 22,23: 0 (reserved) |
855 | 855 | ||
856 | The sprintf variant used by gzprintf (zero is best): | 856 | The sprintf variant used by gzprintf (zero is best): |
857 | 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format | 857 | 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format |
858 | 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! | 858 | 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! |
859 | 26: 0 = returns value, 1 = void -- 1 means inferred string length returned | 859 | 26: 0 = returns value, 1 = void -- 1 means inferred string length returned |
860 | 860 | ||
861 | Remainder: | 861 | Remainder: |
862 | 27-31: 0 (reserved) | 862 | 27-31: 0 (reserved) |
863 | */ | 863 | */ |
864 | 864 | ||
865 | 865 | ||
866 | /* utility functions */ | 866 | /* utility functions */ |
867 | 867 | ||
868 | /* | 868 | /* |
869 | The following utility functions are implemented on top of the | 869 | The following utility functions are implemented on top of the |
870 | basic stream-oriented functions. To simplify the interface, some | 870 | basic stream-oriented functions. To simplify the interface, some |
871 | default options are assumed (compression level and memory usage, | 871 | default options are assumed (compression level and memory usage, |
872 | standard memory allocation functions). The source code of these | 872 | standard memory allocation functions). The source code of these |
873 | utility functions can easily be modified if you need special options. | 873 | utility functions can easily be modified if you need special options. |
874 | */ | 874 | */ |
875 | 875 | ||
876 | ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, | 876 | ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, |
877 | const Bytef *source, uLong sourceLen)); | 877 | const Bytef *source, uLong sourceLen)); |
878 | /* | 878 | /* |
879 | Compresses the source buffer into the destination buffer. sourceLen is | 879 | Compresses the source buffer into the destination buffer. sourceLen is |
880 | the byte length of the source buffer. Upon entry, destLen is the total | 880 | the byte length of the source buffer. Upon entry, destLen is the total |
881 | size of the destination buffer, which must be at least the value returned | 881 | size of the destination buffer, which must be at least the value returned |
882 | by compressBound(sourceLen). Upon exit, destLen is the actual size of the | 882 | by compressBound(sourceLen). Upon exit, destLen is the actual size of the |
883 | compressed buffer. | 883 | compressed buffer. |
884 | This function can be used to compress a whole file at once if the | 884 | This function can be used to compress a whole file at once if the |
885 | input file is mmap'ed. | 885 | input file is mmap'ed. |
886 | compress returns Z_OK if success, Z_MEM_ERROR if there was not | 886 | compress returns Z_OK if success, Z_MEM_ERROR if there was not |
887 | enough memory, Z_BUF_ERROR if there was not enough room in the output | 887 | enough memory, Z_BUF_ERROR if there was not enough room in the output |
888 | buffer. | 888 | buffer. |
889 | */ | 889 | */ |
890 | 890 | ||
891 | ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, | 891 | ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, |
892 | const Bytef *source, uLong sourceLen, | 892 | const Bytef *source, uLong sourceLen, |
893 | int level)); | 893 | int level)); |
894 | /* | 894 | /* |
895 | Compresses the source buffer into the destination buffer. The level | 895 | Compresses the source buffer into the destination buffer. The level |
896 | parameter has the same meaning as in deflateInit. sourceLen is the byte | 896 | parameter has the same meaning as in deflateInit. sourceLen is the byte |
897 | length of the source buffer. Upon entry, destLen is the total size of the | 897 | length of the source buffer. Upon entry, destLen is the total size of the |
898 | destination buffer, which must be at least the value returned by | 898 | destination buffer, which must be at least the value returned by |
899 | compressBound(sourceLen). Upon exit, destLen is the actual size of the | 899 | compressBound(sourceLen). Upon exit, destLen is the actual size of the |
900 | compressed buffer. | 900 | compressed buffer. |
901 | 901 | ||
902 | compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough | 902 | compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
903 | memory, Z_BUF_ERROR if there was not enough room in the output buffer, | 903 | memory, Z_BUF_ERROR if there was not enough room in the output buffer, |
904 | Z_STREAM_ERROR if the level parameter is invalid. | 904 | Z_STREAM_ERROR if the level parameter is invalid. |
905 | */ | 905 | */ |
906 | 906 | ||
907 | ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); | 907 | ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); |
908 | /* | 908 | /* |
909 | compressBound() returns an upper bound on the compressed size after | 909 | compressBound() returns an upper bound on the compressed size after |
910 | compress() or compress2() on sourceLen bytes. It would be used before | 910 | compress() or compress2() on sourceLen bytes. It would be used before |
911 | a compress() or compress2() call to allocate the destination buffer. | 911 | a compress() or compress2() call to allocate the destination buffer. |
912 | */ | 912 | */ |
913 | 913 | ||
914 | ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, | 914 | ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, |
915 | const Bytef *source, uLong sourceLen)); | 915 | const Bytef *source, uLong sourceLen)); |
916 | /* | 916 | /* |
917 | Decompresses the source buffer into the destination buffer. sourceLen is | 917 | Decompresses the source buffer into the destination buffer. sourceLen is |
918 | the byte length of the source buffer. Upon entry, destLen is the total | 918 | the byte length of the source buffer. Upon entry, destLen is the total |
919 | size of the destination buffer, which must be large enough to hold the | 919 | size of the destination buffer, which must be large enough to hold the |
920 | entire uncompressed data. (The size of the uncompressed data must have | 920 | entire uncompressed data. (The size of the uncompressed data must have |
921 | been saved previously by the compressor and transmitted to the decompressor | 921 | been saved previously by the compressor and transmitted to the decompressor |
922 | by some mechanism outside the scope of this compression library.) | 922 | by some mechanism outside the scope of this compression library.) |
923 | Upon exit, destLen is the actual size of the compressed buffer. | 923 | Upon exit, destLen is the actual size of the compressed buffer. |
924 | This function can be used to decompress a whole file at once if the | 924 | This function can be used to decompress a whole file at once if the |
925 | input file is mmap'ed. | 925 | input file is mmap'ed. |
926 | 926 | ||
927 | uncompress returns Z_OK if success, Z_MEM_ERROR if there was not | 927 | uncompress returns Z_OK if success, Z_MEM_ERROR if there was not |
928 | enough memory, Z_BUF_ERROR if there was not enough room in the output | 928 | enough memory, Z_BUF_ERROR if there was not enough room in the output |
929 | buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. | 929 | buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. |
930 | */ | 930 | */ |
931 | 931 | ||
932 | 932 | ||
933 | typedef voidp gzFile; | 933 | typedef voidp gzFile; |
934 | 934 | ||
935 | ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); | 935 | ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); |
936 | /* | 936 | /* |
937 | Opens a gzip (.gz) file for reading or writing. The mode parameter | 937 | Opens a gzip (.gz) file for reading or writing. The mode parameter |
938 | is as in fopen ("rb" or "wb") but can also include a compression level | 938 | is as in fopen ("rb" or "wb") but can also include a compression level |
939 | ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for | 939 | ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for |
940 | Huffman only compression as in "wb1h", or 'R' for run-length encoding | 940 | Huffman only compression as in "wb1h", or 'R' for run-length encoding |
941 | as in "wb1R". (See the description of deflateInit2 for more information | 941 | as in "wb1R". (See the description of deflateInit2 for more information |
942 | about the strategy parameter.) | 942 | about the strategy parameter.) |
943 | 943 | ||
944 | gzopen can be used to read a file which is not in gzip format; in this | 944 | gzopen can be used to read a file which is not in gzip format; in this |
945 | case gzread will directly read from the file without decompression. | 945 | case gzread will directly read from the file without decompression. |
946 | 946 | ||
947 | gzopen returns NULL if the file could not be opened or if there was | 947 | gzopen returns NULL if the file could not be opened or if there was |
948 | insufficient memory to allocate the (de)compression state; errno | 948 | insufficient memory to allocate the (de)compression state; errno |
949 | can be checked to distinguish the two cases (if errno is zero, the | 949 | can be checked to distinguish the two cases (if errno is zero, the |
950 | zlib error is Z_MEM_ERROR). */ | 950 | zlib error is Z_MEM_ERROR). */ |
951 | 951 | ||
952 | ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); | 952 | ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); |
953 | /* | 953 | /* |
954 | gzdopen() associates a gzFile with the file descriptor fd. File | 954 | gzdopen() associates a gzFile with the file descriptor fd. File |
955 | descriptors are obtained from calls like open, dup, creat, pipe or | 955 | descriptors are obtained from calls like open, dup, creat, pipe or |
956 | fileno (in the file has been previously opened with fopen). | 956 | fileno (in the file has been previously opened with fopen). |
957 | The mode parameter is as in gzopen. | 957 | The mode parameter is as in gzopen. |
958 | The next call of gzclose on the returned gzFile will also close the | 958 | The next call of gzclose on the returned gzFile will also close the |
959 | file descriptor fd, just like fclose(fdopen(fd), mode) closes the file | 959 | file descriptor fd, just like fclose(fdopen(fd), mode) closes the file |
960 | descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). | 960 | descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). |
961 | gzdopen returns NULL if there was insufficient memory to allocate | 961 | gzdopen returns NULL if there was insufficient memory to allocate |
962 | the (de)compression state. | 962 | the (de)compression state. |
963 | */ | 963 | */ |
964 | 964 | ||
965 | ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); | 965 | ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); |
966 | /* | 966 | /* |
967 | Dynamically update the compression level or strategy. See the description | 967 | Dynamically update the compression level or strategy. See the description |
968 | of deflateInit2 for the meaning of these parameters. | 968 | of deflateInit2 for the meaning of these parameters. |
969 | gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not | 969 | gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not |
970 | opened for writing. | 970 | opened for writing. |
971 | */ | 971 | */ |
972 | 972 | ||
973 | ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); | 973 | ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); |
974 | /* | 974 | /* |
975 | Reads the given number of uncompressed bytes from the compressed file. | 975 | Reads the given number of uncompressed bytes from the compressed file. |
976 | If the input file was not in gzip format, gzread copies the given number | 976 | If the input file was not in gzip format, gzread copies the given number |
977 | of bytes into the buffer. | 977 | of bytes into the buffer. |
978 | gzread returns the number of uncompressed bytes actually read (0 for | 978 | gzread returns the number of uncompressed bytes actually read (0 for |
979 | end of file, -1 for error). */ | 979 | end of file, -1 for error). */ |
980 | 980 | ||
981 | ZEXTERN int ZEXPORT gzwrite OF((gzFile file, | 981 | ZEXTERN int ZEXPORT gzwrite OF((gzFile file, |
982 | voidpc buf, unsigned len)); | 982 | voidpc buf, unsigned len)); |
983 | /* | 983 | /* |
984 | Writes the given number of uncompressed bytes into the compressed file. | 984 | Writes the given number of uncompressed bytes into the compressed file. |
985 | gzwrite returns the number of uncompressed bytes actually written | 985 | gzwrite returns the number of uncompressed bytes actually written |
986 | (0 in case of error). | 986 | (0 in case of error). |
987 | */ | 987 | */ |
988 | 988 | ||
989 | ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); | 989 | ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); |
990 | /* | 990 | /* |
991 | Converts, formats, and writes the args to the compressed file under | 991 | Converts, formats, and writes the args to the compressed file under |
992 | control of the format string, as in fprintf. gzprintf returns the number of | 992 | control of the format string, as in fprintf. gzprintf returns the number of |
993 | uncompressed bytes actually written (0 in case of error). The number of | 993 | uncompressed bytes actually written (0 in case of error). The number of |
994 | uncompressed bytes written is limited to 4095. The caller should assure that | 994 | uncompressed bytes written is limited to 4095. The caller should assure that |
995 | this limit is not exceeded. If it is exceeded, then gzprintf() will return | 995 | this limit is not exceeded. If it is exceeded, then gzprintf() will return |
996 | return an error (0) with nothing written. In this case, there may also be a | 996 | return an error (0) with nothing written. In this case, there may also be a |
997 | buffer overflow with unpredictable consequences, which is possible only if | 997 | buffer overflow with unpredictable consequences, which is possible only if |
998 | zlib was compiled with the insecure functions sprintf() or vsprintf() | 998 | zlib was compiled with the insecure functions sprintf() or vsprintf() |
999 | because the secure snprintf() or vsnprintf() functions were not available. | 999 | because the secure snprintf() or vsnprintf() functions were not available. |
1000 | */ | 1000 | */ |
1001 | 1001 | ||
1002 | ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); | 1002 | ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); |
1003 | /* | 1003 | /* |
1004 | Writes the given null-terminated string to the compressed file, excluding | 1004 | Writes the given null-terminated string to the compressed file, excluding |
1005 | the terminating null character. | 1005 | the terminating null character. |
1006 | gzputs returns the number of characters written, or -1 in case of error. | 1006 | gzputs returns the number of characters written, or -1 in case of error. |
1007 | */ | 1007 | */ |
1008 | 1008 | ||
1009 | ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); | 1009 | ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); |
1010 | /* | 1010 | /* |
1011 | Reads bytes from the compressed file until len-1 characters are read, or | 1011 | Reads bytes from the compressed file until len-1 characters are read, or |
1012 | a newline character is read and transferred to buf, or an end-of-file | 1012 | a newline character is read and transferred to buf, or an end-of-file |
1013 | condition is encountered. The string is then terminated with a null | 1013 | condition is encountered. The string is then terminated with a null |
1014 | character. | 1014 | character. |
1015 | gzgets returns buf, or Z_NULL in case of error. | 1015 | gzgets returns buf, or Z_NULL in case of error. |
1016 | */ | 1016 | */ |
1017 | 1017 | ||
1018 | ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); | 1018 | ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); |
1019 | /* | 1019 | /* |
1020 | Writes c, converted to an unsigned char, into the compressed file. | 1020 | Writes c, converted to an unsigned char, into the compressed file. |
1021 | gzputc returns the value that was written, or -1 in case of error. | 1021 | gzputc returns the value that was written, or -1 in case of error. |
1022 | */ | 1022 | */ |
1023 | 1023 | ||
1024 | ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); | 1024 | ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); |
1025 | /* | 1025 | /* |
1026 | Reads one byte from the compressed file. gzgetc returns this byte | 1026 | Reads one byte from the compressed file. gzgetc returns this byte |
1027 | or -1 in case of end of file or error. | 1027 | or -1 in case of end of file or error. |
1028 | */ | 1028 | */ |
1029 | 1029 | ||
1030 | ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); | 1030 | ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); |
1031 | /* | 1031 | /* |
1032 | Push one character back onto the stream to be read again later. | 1032 | Push one character back onto the stream to be read again later. |
1033 | Only one character of push-back is allowed. gzungetc() returns the | 1033 | Only one character of push-back is allowed. gzungetc() returns the |
1034 | character pushed, or -1 on failure. gzungetc() will fail if a | 1034 | character pushed, or -1 on failure. gzungetc() will fail if a |
1035 | character has been pushed but not read yet, or if c is -1. The pushed | 1035 | character has been pushed but not read yet, or if c is -1. The pushed |
1036 | character will be discarded if the stream is repositioned with gzseek() | 1036 | character will be discarded if the stream is repositioned with gzseek() |
1037 | or gzrewind(). | 1037 | or gzrewind(). |
1038 | */ | 1038 | */ |
1039 | 1039 | ||
1040 | ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); | 1040 | ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); |
1041 | /* | 1041 | /* |
1042 | Flushes all pending output into the compressed file. The parameter | 1042 | Flushes all pending output into the compressed file. The parameter |
1043 | flush is as in the deflate() function. The return value is the zlib | 1043 | flush is as in the deflate() function. The return value is the zlib |
1044 | error number (see function gzerror below). gzflush returns Z_OK if | 1044 | error number (see function gzerror below). gzflush returns Z_OK if |
1045 | the flush parameter is Z_FINISH and all output could be flushed. | 1045 | the flush parameter is Z_FINISH and all output could be flushed. |
1046 | gzflush should be called only when strictly necessary because it can | 1046 | gzflush should be called only when strictly necessary because it can |
1047 | degrade compression. | 1047 | degrade compression. |
1048 | */ | 1048 | */ |
1049 | 1049 | ||
1050 | ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, | 1050 | ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, |
1051 | z_off_t offset, int whence)); | 1051 | z_off_t offset, int whence)); |
1052 | /* | 1052 | /* |
1053 | Sets the starting position for the next gzread or gzwrite on the | 1053 | Sets the starting position for the next gzread or gzwrite on the |
1054 | given compressed file. The offset represents a number of bytes in the | 1054 | given compressed file. The offset represents a number of bytes in the |
1055 | uncompressed data stream. The whence parameter is defined as in lseek(2); | 1055 | uncompressed data stream. The whence parameter is defined as in lseek(2); |
1056 | the value SEEK_END is not supported. | 1056 | the value SEEK_END is not supported. |
1057 | If the file is opened for reading, this function is emulated but can be | 1057 | If the file is opened for reading, this function is emulated but can be |
1058 | extremely slow. If the file is opened for writing, only forward seeks are | 1058 | extremely slow. If the file is opened for writing, only forward seeks are |
1059 | supported; gzseek then compresses a sequence of zeroes up to the new | 1059 | supported; gzseek then compresses a sequence of zeroes up to the new |
1060 | starting position. | 1060 | starting position. |
1061 | 1061 | ||
1062 | gzseek returns the resulting offset location as measured in bytes from | 1062 | gzseek returns the resulting offset location as measured in bytes from |
1063 | the beginning of the uncompressed stream, or -1 in case of error, in | 1063 | the beginning of the uncompressed stream, or -1 in case of error, in |
1064 | particular if the file is opened for writing and the new starting position | 1064 | particular if the file is opened for writing and the new starting position |
1065 | would be before the current position. | 1065 | would be before the current position. |
1066 | */ | 1066 | */ |
1067 | 1067 | ||
1068 | ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); | 1068 | ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); |
1069 | /* | 1069 | /* |
1070 | Rewinds the given file. This function is supported only for reading. | 1070 | Rewinds the given file. This function is supported only for reading. |
1071 | 1071 | ||
1072 | gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) | 1072 | gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) |
1073 | */ | 1073 | */ |
1074 | 1074 | ||
1075 | ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); | 1075 | ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); |
1076 | /* | 1076 | /* |
1077 | Returns the starting position for the next gzread or gzwrite on the | 1077 | Returns the starting position for the next gzread or gzwrite on the |
1078 | given compressed file. This position represents a number of bytes in the | 1078 | given compressed file. This position represents a number of bytes in the |
1079 | uncompressed data stream. | 1079 | uncompressed data stream. |
1080 | 1080 | ||
1081 | gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) | 1081 | gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) |
1082 | */ | 1082 | */ |
1083 | 1083 | ||
1084 | ZEXTERN int ZEXPORT gzeof OF((gzFile file)); | 1084 | ZEXTERN int ZEXPORT gzeof OF((gzFile file)); |
1085 | /* | 1085 | /* |
1086 | Returns 1 when EOF has previously been detected reading the given | 1086 | Returns 1 when EOF has previously been detected reading the given |
1087 | input stream, otherwise zero. | 1087 | input stream, otherwise zero. |
1088 | */ | 1088 | */ |
1089 | 1089 | ||
1090 | ZEXTERN int ZEXPORT gzclose OF((gzFile file)); | 1090 | ZEXTERN int ZEXPORT gzclose OF((gzFile file)); |
1091 | /* | 1091 | /* |
1092 | Flushes all pending output if necessary, closes the compressed file | 1092 | Flushes all pending output if necessary, closes the compressed file |
1093 | and deallocates all the (de)compression state. The return value is the zlib | 1093 | and deallocates all the (de)compression state. The return value is the zlib |
1094 | error number (see function gzerror below). | 1094 | error number (see function gzerror below). |
1095 | */ | 1095 | */ |
1096 | 1096 | ||
1097 | ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); | 1097 | ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); |
1098 | /* | 1098 | /* |
1099 | Returns the error message for the last error which occurred on the | 1099 | Returns the error message for the last error which occurred on the |
1100 | given compressed file. errnum is set to zlib error number. If an | 1100 | given compressed file. errnum is set to zlib error number. If an |
1101 | error occurred in the file system and not in the compression library, | 1101 | error occurred in the file system and not in the compression library, |
1102 | errnum is set to Z_ERRNO and the application may consult errno | 1102 | errnum is set to Z_ERRNO and the application may consult errno |
1103 | to get the exact error code. | 1103 | to get the exact error code. |
1104 | */ | 1104 | */ |
1105 | 1105 | ||
1106 | ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); | 1106 | ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); |
1107 | /* | 1107 | /* |
1108 | Clears the error and end-of-file flags for file. This is analogous to the | 1108 | Clears the error and end-of-file flags for file. This is analogous to the |
1109 | clearerr() function in stdio. This is useful for continuing to read a gzip | 1109 | clearerr() function in stdio. This is useful for continuing to read a gzip |
1110 | file that is being written concurrently. | 1110 | file that is being written concurrently. |
1111 | */ | 1111 | */ |
1112 | 1112 | ||
1113 | /* checksum functions */ | 1113 | /* checksum functions */ |
1114 | 1114 | ||
1115 | /* | 1115 | /* |
1116 | These functions are not related to compression but are exported | 1116 | These functions are not related to compression but are exported |
1117 | anyway because they might be useful in applications using the | 1117 | anyway because they might be useful in applications using the |
1118 | compression library. | 1118 | compression library. |
1119 | */ | 1119 | */ |
1120 | 1120 | ||
1121 | ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); | 1121 | ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); |
1122 | 1122 | ||
1123 | /* | 1123 | /* |
1124 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and | 1124 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and |
1125 | return the updated checksum. If buf is NULL, this function returns | 1125 | return the updated checksum. If buf is NULL, this function returns |
1126 | the required initial value for the checksum. | 1126 | the required initial value for the checksum. |
1127 | An Adler-32 checksum is almost as reliable as a CRC32 but can be computed | 1127 | An Adler-32 checksum is almost as reliable as a CRC32 but can be computed |
1128 | much faster. Usage example: | 1128 | much faster. Usage example: |
1129 | 1129 | ||
1130 | uLong adler = adler32(0L, Z_NULL, 0); | 1130 | uLong adler = adler32(0L, Z_NULL, 0); |
1131 | 1131 | ||
1132 | while (read_buffer(buffer, length) != EOF) { | 1132 | while (read_buffer(buffer, length) != EOF) { |
1133 | adler = adler32(adler, buffer, length); | 1133 | adler = adler32(adler, buffer, length); |
1134 | } | 1134 | } |
1135 | if (adler != original_adler) error(); | 1135 | if (adler != original_adler) error(); |
1136 | */ | 1136 | */ |
1137 | 1137 | ||
1138 | ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); | 1138 | ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); |
1139 | /* | 1139 | /* |
1140 | Update a running crc with the bytes buf[0..len-1] and return the updated | 1140 | Update a running crc with the bytes buf[0..len-1] and return the updated |
1141 | crc. If buf is NULL, this function returns the required initial value | 1141 | crc. If buf is NULL, this function returns the required initial value |
1142 | for the crc. Pre- and post-conditioning (one's complement) is performed | 1142 | for the crc. Pre- and post-conditioning (one's complement) is performed |
1143 | within this function so it shouldn't be done by the application. | 1143 | within this function so it shouldn't be done by the application. |
1144 | Usage example: | 1144 | Usage example: |
1145 | 1145 | ||
1146 | uLong crc = crc32(0L, Z_NULL, 0); | 1146 | uLong crc = crc32(0L, Z_NULL, 0); |
1147 | 1147 | ||
1148 | while (read_buffer(buffer, length) != EOF) { | 1148 | while (read_buffer(buffer, length) != EOF) { |
1149 | crc = crc32(crc, buffer, length); | 1149 | crc = crc32(crc, buffer, length); |
1150 | } | 1150 | } |
1151 | if (crc != original_crc) error(); | 1151 | if (crc != original_crc) error(); |
1152 | */ | 1152 | */ |
1153 | 1153 | ||
1154 | 1154 | ||
1155 | /* various hacks, don't look :) */ | 1155 | /* various hacks, don't look :) */ |
1156 | 1156 | ||
1157 | /* deflateInit and inflateInit are macros to allow checking the zlib version | 1157 | /* deflateInit and inflateInit are macros to allow checking the zlib version |
1158 | * and the compiler's view of z_stream: | 1158 | * and the compiler's view of z_stream: |
1159 | */ | 1159 | */ |
1160 | ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, | 1160 | ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, |
1161 | const char *version, int stream_size)); | 1161 | const char *version, int stream_size)); |
1162 | ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, | 1162 | ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, |
1163 | const char *version, int stream_size)); | 1163 | const char *version, int stream_size)); |
1164 | ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, | 1164 | ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, |
1165 | int windowBits, int memLevel, | 1165 | int windowBits, int memLevel, |
1166 | int strategy, const char *version, | 1166 | int strategy, const char *version, |
1167 | int stream_size)); | 1167 | int stream_size)); |
1168 | ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, | 1168 | ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, |
1169 | const char *version, int stream_size)); | 1169 | const char *version, int stream_size)); |
1170 | ZEXTERN int ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, int windowBits, | 1170 | ZEXTERN int ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, int windowBits, |
1171 | unsigned char FAR *window, | 1171 | unsigned char FAR *window, |
1172 | const char *version, | 1172 | const char *version, |
1173 | int stream_size)); | 1173 | int stream_size)); |
1174 | #define deflateInit(strm, level) \ | 1174 | #define deflateInit(strm, level) \ |
1175 | deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) | 1175 | deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) |
1176 | #define inflateInit(strm) \ | 1176 | #define inflateInit(strm) \ |
1177 | inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) | 1177 | inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) |
1178 | #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ | 1178 | #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ |
1179 | deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ | 1179 | deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ |
1180 | (strategy), ZLIB_VERSION, sizeof(z_stream)) | 1180 | (strategy), ZLIB_VERSION, sizeof(z_stream)) |
1181 | #define inflateInit2(strm, windowBits) \ | 1181 | #define inflateInit2(strm, windowBits) \ |
1182 | inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) | 1182 | inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) |
1183 | #define inflateBackInit(strm, windowBits, window) \ | 1183 | #define inflateBackInit(strm, windowBits, window) \ |
1184 | inflateBackInit_((strm), (windowBits), (window), \ | 1184 | inflateBackInit_((strm), (windowBits), (window), \ |
1185 | ZLIB_VERSION, sizeof(z_stream)) | 1185 | ZLIB_VERSION, sizeof(z_stream)) |
1186 | 1186 | ||
1187 | 1187 | ||
1188 | #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) | 1188 | #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) |
1189 | struct internal_state {int dummy;}; /* hack for buggy compilers */ | 1189 | struct internal_state {int dummy;}; /* hack for buggy compilers */ |
1190 | #endif | 1190 | #endif |
1191 | 1191 | ||
1192 | ZEXTERN const char * ZEXPORT zError OF((int)); | 1192 | ZEXTERN const char * ZEXPORT zError OF((int)); |
1193 | ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); | 1193 | ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); |
1194 | ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); | 1194 | ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); |
1195 | 1195 | ||
1196 | #ifdef __cplusplus | 1196 | #ifdef __cplusplus |
1197 | } | 1197 | } |
1198 | #endif | 1198 | #endif |
1199 | 1199 | ||
1200 | #endif /* ZLIB_H */ | 1200 | #endif /* ZLIB_H */ |