diff options
Diffstat (limited to 'apps/plugins/imageviewer/png/inflate.c')
-rw-r--r-- | apps/plugins/imageviewer/png/inflate.c | 1332 |
1 files changed, 1332 insertions, 0 deletions
diff --git a/apps/plugins/imageviewer/png/inflate.c b/apps/plugins/imageviewer/png/inflate.c new file mode 100644 index 0000000000..beec74044b --- /dev/null +++ b/apps/plugins/imageviewer/png/inflate.c | |||
@@ -0,0 +1,1332 @@ | |||
1 | /* inflate.c -- zlib decompression | ||
2 | * Copyright (C) 1995-2005 Mark Adler | ||
3 | * For conditions of distribution and use, see copyright notice in zlib.h | ||
4 | */ | ||
5 | |||
6 | /* | ||
7 | * Change history: | ||
8 | * | ||
9 | * 1.2.beta0 24 Nov 2002 | ||
10 | * - First version -- complete rewrite of inflate to simplify code, avoid | ||
11 | * creation of window when not needed, minimize use of window when it is | ||
12 | * needed, make inffast.c even faster, implement gzip decoding, and to | ||
13 | * improve code readability and style over the previous zlib inflate code | ||
14 | * | ||
15 | * 1.2.beta1 25 Nov 2002 | ||
16 | * - Use pointers for available input and output checking in inffast.c | ||
17 | * - Remove input and output counters in inffast.c | ||
18 | * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 | ||
19 | * - Remove unnecessary second byte pull from length extra in inffast.c | ||
20 | * - Unroll direct copy to three copies per loop in inffast.c | ||
21 | * | ||
22 | * 1.2.beta2 4 Dec 2002 | ||
23 | * - Change external routine names to reduce potential conflicts | ||
24 | * - Correct filename to inffixed.h for fixed tables in inflate.c | ||
25 | * - Make hbuf[] unsigned char to match parameter type in inflate.c | ||
26 | * - Change strm->next_out[-state.offset] to *(strm->next_out - state.offset) | ||
27 | * to avoid negation problem on Alphas (64 bit) in inflate.c | ||
28 | * | ||
29 | * 1.2.beta3 22 Dec 2002 | ||
30 | * - Add comments on state.bits assertion in inffast.c | ||
31 | * - Add comments on op field in inftrees.h | ||
32 | * - Fix bug in reuse of allocated window after inflateReset() | ||
33 | * - Remove bit fields--back to byte structure for speed | ||
34 | * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths | ||
35 | * - Change post-increments to pre-increments in inflate_fast(), PPC biased? | ||
36 | * - Add compile time option, POSTINC, to use post-increments instead (Intel?) | ||
37 | * - Make MATCH copy in inflate() much faster for when inflate_fast() not used | ||
38 | * - Use local copies of stream next and avail values, as well as local bit | ||
39 | * buffer and bit count in inflate()--for speed when inflate_fast() not used | ||
40 | * | ||
41 | * 1.2.beta4 1 Jan 2003 | ||
42 | * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings | ||
43 | * - Move a comment on output buffer sizes from inffast.c to inflate.c | ||
44 | * - Add comments in inffast.c to introduce the inflate_fast() routine | ||
45 | * - Rearrange window copies in inflate_fast() for speed and simplification | ||
46 | * - Unroll last copy for window match in inflate_fast() | ||
47 | * - Use local copies of window variables in inflate_fast() for speed | ||
48 | * - Pull out common write == 0 case for speed in inflate_fast() | ||
49 | * - Make op and len in inflate_fast() unsigned for consistency | ||
50 | * - Add FAR to lcode and dcode declarations in inflate_fast() | ||
51 | * - Simplified bad distance check in inflate_fast() | ||
52 | * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new | ||
53 | * source file infback.c to provide a call-back interface to inflate for | ||
54 | * programs like gzip and unzip -- uses window as output buffer to avoid | ||
55 | * window copying | ||
56 | * | ||
57 | * 1.2.beta5 1 Jan 2003 | ||
58 | * - Improved inflateBack() interface to allow the caller to provide initial | ||
59 | * input in strm. | ||
60 | * - Fixed stored blocks bug in inflateBack() | ||
61 | * | ||
62 | * 1.2.beta6 4 Jan 2003 | ||
63 | * - Added comments in inffast.c on effectiveness of POSTINC | ||
64 | * - Typecasting all around to reduce compiler warnings | ||
65 | * - Changed loops from while (1) or do {} while (1) to for (;;), again to | ||
66 | * make compilers happy | ||
67 | * - Changed type of window in inflateBackInit() to unsigned char * | ||
68 | * | ||
69 | * 1.2.beta7 27 Jan 2003 | ||
70 | * - Changed many types to unsigned or unsigned short to avoid warnings | ||
71 | * - Added inflateCopy() function | ||
72 | * | ||
73 | * 1.2.0 9 Mar 2003 | ||
74 | * - Changed inflateBack() interface to provide separate opaque descriptors | ||
75 | * for the in() and out() functions | ||
76 | * - Changed inflateBack() argument and in_func typedef to swap the length | ||
77 | * and buffer address return values for the input function | ||
78 | * - Check next_in and next_out for Z_NULL on entry to inflate() | ||
79 | * | ||
80 | * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. | ||
81 | */ | ||
82 | |||
83 | #include "zutil.h" | ||
84 | #include "inftrees.h" | ||
85 | #include "inflate.h" | ||
86 | #include "inffast.h" | ||
87 | #include "plugin.h" | ||
88 | #include "png.h" | ||
89 | |||
90 | #ifdef MAKEFIXED | ||
91 | # ifndef BUILDFIXED | ||
92 | # define BUILDFIXED | ||
93 | # endif | ||
94 | #endif | ||
95 | |||
96 | struct inflate_state state; | ||
97 | |||
98 | /* function prototypes */ | ||
99 | local void fixedtables OF((void)); | ||
100 | local int updatewindow OF((z_streamp strm, unsigned out)); | ||
101 | #ifdef BUILDFIXED | ||
102 | void makefixed OF((void)); | ||
103 | #endif | ||
104 | local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, | ||
105 | unsigned len)); | ||
106 | |||
107 | int ZEXPORT inflateReset(strm) | ||
108 | z_streamp strm; | ||
109 | { | ||
110 | //struct inflate_state FAR *state; | ||
111 | |||
112 | if (strm == Z_NULL) return Z_STREAM_ERROR; | ||
113 | //state = strm->state; | ||
114 | strm->total_in = strm->total_out = state.total = 0; | ||
115 | strm->msg = Z_NULL; | ||
116 | strm->adler = 1; /* to support ill-conceived Java test suite */ | ||
117 | state.mode = HEAD; | ||
118 | state.last = 0; | ||
119 | state.havedict = 0; | ||
120 | state.dmax = 32768U; | ||
121 | state.head = Z_NULL; | ||
122 | state.wsize = 0; | ||
123 | state.whave = 0; | ||
124 | state.write = 0; | ||
125 | state.hold = 0; | ||
126 | state.bits = 0; | ||
127 | state.lencode = state.distcode = state.next = state.codes; | ||
128 | //DEBUGF("inflate: reset\n"); | ||
129 | return Z_OK; | ||
130 | } | ||
131 | |||
132 | int ZEXPORT inflatePrime(strm, bits, value) | ||
133 | z_streamp strm; | ||
134 | int bits; | ||
135 | int value; | ||
136 | { | ||
137 | //struct inflate_state FAR *state; | ||
138 | |||
139 | if (strm == Z_NULL) return Z_STREAM_ERROR; | ||
140 | //state = (struct inflate_state FAR *)strm->state; | ||
141 | if (bits > 16 || state.bits + bits > 32) return Z_STREAM_ERROR; | ||
142 | value &= (1L << bits) - 1; | ||
143 | state.hold += value << state.bits; | ||
144 | state.bits += bits; | ||
145 | return Z_OK; | ||
146 | } | ||
147 | |||
148 | int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) | ||
149 | z_streamp strm; | ||
150 | int windowBits; | ||
151 | const char *version; | ||
152 | int stream_size; | ||
153 | { | ||
154 | //struct inflate_state FAR *state; | ||
155 | |||
156 | if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || | ||
157 | stream_size != (int)(sizeof(z_stream))) | ||
158 | return Z_VERSION_ERROR; | ||
159 | if (strm == Z_NULL) return Z_STREAM_ERROR; | ||
160 | strm->msg = Z_NULL; /* in case we return an error */ | ||
161 | //if (strm->zalloc == (alloc_func)0) { | ||
162 | // strm->zalloc = zcalloc; | ||
163 | // strm->opaque = (voidpf)0; | ||
164 | //} | ||
165 | //if (strm->zfree == (free_func)0) strm->zfree = zcfree; | ||
166 | //state = (struct inflate_state FAR *) | ||
167 | // ZALLOC(strm, 1, sizeof(struct inflate_state)); | ||
168 | //if (state == Z_NULL) return Z_MEM_ERROR; | ||
169 | //DEBUGF("inflate: allocated\n"); | ||
170 | //strm->state = (struct internal_state FAR *)state; | ||
171 | if (windowBits < 0) { | ||
172 | state.wrap = 0; | ||
173 | windowBits = -windowBits; | ||
174 | } | ||
175 | else { | ||
176 | state.wrap = (windowBits >> 4) + 1; | ||
177 | #ifdef GUNZIP | ||
178 | if (windowBits < 48) windowBits &= 15; | ||
179 | #endif | ||
180 | } | ||
181 | if (windowBits < 8 || windowBits > 15) { | ||
182 | //ZFREE(strm, state); | ||
183 | //strm->state = Z_NULL; | ||
184 | return Z_STREAM_ERROR; | ||
185 | } | ||
186 | state.wbits = (unsigned)windowBits; | ||
187 | state.window = Z_NULL; | ||
188 | return inflateReset(strm); | ||
189 | } | ||
190 | |||
191 | int ZEXPORT inflateInit_(strm, version, stream_size) | ||
192 | z_streamp strm; | ||
193 | const char *version; | ||
194 | int stream_size; | ||
195 | { | ||
196 | return inflateInit2_(strm, DEF_WBITS, version, stream_size); | ||
197 | } | ||
198 | |||
199 | /* | ||
200 | Return state with length and distance decoding tables and index sizes set to | ||
201 | fixed code decoding. Normally this returns fixed tables from inffixed.h. | ||
202 | If BUILDFIXED is defined, then instead this routine builds the tables the | ||
203 | first time it's called, and returns those tables the first time and | ||
204 | thereafter. This reduces the size of the code by about 2K bytes, in | ||
205 | exchange for a little execution time. However, BUILDFIXED should not be | ||
206 | used for threaded applications, since the rewriting of the tables and virgin | ||
207 | may not be thread-safe. | ||
208 | */ | ||
209 | local void fixedtables(void) | ||
210 | //struct inflate_state FAR *state; | ||
211 | { | ||
212 | #ifdef BUILDFIXED | ||
213 | static int virgin = 1; | ||
214 | static code *lenfix, *distfix; | ||
215 | static code fixed[544]; | ||
216 | |||
217 | /* build fixed huffman tables if first call (may not be thread safe) */ | ||
218 | if (virgin) { | ||
219 | unsigned sym, bits; | ||
220 | static code *next; | ||
221 | |||
222 | /* literal/length table */ | ||
223 | sym = 0; | ||
224 | while (sym < 144) state.lens[sym++] = 8; | ||
225 | while (sym < 256) state.lens[sym++] = 9; | ||
226 | while (sym < 280) state.lens[sym++] = 7; | ||
227 | while (sym < 288) state.lens[sym++] = 8; | ||
228 | next = fixed; | ||
229 | lenfix = next; | ||
230 | bits = 9; | ||
231 | inflate_table(LENS, state.lens, 288, &(next), &(bits), state.work); | ||
232 | |||
233 | /* distance table */ | ||
234 | sym = 0; | ||
235 | while (sym < 32) state.lens[sym++] = 5; | ||
236 | distfix = next; | ||
237 | bits = 5; | ||
238 | inflate_table(DISTS, state.lens, 32, &(next), &(bits), state.work); | ||
239 | |||
240 | /* do this just once */ | ||
241 | virgin = 0; | ||
242 | } | ||
243 | #else /* !BUILDFIXED */ | ||
244 | # include "inffixed.h" | ||
245 | #endif /* BUILDFIXED */ | ||
246 | state.lencode = lenfix; | ||
247 | state.lenbits = 9; | ||
248 | state.distcode = distfix; | ||
249 | state.distbits = 5; | ||
250 | } | ||
251 | |||
252 | #ifdef MAKEFIXED | ||
253 | #include <stdio.h> | ||
254 | |||
255 | /* | ||
256 | Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also | ||
257 | defines BUILDFIXED, so the tables are built on the fly. makefixed() writes | ||
258 | those tables to stdout, which would be piped to inffixed.h. A small program | ||
259 | can simply call makefixed to do this: | ||
260 | |||
261 | void makefixed(void); | ||
262 | |||
263 | int main(void) | ||
264 | { | ||
265 | makefixed(); | ||
266 | return 0; | ||
267 | } | ||
268 | |||
269 | Then that can be linked with zlib built with MAKEFIXED defined and run: | ||
270 | |||
271 | a.out > inffixed.h | ||
272 | */ | ||
273 | void makefixed() | ||
274 | { | ||
275 | unsigned low, size; | ||
276 | struct inflate_state state; | ||
277 | |||
278 | fixedtables(&state); | ||
279 | puts(" /* inffixed.h -- table for decoding fixed codes"); | ||
280 | puts(" * Generated automatically by makefixed()."); | ||
281 | puts(" */"); | ||
282 | puts(""); | ||
283 | puts(" /* WARNING: this file should *not* be used by applications."); | ||
284 | puts(" It is part of the implementation of this library and is"); | ||
285 | puts(" subject to change. Applications should only use zlib.h."); | ||
286 | puts(" */"); | ||
287 | puts(""); | ||
288 | size = 1U << 9; | ||
289 | printf(" static const code lenfix[%u] = {", size); | ||
290 | low = 0; | ||
291 | for (;;) { | ||
292 | if ((low % 7) == 0) printf("\n "); | ||
293 | printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits, | ||
294 | state.lencode[low].val); | ||
295 | if (++low == size) break; | ||
296 | putchar(','); | ||
297 | } | ||
298 | puts("\n };"); | ||
299 | size = 1U << 5; | ||
300 | printf("\n static const code distfix[%u] = {", size); | ||
301 | low = 0; | ||
302 | for (;;) { | ||
303 | if ((low % 6) == 0) printf("\n "); | ||
304 | printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, | ||
305 | state.distcode[low].val); | ||
306 | if (++low == size) break; | ||
307 | putchar(','); | ||
308 | } | ||
309 | puts("\n };"); | ||
310 | } | ||
311 | #endif /* MAKEFIXED */ | ||
312 | |||
313 | /* | ||
314 | Update the window with the last wsize (normally 32K) bytes written before | ||
315 | returning. If window does not exist yet, create it. This is only called | ||
316 | when a window is already in use, or when output has been written during this | ||
317 | inflate call, but the end of the deflate stream has not been reached yet. | ||
318 | It is also called to create a window for dictionary data when a dictionary | ||
319 | is loaded. | ||
320 | |||
321 | Providing output buffers larger than 32K to inflate() should provide a speed | ||
322 | advantage, since only the last 32K of output is copied to the sliding window | ||
323 | upon return from inflate(), and since all distances after the first 32K of | ||
324 | output will fall in the output data, making match copies simpler and faster. | ||
325 | The advantage may be dependent on the size of the processor's data caches. | ||
326 | */ | ||
327 | local int updatewindow(strm, out) | ||
328 | z_streamp strm; | ||
329 | unsigned out; | ||
330 | { | ||
331 | //struct inflate_state FAR *state; | ||
332 | unsigned copy, dist; | ||
333 | |||
334 | //state = (struct inflate_state FAR *)strm->state; | ||
335 | |||
336 | /* if it hasn't been done already, allocate space for the window */ | ||
337 | if (state.window == Z_NULL) { | ||
338 | state.window = (unsigned char FAR *) | ||
339 | ZALLOC(strm, 1U << state.wbits, | ||
340 | sizeof(unsigned char)); | ||
341 | if (state.window == Z_NULL) return 1; | ||
342 | } | ||
343 | |||
344 | /* if window not in use yet, initialize */ | ||
345 | if (state.wsize == 0) { | ||
346 | state.wsize = 1U << state.wbits; | ||
347 | state.write = 0; | ||
348 | state.whave = 0; | ||
349 | } | ||
350 | |||
351 | /* copy state.wsize or less output bytes into the circular window */ | ||
352 | copy = out - strm->avail_out; | ||
353 | if (copy >= state.wsize) { | ||
354 | zmemcpy(state.window, strm->next_out - state.wsize, state.wsize); | ||
355 | state.write = 0; | ||
356 | state.whave = state.wsize; | ||
357 | } | ||
358 | else { | ||
359 | dist = state.wsize - state.write; | ||
360 | if (dist > copy) dist = copy; | ||
361 | zmemcpy(state.window + state.write, strm->next_out - copy, dist); | ||
362 | copy -= dist; | ||
363 | if (copy) { | ||
364 | zmemcpy(state.window, strm->next_out - copy, copy); | ||
365 | state.write = copy; | ||
366 | state.whave = state.wsize; | ||
367 | } | ||
368 | else { | ||
369 | state.write += dist; | ||
370 | if (state.write == state.wsize) state.write = 0; | ||
371 | if (state.whave < state.wsize) state.whave += dist; | ||
372 | } | ||
373 | } | ||
374 | return 0; | ||
375 | } | ||
376 | |||
377 | /* Macros for inflate(): */ | ||
378 | |||
379 | /* check function to use adler32() for zlib or crc32() for gzip */ | ||
380 | #ifdef GUNZIP | ||
381 | # define UPDATE(check, buf, len) \ | ||
382 | (state.flags ? crc32(check, buf, len) : adler32(check, buf, len)) | ||
383 | #else | ||
384 | # define UPDATE(check, buf, len) adler32(check, buf, len) | ||
385 | #endif | ||
386 | |||
387 | /* check macros for header crc */ | ||
388 | #ifdef GUNZIP | ||
389 | # define CRC2(check, word) \ | ||
390 | do { \ | ||
391 | hbuf[0] = (unsigned char)(word); \ | ||
392 | hbuf[1] = (unsigned char)((word) >> 8); \ | ||
393 | check = crc32(check, hbuf, 2); \ | ||
394 | } while (0) | ||
395 | |||
396 | # define CRC4(check, word) \ | ||
397 | do { \ | ||
398 | hbuf[0] = (unsigned char)(word); \ | ||
399 | hbuf[1] = (unsigned char)((word) >> 8); \ | ||
400 | hbuf[2] = (unsigned char)((word) >> 16); \ | ||
401 | hbuf[3] = (unsigned char)((word) >> 24); \ | ||
402 | check = crc32(check, hbuf, 4); \ | ||
403 | } while (0) | ||
404 | #endif | ||
405 | |||
406 | /* Load registers with state in inflate() for speed */ | ||
407 | #define LOAD() \ | ||
408 | do { \ | ||
409 | put = strm->next_out; \ | ||
410 | left = strm->avail_out; \ | ||
411 | next = strm->next_in; \ | ||
412 | have = strm->avail_in; \ | ||
413 | hold = state.hold; \ | ||
414 | bits = state.bits; \ | ||
415 | } while (0) | ||
416 | |||
417 | /* Restore state from registers in inflate() */ | ||
418 | #define RESTORE() \ | ||
419 | do { \ | ||
420 | strm->next_out = put; \ | ||
421 | strm->avail_out = left; \ | ||
422 | strm->next_in = next; \ | ||
423 | strm->avail_in = have; \ | ||
424 | state.hold = hold; \ | ||
425 | state.bits = bits; \ | ||
426 | } while (0) | ||
427 | |||
428 | /* Clear the input bit accumulator */ | ||
429 | #define INITBITS() \ | ||
430 | do { \ | ||
431 | hold = 0; \ | ||
432 | bits = 0; \ | ||
433 | } while (0) | ||
434 | |||
435 | /* Get a byte of input into the bit accumulator, or return from inflate() | ||
436 | if there is no input available. */ | ||
437 | #define PULLBYTE() \ | ||
438 | do { \ | ||
439 | if (have == 0) goto inf_leave; \ | ||
440 | have--; \ | ||
441 | hold += (unsigned long)(*next++) << bits; \ | ||
442 | bits += 8; \ | ||
443 | } while (0) | ||
444 | |||
445 | /* Assure that there are at least n bits in the bit accumulator. If there is | ||
446 | not enough available input to do that, then return from inflate(). */ | ||
447 | #define NEEDBITS(n) \ | ||
448 | do { \ | ||
449 | while (bits < (unsigned)(n)) \ | ||
450 | PULLBYTE(); \ | ||
451 | } while (0) | ||
452 | |||
453 | /* Return the low n bits of the bit accumulator (n < 16) */ | ||
454 | #define BITS(n) \ | ||
455 | ((unsigned)hold & ((1U << (n)) - 1)) | ||
456 | |||
457 | /* Remove n bits from the bit accumulator */ | ||
458 | #define DROPBITS(n) \ | ||
459 | do { \ | ||
460 | hold >>= (n); \ | ||
461 | bits -= (unsigned)(n); \ | ||
462 | } while (0) | ||
463 | |||
464 | /* Remove zero to seven bits as needed to go to a byte boundary */ | ||
465 | #define BYTEBITS() \ | ||
466 | do { \ | ||
467 | hold >>= bits & 7; \ | ||
468 | bits -= bits & 7; \ | ||
469 | } while (0) | ||
470 | |||
471 | /* Reverse the bytes in a 32-bit value */ | ||
472 | #define REVERSE(q) \ | ||
473 | ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ | ||
474 | (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) | ||
475 | |||
476 | /* | ||
477 | inflate() uses a state machine to process as much input data and generate as | ||
478 | much output data as possible before returning. The state machine is | ||
479 | structured roughly as follows: | ||
480 | |||
481 | for (;;) switch (state) { | ||
482 | ... | ||
483 | case STATEn: | ||
484 | if (not enough input data or output space to make progress) | ||
485 | return; | ||
486 | ... make progress ... | ||
487 | state = STATEm; | ||
488 | break; | ||
489 | ... | ||
490 | } | ||
491 | |||
492 | so when inflate() is called again, the same case is attempted again, and | ||
493 | if the appropriate resources are provided, the machine proceeds to the | ||
494 | next state. The NEEDBITS() macro is usually the way the state evaluates | ||
495 | whether it can proceed or should return. NEEDBITS() does the return if | ||
496 | the requested bits are not available. The typical use of the BITS macros | ||
497 | is: | ||
498 | |||
499 | NEEDBITS(n); | ||
500 | ... do something with BITS(n) ... | ||
501 | DROPBITS(n); | ||
502 | |||
503 | where NEEDBITS(n) either returns from inflate() if there isn't enough | ||
504 | input left to load n bits into the accumulator, or it continues. BITS(n) | ||
505 | gives the low n bits in the accumulator. When done, DROPBITS(n) drops | ||
506 | the low n bits off the accumulator. INITBITS() clears the accumulator | ||
507 | and sets the number of available bits to zero. BYTEBITS() discards just | ||
508 | enough bits to put the accumulator on a byte boundary. After BYTEBITS() | ||
509 | and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. | ||
510 | |||
511 | NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return | ||
512 | if there is no input available. The decoding of variable length codes uses | ||
513 | PULLBYTE() directly in order to pull just enough bytes to decode the next | ||
514 | code, and no more. | ||
515 | |||
516 | Some states loop until they get enough input, making sure that enough | ||
517 | state information is maintained to continue the loop where it left off | ||
518 | if NEEDBITS() returns in the loop. For example, want, need, and keep | ||
519 | would all have to actually be part of the saved state in case NEEDBITS() | ||
520 | returns: | ||
521 | |||
522 | case STATEw: | ||
523 | while (want < need) { | ||
524 | NEEDBITS(n); | ||
525 | keep[want++] = BITS(n); | ||
526 | DROPBITS(n); | ||
527 | } | ||
528 | state = STATEx; | ||
529 | case STATEx: | ||
530 | |||
531 | As shown above, if the next state is also the next case, then the break | ||
532 | is omitted. | ||
533 | |||
534 | A state may also return if there is not enough output space available to | ||
535 | complete that state. Those states are copying stored data, writing a | ||
536 | literal byte, and copying a matching string. | ||
537 | |||
538 | When returning, a "goto inf_leave" is used to update the total counters, | ||
539 | update the check value, and determine whether any progress has been made | ||
540 | during that inflate() call in order to return the proper return code. | ||
541 | Progress is defined as a change in either strm->avail_in or strm->avail_out. | ||
542 | When there is a window, goto inf_leave will update the window with the last | ||
543 | output written. If a goto inf_leave occurs in the middle of decompression | ||
544 | and there is no window currently, goto inf_leave will create one and copy | ||
545 | output to the window for the next call of inflate(). | ||
546 | |||
547 | In this implementation, the flush parameter of inflate() only affects the | ||
548 | return code (per zlib.h). inflate() always writes as much as possible to | ||
549 | strm->next_out, given the space available and the provided input--the effect | ||
550 | documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers | ||
551 | the allocation of and copying into a sliding window until necessary, which | ||
552 | provides the effect documented in zlib.h for Z_FINISH when the entire input | ||
553 | stream available. So the only thing the flush parameter actually does is: | ||
554 | when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it | ||
555 | will return Z_BUF_ERROR if it has not reached the end of the stream. | ||
556 | */ | ||
557 | |||
558 | int ZEXPORT inflate(strm, flush) | ||
559 | z_streamp strm; | ||
560 | int flush; | ||
561 | { | ||
562 | //struct inflate_state FAR *state; | ||
563 | unsigned char FAR *next; /* next input */ | ||
564 | unsigned char FAR *put; /* next output */ | ||
565 | unsigned have, left; /* available input and output */ | ||
566 | unsigned long hold; /* bit buffer */ | ||
567 | unsigned bits; /* bits in bit buffer */ | ||
568 | unsigned in, out; /* save starting available input and output */ | ||
569 | unsigned copy; /* number of stored or match bytes to copy */ | ||
570 | unsigned char FAR *from; /* where to copy match bytes from */ | ||
571 | code this; /* current decoding table entry */ | ||
572 | code last; /* parent table entry */ | ||
573 | unsigned len; /* length to copy for repeats, bits to drop */ | ||
574 | int ret; /* return code */ | ||
575 | #ifdef GUNZIP | ||
576 | unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ | ||
577 | #endif | ||
578 | static const unsigned short order[19] = /* permutation of code lengths */ | ||
579 | {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; | ||
580 | |||
581 | if (strm == Z_NULL || strm->next_out == Z_NULL || | ||
582 | (strm->next_in == Z_NULL && strm->avail_in != 0)) | ||
583 | return Z_STREAM_ERROR; | ||
584 | |||
585 | uInt insize = strm->avail_in; | ||
586 | |||
587 | //state = (struct inflate_state FAR *)strm->state; | ||
588 | if (state.mode == TYPE) state.mode = TYPEDO; /* skip check */ | ||
589 | LOAD(); | ||
590 | in = have; | ||
591 | out = left; | ||
592 | ret = Z_OK; | ||
593 | for (;;) { | ||
594 | switch (state.mode) { | ||
595 | case HEAD: | ||
596 | if (state.wrap == 0) { | ||
597 | state.mode = TYPEDO; | ||
598 | break; | ||
599 | } | ||
600 | NEEDBITS(16); | ||
601 | #ifdef GUNZIP | ||
602 | if ((state.wrap & 2) && hold == 0x8b1f) { /* gzip header */ | ||
603 | state.check = crc32(0L, Z_NULL, 0); | ||
604 | CRC2(state.check, hold); | ||
605 | INITBITS(); | ||
606 | state.mode = FLAGS; | ||
607 | break; | ||
608 | } | ||
609 | state.flags = 0; /* expect zlib header */ | ||
610 | if (state.head != Z_NULL) | ||
611 | state.head->done = -1; | ||
612 | if (!(state.wrap & 1) || /* check if zlib header allowed */ | ||
613 | #else | ||
614 | if ( | ||
615 | #endif | ||
616 | ((BITS(8) << 8) + (hold >> 8)) % 31) { | ||
617 | strm->msg = (char *)"incorrect header check"; | ||
618 | state.mode = BAD; | ||
619 | break; | ||
620 | } | ||
621 | if (BITS(4) != Z_DEFLATED) { | ||
622 | strm->msg = (char *)"unknown compression method"; | ||
623 | state.mode = BAD; | ||
624 | break; | ||
625 | } | ||
626 | DROPBITS(4); | ||
627 | len = BITS(4) + 8; | ||
628 | if (len > state.wbits) { | ||
629 | strm->msg = (char *)"invalid window size"; | ||
630 | state.mode = BAD; | ||
631 | break; | ||
632 | } | ||
633 | state.dmax = 1U << len; | ||
634 | //DEBUGF("inflate: zlib header ok\n"); | ||
635 | strm->adler = state.check = adler32(0L, Z_NULL, 0); | ||
636 | state.mode = hold & 0x200 ? DICTID : TYPE; | ||
637 | INITBITS(); | ||
638 | break; | ||
639 | #ifdef GUNZIP | ||
640 | case FLAGS: | ||
641 | NEEDBITS(16); | ||
642 | state.flags = (int)(hold); | ||
643 | if ((state.flags & 0xff) != Z_DEFLATED) { | ||
644 | strm->msg = (char *)"unknown compression method"; | ||
645 | state.mode = BAD; | ||
646 | break; | ||
647 | } | ||
648 | if (state.flags & 0xe000) { | ||
649 | strm->msg = (char *)"unknown header flags set"; | ||
650 | state.mode = BAD; | ||
651 | break; | ||
652 | } | ||
653 | if (state.head != Z_NULL) | ||
654 | state.head->text = (int)((hold >> 8) & 1); | ||
655 | if (state.flags & 0x0200) CRC2(state.check, hold); | ||
656 | INITBITS(); | ||
657 | state.mode = TIME; | ||
658 | case TIME: | ||
659 | NEEDBITS(32); | ||
660 | if (state.head != Z_NULL) | ||
661 | state.head->time = hold; | ||
662 | if (state.flags & 0x0200) CRC4(state.check, hold); | ||
663 | INITBITS(); | ||
664 | state.mode = OS; | ||
665 | case OS: | ||
666 | NEEDBITS(16); | ||
667 | if (state.head != Z_NULL) { | ||
668 | state.head->xflags = (int)(hold & 0xff); | ||
669 | state.head->os = (int)(hold >> 8); | ||
670 | } | ||
671 | if (state.flags & 0x0200) CRC2(state.check, hold); | ||
672 | INITBITS(); | ||
673 | state.mode = EXLEN; | ||
674 | case EXLEN: | ||
675 | if (state.flags & 0x0400) { | ||
676 | NEEDBITS(16); | ||
677 | state.length = (unsigned)(hold); | ||
678 | if (state.head != Z_NULL) | ||
679 | state.head->extra_len = (unsigned)hold; | ||
680 | if (state.flags & 0x0200) CRC2(state.check, hold); | ||
681 | INITBITS(); | ||
682 | } | ||
683 | else if (state.head != Z_NULL) | ||
684 | state.head->extra = Z_NULL; | ||
685 | state.mode = EXTRA; | ||
686 | case EXTRA: | ||
687 | if (state.flags & 0x0400) { | ||
688 | copy = state.length; | ||
689 | if (copy > have) copy = have; | ||
690 | if (copy) { | ||
691 | if (state.head != Z_NULL && | ||
692 | state.head->extra != Z_NULL) { | ||
693 | len = state.head->extra_len - state.length; | ||
694 | zmemcpy(state.head->extra + len, next, | ||
695 | len + copy > state.head->extra_max ? | ||
696 | state.head->extra_max - len : copy); | ||
697 | } | ||
698 | if (state.flags & 0x0200) | ||
699 | state.check = crc32(state.check, next, copy); | ||
700 | have -= copy; | ||
701 | next += copy; | ||
702 | state.length -= copy; | ||
703 | } | ||
704 | if (state.length) goto inf_leave; | ||
705 | } | ||
706 | state.length = 0; | ||
707 | state.mode = NAME; | ||
708 | case NAME: | ||
709 | if (state.flags & 0x0800) { | ||
710 | if (have == 0) goto inf_leave; | ||
711 | copy = 0; | ||
712 | do { | ||
713 | len = (unsigned)(next[copy++]); | ||
714 | if (state.head != Z_NULL && | ||
715 | state.head->name != Z_NULL && | ||
716 | state.length < state.head->name_max) | ||
717 | state.head->name[state.length++] = len; | ||
718 | } while (len && copy < have); | ||
719 | if (state.flags & 0x0200) | ||
720 | state.check = crc32(state.check, next, copy); | ||
721 | have -= copy; | ||
722 | next += copy; | ||
723 | if (len) goto inf_leave; | ||
724 | } | ||
725 | else if (state.head != Z_NULL) | ||
726 | state.head->name = Z_NULL; | ||
727 | state.length = 0; | ||
728 | state.mode = COMMENT; | ||
729 | case COMMENT: | ||
730 | if (state.flags & 0x1000) { | ||
731 | if (have == 0) goto inf_leave; | ||
732 | copy = 0; | ||
733 | do { | ||
734 | len = (unsigned)(next[copy++]); | ||
735 | if (state.head != Z_NULL && | ||
736 | state.head->comment != Z_NULL && | ||
737 | state.length < state.head->comm_max) | ||
738 | state.head->comment[state.length++] = len; | ||
739 | } while (len && copy < have); | ||
740 | if (state.flags & 0x0200) | ||
741 | state.check = crc32(state.check, next, copy); | ||
742 | have -= copy; | ||
743 | next += copy; | ||
744 | if (len) goto inf_leave; | ||
745 | } | ||
746 | else if (state.head != Z_NULL) | ||
747 | state.head->comment = Z_NULL; | ||
748 | state.mode = HCRC; | ||
749 | case HCRC: | ||
750 | if (state.flags & 0x0200) { | ||
751 | NEEDBITS(16); | ||
752 | if (hold != (state.check & 0xffff)) { | ||
753 | strm->msg = (char *)"header crc mismatch"; | ||
754 | state.mode = BAD; | ||
755 | break; | ||
756 | } | ||
757 | INITBITS(); | ||
758 | } | ||
759 | if (state.head != Z_NULL) { | ||
760 | state.head->hcrc = (int)((state.flags >> 9) & 1); | ||
761 | state.head->done = 1; | ||
762 | } | ||
763 | strm->adler = state.check = crc32(0L, Z_NULL, 0); | ||
764 | state.mode = TYPE; | ||
765 | break; | ||
766 | #endif | ||
767 | case DICTID: | ||
768 | NEEDBITS(32); | ||
769 | strm->adler = state.check = REVERSE(hold); | ||
770 | INITBITS(); | ||
771 | state.mode = DICT; | ||
772 | case DICT: | ||
773 | if (state.havedict == 0) { | ||
774 | RESTORE(); | ||
775 | return Z_NEED_DICT; | ||
776 | } | ||
777 | strm->adler = state.check = adler32(0L, Z_NULL, 0); | ||
778 | state.mode = TYPE; | ||
779 | case TYPE: | ||
780 | if (flush == Z_BLOCK) goto inf_leave; | ||
781 | case TYPEDO: | ||
782 | if (state.last) { | ||
783 | BYTEBITS(); | ||
784 | state.mode = CHECK; | ||
785 | break; | ||
786 | } | ||
787 | NEEDBITS(3); | ||
788 | state.last = BITS(1); | ||
789 | DROPBITS(1); | ||
790 | switch (BITS(2)) { | ||
791 | case 0: /* stored block */ | ||
792 | //DEBUGF("inflate: stored block%s\n", | ||
793 | //state.last ? " (last)" : ""); | ||
794 | state.mode = STORED; | ||
795 | break; | ||
796 | case 1: /* fixed block */ | ||
797 | fixedtables(); | ||
798 | //DEBUGF("inflate: fixed codes block%s\n", | ||
799 | //state.last ? " (last)" : ""); | ||
800 | state.mode = LEN; /* decode codes */ | ||
801 | break; | ||
802 | case 2: /* dynamic block */ | ||
803 | //DEBUGF("inflate: dynamic codes block%s\n", | ||
804 | //state.last ? " (last)" : ""); | ||
805 | state.mode = TABLE; | ||
806 | break; | ||
807 | case 3: | ||
808 | strm->msg = (char *)"invalid block type"; | ||
809 | state.mode = BAD; | ||
810 | } | ||
811 | DROPBITS(2); | ||
812 | break; | ||
813 | case STORED: | ||
814 | BYTEBITS(); /* go to byte boundary */ | ||
815 | NEEDBITS(32); | ||
816 | if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { | ||
817 | strm->msg = (char *)"invalid stored block lengths"; | ||
818 | state.mode = BAD; | ||
819 | break; | ||
820 | } | ||
821 | state.length = (unsigned)hold & 0xffff; | ||
822 | //DEBUGF("inflate: stored length %u\n", | ||
823 | //state.length); | ||
824 | INITBITS(); | ||
825 | state.mode = COPY; | ||
826 | case COPY: | ||
827 | copy = state.length; | ||
828 | if (copy) { | ||
829 | if (copy > have) copy = have; | ||
830 | if (copy > left) copy = left; | ||
831 | if (copy == 0) goto inf_leave; | ||
832 | zmemcpy(put, next, copy); | ||
833 | have -= copy; | ||
834 | next += copy; | ||
835 | left -= copy; | ||
836 | put += copy; | ||
837 | state.length -= copy; | ||
838 | break; | ||
839 | } | ||
840 | //DEBUGF("inflate: stored end\n"); | ||
841 | state.mode = TYPE; | ||
842 | break; | ||
843 | case TABLE: | ||
844 | NEEDBITS(14); | ||
845 | state.nlen = BITS(5) + 257; | ||
846 | DROPBITS(5); | ||
847 | state.ndist = BITS(5) + 1; | ||
848 | DROPBITS(5); | ||
849 | state.ncode = BITS(4) + 4; | ||
850 | DROPBITS(4); | ||
851 | #ifndef PKZIP_BUG_WORKAROUND | ||
852 | if (state.nlen > 286 || state.ndist > 30) { | ||
853 | strm->msg = (char *)"too many length or distance symbols"; | ||
854 | state.mode = BAD; | ||
855 | break; | ||
856 | } | ||
857 | #endif | ||
858 | //DEBUGF("inflate: table sizes ok\n"); | ||
859 | state.have = 0; | ||
860 | state.mode = LENLENS; | ||
861 | case LENLENS: | ||
862 | while (state.have < state.ncode) { | ||
863 | NEEDBITS(3); | ||
864 | state.lens[order[state.have++]] = (unsigned short)BITS(3); | ||
865 | DROPBITS(3); | ||
866 | } | ||
867 | while (state.have < 19) | ||
868 | state.lens[order[state.have++]] = 0; | ||
869 | state.next = state.codes; | ||
870 | state.lencode = (code const FAR *)(state.next); | ||
871 | state.lenbits = 7; | ||
872 | ret = inflate_table(CODES, state.lens, 19, &(state.next), | ||
873 | &(state.lenbits), state.work); | ||
874 | if (ret) { | ||
875 | strm->msg = (char *)"invalid code lengths set"; | ||
876 | state.mode = BAD; | ||
877 | break; | ||
878 | } | ||
879 | //DEBUGF("inflate: code lengths ok\n"); | ||
880 | state.have = 0; | ||
881 | state.mode = CODELENS; | ||
882 | case CODELENS: | ||
883 | while (state.have < state.nlen + state.ndist) { | ||
884 | for (;;) { | ||
885 | this = state.lencode[BITS(state.lenbits)]; | ||
886 | if ((unsigned)(this.bits) <= bits) break; | ||
887 | PULLBYTE(); | ||
888 | } | ||
889 | if (this.val < 16) { | ||
890 | NEEDBITS(this.bits); | ||
891 | DROPBITS(this.bits); | ||
892 | state.lens[state.have++] = this.val; | ||
893 | } | ||
894 | else { | ||
895 | if (this.val == 16) { | ||
896 | NEEDBITS(this.bits + 2); | ||
897 | DROPBITS(this.bits); | ||
898 | if (state.have == 0) { | ||
899 | strm->msg = (char *)"invalid bit length repeat"; | ||
900 | state.mode = BAD; | ||
901 | break; | ||
902 | } | ||
903 | len = state.lens[state.have - 1]; | ||
904 | copy = 3 + BITS(2); | ||
905 | DROPBITS(2); | ||
906 | } | ||
907 | else if (this.val == 17) { | ||
908 | NEEDBITS(this.bits + 3); | ||
909 | DROPBITS(this.bits); | ||
910 | len = 0; | ||
911 | copy = 3 + BITS(3); | ||
912 | DROPBITS(3); | ||
913 | } | ||
914 | else { | ||
915 | NEEDBITS(this.bits + 7); | ||
916 | DROPBITS(this.bits); | ||
917 | len = 0; | ||
918 | copy = 11 + BITS(7); | ||
919 | DROPBITS(7); | ||
920 | } | ||
921 | if (state.have + copy > state.nlen + state.ndist) { | ||
922 | strm->msg = (char *)"invalid bit length repeat"; | ||
923 | state.mode = BAD; | ||
924 | break; | ||
925 | } | ||
926 | while (copy--) | ||
927 | state.lens[state.have++] = (unsigned short)len; | ||
928 | } | ||
929 | } | ||
930 | |||
931 | /* handle error breaks in while */ | ||
932 | if (state.mode == BAD) break; | ||
933 | |||
934 | /* build code tables */ | ||
935 | state.next = state.codes; | ||
936 | state.lencode = (code const FAR *)(state.next); | ||
937 | state.lenbits = 9; | ||
938 | ret = inflate_table(LENS, state.lens, state.nlen, &(state.next), | ||
939 | &(state.lenbits), state.work); | ||
940 | if (ret) { | ||
941 | strm->msg = (char *)"invalid literal/lengths set"; | ||
942 | state.mode = BAD; | ||
943 | break; | ||
944 | } | ||
945 | state.distcode = (code const FAR *)(state.next); | ||
946 | state.distbits = 6; | ||
947 | ret = inflate_table(DISTS, state.lens + state.nlen, state.ndist, | ||
948 | &(state.next), &(state.distbits), state.work); | ||
949 | if (ret) { | ||
950 | strm->msg = (char *)"invalid distances set"; | ||
951 | state.mode = BAD; | ||
952 | break; | ||
953 | } | ||
954 | //DEBUGF("inflate: codes ok\n"); | ||
955 | state.mode = LEN; | ||
956 | case LEN: | ||
957 | if (have >= 6 && left >= 258) { | ||
958 | RESTORE(); | ||
959 | inflate_fast(strm, out); | ||
960 | LOAD(); | ||
961 | break; | ||
962 | } | ||
963 | for (;;) { | ||
964 | this = state.lencode[BITS(state.lenbits)]; | ||
965 | if ((unsigned)(this.bits) <= bits) break; | ||
966 | PULLBYTE(); | ||
967 | } | ||
968 | if (this.op && (this.op & 0xf0) == 0) { | ||
969 | last = this; | ||
970 | for (;;) { | ||
971 | this = state.lencode[last.val + | ||
972 | (BITS(last.bits + last.op) >> last.bits)]; | ||
973 | if ((unsigned)(last.bits + this.bits) <= bits) break; | ||
974 | PULLBYTE(); | ||
975 | } | ||
976 | DROPBITS(last.bits); | ||
977 | } | ||
978 | DROPBITS(this.bits); | ||
979 | state.length = (unsigned)this.val; | ||
980 | if ((int)(this.op) == 0) { | ||
981 | //DEBUGF(this.val >= 0x20 && this.val < 0x7f ? | ||
982 | //"inflate: literal '%c'\n" : | ||
983 | //"inflate: literal 0x%02x\n", this.val); | ||
984 | state.mode = LIT; | ||
985 | break; | ||
986 | } | ||
987 | if (this.op & 32) { | ||
988 | //DEBUGF("inflate: end of block\n"); | ||
989 | state.mode = TYPE; | ||
990 | break; | ||
991 | } | ||
992 | if (this.op & 64) { | ||
993 | strm->msg = (char *)"invalid literal/length code"; | ||
994 | state.mode = BAD; | ||
995 | break; | ||
996 | } | ||
997 | state.extra = (unsigned)(this.op) & 15; | ||
998 | state.mode = LENEXT; | ||
999 | case LENEXT: | ||
1000 | if (state.extra) { | ||
1001 | NEEDBITS(state.extra); | ||
1002 | state.length += BITS(state.extra); | ||
1003 | DROPBITS(state.extra); | ||
1004 | } | ||
1005 | //DEBUGF("inflate: length %u\n", state.length); | ||
1006 | state.mode = DIST; | ||
1007 | case DIST: | ||
1008 | for (;;) { | ||
1009 | this = state.distcode[BITS(state.distbits)]; | ||
1010 | if ((unsigned)(this.bits) <= bits) break; | ||
1011 | PULLBYTE(); | ||
1012 | } | ||
1013 | if ((this.op & 0xf0) == 0) { | ||
1014 | last = this; | ||
1015 | for (;;) { | ||
1016 | this = state.distcode[last.val + | ||
1017 | (BITS(last.bits + last.op) >> last.bits)]; | ||
1018 | if ((unsigned)(last.bits + this.bits) <= bits) break; | ||
1019 | PULLBYTE(); | ||
1020 | } | ||
1021 | DROPBITS(last.bits); | ||
1022 | } | ||
1023 | DROPBITS(this.bits); | ||
1024 | if (this.op & 64) { | ||
1025 | strm->msg = (char *)"invalid distance code"; | ||
1026 | state.mode = BAD; | ||
1027 | break; | ||
1028 | } | ||
1029 | state.offset = (unsigned)this.val; | ||
1030 | state.extra = (unsigned)(this.op) & 15; | ||
1031 | state.mode = DISTEXT; | ||
1032 | case DISTEXT: | ||
1033 | if (state.extra) { | ||
1034 | NEEDBITS(state.extra); | ||
1035 | state.offset += BITS(state.extra); | ||
1036 | DROPBITS(state.extra); | ||
1037 | } | ||
1038 | #ifdef INFLATE_STRICT | ||
1039 | if (state.offset > state.dmax) { | ||
1040 | strm->msg = (char *)"invalid distance too far back"; | ||
1041 | state.mode = BAD; | ||
1042 | break; | ||
1043 | } | ||
1044 | #endif | ||
1045 | if (state.offset > state.whave + out - left) { | ||
1046 | strm->msg = (char *)"invalid distance too far back"; | ||
1047 | state.mode = BAD; | ||
1048 | break; | ||
1049 | } | ||
1050 | //DEBUGF("inflate: distance %u\n", state.offset); | ||
1051 | state.mode = MATCH; | ||
1052 | case MATCH: | ||
1053 | if (left == 0) goto inf_leave; | ||
1054 | copy = out - left; | ||
1055 | if (state.offset > copy) { /* copy from window */ | ||
1056 | copy = state.offset - copy; | ||
1057 | if (copy > state.write) { | ||
1058 | copy -= state.write; | ||
1059 | from = state.window + (state.wsize - copy); | ||
1060 | } | ||
1061 | else | ||
1062 | from = state.window + (state.write - copy); | ||
1063 | if (copy > state.length) copy = state.length; | ||
1064 | } | ||
1065 | else { /* copy from output */ | ||
1066 | from = put - state.offset; | ||
1067 | copy = state.length; | ||
1068 | } | ||
1069 | if (copy > left) copy = left; | ||
1070 | left -= copy; | ||
1071 | state.length -= copy; | ||
1072 | do { | ||
1073 | *put++ = *from++; | ||
1074 | } while (--copy); | ||
1075 | if (state.length == 0) state.mode = LEN; | ||
1076 | break; | ||
1077 | case LIT: | ||
1078 | if (left == 0) goto inf_leave; | ||
1079 | *put++ = (unsigned char)(state.length); | ||
1080 | left--; | ||
1081 | state.mode = LEN; | ||
1082 | break; | ||
1083 | case CHECK: | ||
1084 | if (state.wrap) { | ||
1085 | NEEDBITS(32); | ||
1086 | out -= left; | ||
1087 | strm->total_out += out; | ||
1088 | state.total += out; | ||
1089 | if (out) | ||
1090 | strm->adler = state.check = | ||
1091 | UPDATE(state.check, put - out, out); | ||
1092 | out = left; | ||
1093 | if (( | ||
1094 | #ifdef GUNZIP | ||
1095 | state.flags ? hold : | ||
1096 | #endif | ||
1097 | REVERSE(hold)) != state.check) { | ||
1098 | strm->msg = (char *)"incorrect data check"; | ||
1099 | state.mode = BAD; | ||
1100 | break; | ||
1101 | } | ||
1102 | INITBITS(); | ||
1103 | //DEBUGF("inflate: check matches trailer\n"); | ||
1104 | } | ||
1105 | #ifdef GUNZIP | ||
1106 | state.mode = LENGTH; | ||
1107 | case LENGTH: | ||
1108 | if (state.wrap && state.flags) { | ||
1109 | NEEDBITS(32); | ||
1110 | if (hold != (state.total & 0xffffffffUL)) { | ||
1111 | strm->msg = (char *)"incorrect length check"; | ||
1112 | state.mode = BAD; | ||
1113 | break; | ||
1114 | } | ||
1115 | INITBITS(); | ||
1116 | Tracev((stderr, "inflate: length matches trailer\n")); | ||
1117 | } | ||
1118 | #endif | ||
1119 | state.mode = DONE; | ||
1120 | case DONE: | ||
1121 | ret = Z_STREAM_END; | ||
1122 | goto inf_leave; | ||
1123 | case BAD: | ||
1124 | ret = Z_DATA_ERROR; | ||
1125 | goto inf_leave; | ||
1126 | case ZMEM: | ||
1127 | return Z_MEM_ERROR; | ||
1128 | case SYNC: | ||
1129 | default: | ||
1130 | return Z_STREAM_ERROR; | ||
1131 | } | ||
1132 | //DEBUGF("%d / %d\n", strm->total_in, strm->avail_in); | ||
1133 | if (rb->button_get(false) == IMGVIEW_MENU) | ||
1134 | return PLUGIN_ABORT; | ||
1135 | else cb_progress(insize - strm->avail_in, insize); | ||
1136 | } | ||
1137 | |||
1138 | /* | ||
1139 | Return from inflate(), updating the total counts and the check value. | ||
1140 | If there was no progress during the inflate() call, return a buffer | ||
1141 | error. Call updatewindow() to create and/or update the window state. | ||
1142 | Note: a memory error from inflate() is non-recoverable. | ||
1143 | */ | ||
1144 | inf_leave: | ||
1145 | RESTORE(); | ||
1146 | if (state.wsize || (state.mode < CHECK && out != strm->avail_out)) | ||
1147 | if (updatewindow(strm, out)) { | ||
1148 | state.mode = ZMEM; | ||
1149 | return Z_MEM_ERROR; | ||
1150 | } | ||
1151 | in -= strm->avail_in; | ||
1152 | out -= strm->avail_out; | ||
1153 | strm->total_in += in; | ||
1154 | strm->total_out += out; | ||
1155 | state.total += out; | ||
1156 | if (state.wrap && out) | ||
1157 | strm->adler = state.check = | ||
1158 | UPDATE(state.check, strm->next_out - out, out); | ||
1159 | strm->data_type = state.bits + (state.last ? 64 : 0) + | ||
1160 | (state.mode == TYPE ? 128 : 0); | ||
1161 | if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) | ||
1162 | ret = Z_BUF_ERROR; | ||
1163 | return ret; | ||
1164 | } | ||
1165 | |||
1166 | int ZEXPORT inflateEnd(strm) | ||
1167 | z_streamp strm; | ||
1168 | { | ||
1169 | //struct inflate_state FAR *state; | ||
1170 | if (strm == Z_NULL /*|| strm->zfree == (free_func)0*/) | ||
1171 | return Z_STREAM_ERROR; | ||
1172 | //state = (struct inflate_state FAR *)strm->state; | ||
1173 | //if (state.window != Z_NULL) ZFREE(strm, state.window); | ||
1174 | //ZFREE(strm, strm->state); | ||
1175 | //strm->state = Z_NULL; | ||
1176 | //DEBUGF("inflate: end\n"); | ||
1177 | return Z_OK; | ||
1178 | } | ||
1179 | |||
1180 | int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) | ||
1181 | z_streamp strm; | ||
1182 | const Bytef *dictionary; | ||
1183 | uInt dictLength; | ||
1184 | { | ||
1185 | //struct inflate_state FAR *state; | ||
1186 | unsigned long id; | ||
1187 | |||
1188 | /* check state */ | ||
1189 | if (strm == Z_NULL) return Z_STREAM_ERROR; | ||
1190 | //state = (struct inflate_state FAR *)strm->state; | ||
1191 | if (state.wrap != 0 && state.mode != DICT) | ||
1192 | return Z_STREAM_ERROR; | ||
1193 | |||
1194 | /* check for correct dictionary id */ | ||
1195 | if (state.mode == DICT) { | ||
1196 | id = adler32(0L, Z_NULL, 0); | ||
1197 | id = adler32(id, dictionary, dictLength); | ||
1198 | if (id != state.check) | ||
1199 | return Z_DATA_ERROR; | ||
1200 | } | ||
1201 | |||
1202 | /* copy dictionary to window */ | ||
1203 | if (updatewindow(strm, strm->avail_out)) { | ||
1204 | state.mode = ZMEM; | ||
1205 | return Z_MEM_ERROR; | ||
1206 | } | ||
1207 | if (dictLength > state.wsize) { | ||
1208 | zmemcpy(state.window, dictionary + dictLength - state.wsize, | ||
1209 | state.wsize); | ||
1210 | state.whave = state.wsize; | ||
1211 | } | ||
1212 | else { | ||
1213 | zmemcpy(state.window + state.wsize - dictLength, dictionary, | ||
1214 | dictLength); | ||
1215 | state.whave = dictLength; | ||
1216 | } | ||
1217 | state.havedict = 1; | ||
1218 | //DEBUGF("inflate: dictionary set\n"); | ||
1219 | return Z_OK; | ||
1220 | } | ||
1221 | |||
1222 | int ZEXPORT inflateGetHeader(strm, head) | ||
1223 | z_streamp strm; | ||
1224 | gz_headerp head; | ||
1225 | { | ||
1226 | //struct inflate_state FAR *state; | ||
1227 | |||
1228 | /* check state */ | ||
1229 | if (strm == Z_NULL) return Z_STREAM_ERROR; | ||
1230 | //state = (struct inflate_state FAR *)strm->state; | ||
1231 | if ((state.wrap & 2) == 0) return Z_STREAM_ERROR; | ||
1232 | |||
1233 | /* save header structure */ | ||
1234 | state.head = head; | ||
1235 | head->done = 0; | ||
1236 | return Z_OK; | ||
1237 | } | ||
1238 | |||
1239 | /* | ||
1240 | Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found | ||
1241 | or when out of input. When called, *have is the number of pattern bytes | ||
1242 | found in order so far, in 0..3. On return *have is updated to the new | ||
1243 | state. If on return *have equals four, then the pattern was found and the | ||
1244 | return value is how many bytes were read including the last byte of the | ||
1245 | pattern. If *have is less than four, then the pattern has not been found | ||
1246 | yet and the return value is len. In the latter case, syncsearch() can be | ||
1247 | called again with more data and the *have state. *have is initialized to | ||
1248 | zero for the first call. | ||
1249 | */ | ||
1250 | local unsigned syncsearch(have, buf, len) | ||
1251 | unsigned FAR *have; | ||
1252 | unsigned char FAR *buf; | ||
1253 | unsigned len; | ||
1254 | { | ||
1255 | unsigned got; | ||
1256 | unsigned next; | ||
1257 | |||
1258 | got = *have; | ||
1259 | next = 0; | ||
1260 | while (next < len && got < 4) { | ||
1261 | if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) | ||
1262 | got++; | ||
1263 | else if (buf[next]) | ||
1264 | got = 0; | ||
1265 | else | ||
1266 | got = 4 - got; | ||
1267 | next++; | ||
1268 | } | ||
1269 | *have = got; | ||
1270 | return next; | ||
1271 | } | ||
1272 | |||
1273 | int ZEXPORT inflateSync(strm) | ||
1274 | z_streamp strm; | ||
1275 | { | ||
1276 | unsigned len; /* number of bytes to look at or looked at */ | ||
1277 | unsigned long in, out; /* temporary to save total_in and total_out */ | ||
1278 | unsigned char buf[4]; /* to restore bit buffer to byte string */ | ||
1279 | //struct inflate_state FAR *state; | ||
1280 | |||
1281 | /* check parameters */ | ||
1282 | if (strm == Z_NULL) return Z_STREAM_ERROR; | ||
1283 | //state = (struct inflate_state FAR *)strm->state; | ||
1284 | if (strm->avail_in == 0 && state.bits < 8) return Z_BUF_ERROR; | ||
1285 | |||
1286 | /* if first time, start search in bit buffer */ | ||
1287 | if (state.mode != SYNC) { | ||
1288 | state.mode = SYNC; | ||
1289 | state.hold <<= state.bits & 7; | ||
1290 | state.bits -= state.bits & 7; | ||
1291 | len = 0; | ||
1292 | while (state.bits >= 8) { | ||
1293 | buf[len++] = (unsigned char)(state.hold); | ||
1294 | state.hold >>= 8; | ||
1295 | state.bits -= 8; | ||
1296 | } | ||
1297 | state.have = 0; | ||
1298 | syncsearch(&(state.have), buf, len); | ||
1299 | } | ||
1300 | |||
1301 | /* search available input */ | ||
1302 | len = syncsearch(&(state.have), strm->next_in, strm->avail_in); | ||
1303 | strm->avail_in -= len; | ||
1304 | strm->next_in += len; | ||
1305 | strm->total_in += len; | ||
1306 | |||
1307 | /* return no joy or set up to restart inflate() on a new block */ | ||
1308 | if (state.have != 4) return Z_DATA_ERROR; | ||
1309 | in = strm->total_in; out = strm->total_out; | ||
1310 | inflateReset(strm); | ||
1311 | strm->total_in = in; strm->total_out = out; | ||
1312 | state.mode = TYPE; | ||
1313 | return Z_OK; | ||
1314 | } | ||
1315 | |||
1316 | /* | ||
1317 | Returns true if inflate is currently at the end of a block generated by | ||
1318 | Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP | ||
1319 | implementation to provide an additional safety check. PPP uses | ||
1320 | Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored | ||
1321 | block. When decompressing, PPP checks that at the end of input packet, | ||
1322 | inflate is waiting for these length bytes. | ||
1323 | */ | ||
1324 | int ZEXPORT inflateSyncPoint(strm) | ||
1325 | z_streamp strm; | ||
1326 | { | ||
1327 | //struct inflate_state FAR *state; | ||
1328 | |||
1329 | if (strm == Z_NULL) return Z_STREAM_ERROR; | ||
1330 | //state = (struct inflate_state FAR *)strm->state; | ||
1331 | return state.mode == STORED && state.bits == 0; | ||
1332 | } | ||