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
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
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
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
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
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
57 * 1.2.beta5 1 Jan 2003
58 * - Improved inflateBack() interface to allow the caller to provide initial
60 * - Fixed stored blocks bug in inflateBack()
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 *
69 * 1.2.beta7 27 Jan 2003
70 * - Changed many types to unsigned or unsigned short to avoid warnings
71 * - Added inflateCopy() function
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()
80 * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
96 struct inflate_state state
;
98 /* function prototypes */
99 local
void fixedtables
OF((void));
100 local
int updatewindow
OF((z_streamp strm
, unsigned out
));
102 void makefixed
OF((void));
104 local
unsigned syncsearch
OF((unsigned FAR
*have
, unsigned char FAR
*buf
,
107 int ZEXPORT
inflateReset(strm
)
110 //struct inflate_state FAR *state;
112 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
113 //state = strm->state;
114 strm
->total_in
= strm
->total_out
= state
.total
= 0;
116 strm
->adler
= 1; /* to support ill-conceived Java test suite */
127 state
.lencode
= state
.distcode
= state
.next
= state
.codes
;
128 //DEBUGF("inflate: reset\n");
132 int ZEXPORT
inflatePrime(strm
, bits
, value
)
137 //struct inflate_state FAR *state;
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
;
148 int ZEXPORT
inflateInit2_(strm
, windowBits
, version
, stream_size
)
154 //struct inflate_state FAR *state;
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;
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) {
173 windowBits
= -windowBits
;
176 state
.wrap
= (windowBits
>> 4) + 1;
178 if (windowBits
< 48) windowBits
&= 15;
181 if (windowBits
< 8 || windowBits
> 15) {
182 //ZFREE(strm, state);
183 //strm->state = Z_NULL;
184 return Z_STREAM_ERROR
;
186 state
.wbits
= (unsigned)windowBits
;
187 state
.window
= Z_NULL
;
188 return inflateReset(strm
);
191 int ZEXPORT
inflateInit_(strm
, version
, stream_size
)
196 return inflateInit2_(strm
, DEF_WBITS
, version
, stream_size
);
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.
209 local
void fixedtables(void)
210 //struct inflate_state FAR *state;
213 static int virgin
= 1;
214 static code
*lenfix
, *distfix
;
215 static code fixed
[544];
217 /* build fixed huffman tables if first call (may not be thread safe) */
222 /* literal/length table */
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;
231 inflate_table(LENS
, state
.lens
, 288, &(next
), &(bits
), state
.work
);
235 while (sym
< 32) state
.lens
[sym
++] = 5;
238 inflate_table(DISTS
, state
.lens
, 32, &(next
), &(bits
), state
.work
);
240 /* do this just once */
243 #else /* !BUILDFIXED */
244 # include "inffixed.h"
245 #endif /* BUILDFIXED */
246 state
.lencode
= lenfix
;
248 state
.distcode
= distfix
;
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:
261 void makefixed(void);
269 Then that can be linked with zlib built with MAKEFIXED defined and run:
276 struct inflate_state state
;
279 puts(" /* inffixed.h -- table for decoding fixed codes");
280 puts(" * Generated automatically by makefixed().");
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.");
289 printf(" static const code lenfix[%u] = {", size
);
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;
300 printf("\n static const code distfix[%u] = {", size
);
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;
311 #endif /* MAKEFIXED */
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
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.
327 local
int updatewindow(strm
, out
)
331 //struct inflate_state FAR *state;
334 //state = (struct inflate_state FAR *)strm->state;
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;
344 /* if window not in use yet, initialize */
345 if (state
.wsize
== 0) {
346 state
.wsize
= 1U << state
.wbits
;
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
);
356 state
.whave
= state
.wsize
;
359 dist
= state
.wsize
- state
.write
;
360 if (dist
> copy
) dist
= copy
;
361 zmemcpy(state
.window
+ state
.write
, strm
->next_out
- copy
, dist
);
364 zmemcpy(state
.window
, strm
->next_out
- copy
, copy
);
366 state
.whave
= state
.wsize
;
370 if (state
.write
== state
.wsize
) state
.write
= 0;
371 if (state
.whave
< state
.wsize
) state
.whave
+= dist
;
377 /* Macros for inflate(): */
379 /* check function to use adler32() for zlib or crc32() for gzip */
381 # define UPDATE(check, buf, len) \
382 (state.flags ? crc32(check, buf, len) : adler32(check, buf, len))
384 # define UPDATE(check, buf, len) adler32(check, buf, len)
387 /* check macros for header crc */
389 # define CRC2(check, word) \
391 hbuf[0] = (unsigned char)(word); \
392 hbuf[1] = (unsigned char)((word) >> 8); \
393 check = crc32(check, hbuf, 2); \
396 # define CRC4(check, word) \
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); \
406 /* Load registers with state in inflate() for speed */
409 put = strm->next_out; \
410 left = strm->avail_out; \
411 next = strm->next_in; \
412 have = strm->avail_in; \
417 /* Restore state from registers in inflate() */
420 strm->next_out = put; \
421 strm->avail_out = left; \
422 strm->next_in = next; \
423 strm->avail_in = have; \
428 /* Clear the input bit accumulator */
435 /* Get a byte of input into the bit accumulator, or return from inflate()
436 if there is no input available. */
439 if (have == 0) goto inf_leave; \
441 hold += (unsigned long)(*next++) << bits; \
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) \
449 while (bits < (unsigned)(n)) \
453 /* Return the low n bits of the bit accumulator (n < 16) */
455 ((unsigned)hold & ((1U << (n)) - 1))
457 /* Remove n bits from the bit accumulator */
458 #define DROPBITS(n) \
461 bits -= (unsigned)(n); \
464 /* Remove zero to seven bits as needed to go to a byte boundary */
471 /* Reverse the bytes in a 32-bit value */
473 ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
474 (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
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:
481 for (;;) switch (state) {
484 if (not enough input data or output space to make progress)
486 ... make progress ...
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
500 ... do something with BITS(n) ...
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.
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
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()
523 while (want < need) {
525 keep[want++] = BITS(n);
531 As shown above, if the next state is also the next case, then the break
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.
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().
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.
558 extern void cb_progress(int current
, int total
);
560 int ZEXPORT
inflate(strm
, flush
)
564 //struct inflate_state FAR *state;
565 unsigned char FAR
*next
; /* next input */
566 unsigned char FAR
*put
; /* next output */
567 unsigned have
, left
; /* available input and output */
568 unsigned long hold
; /* bit buffer */
569 unsigned bits
; /* bits in bit buffer */
570 unsigned in
, out
; /* save starting available input and output */
571 unsigned copy
; /* number of stored or match bytes to copy */
572 unsigned char FAR
*from
; /* where to copy match bytes from */
573 code
this; /* current decoding table entry */
574 code last
; /* parent table entry */
575 unsigned len
; /* length to copy for repeats, bits to drop */
576 int ret
; /* return code */
578 unsigned char hbuf
[4]; /* buffer for gzip header crc calculation */
580 static const unsigned short order
[19] = /* permutation of code lengths */
581 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
583 if (strm
== Z_NULL
|| strm
->next_out
== Z_NULL
||
584 (strm
->next_in
== Z_NULL
&& strm
->avail_in
!= 0))
585 return Z_STREAM_ERROR
;
587 uInt insize
= strm
->avail_in
;
589 //state = (struct inflate_state FAR *)strm->state;
590 if (state
.mode
== TYPE
) state
.mode
= TYPEDO
; /* skip check */
596 switch (state
.mode
) {
598 if (state
.wrap
== 0) {
604 if ((state
.wrap
& 2) && hold
== 0x8b1f) { /* gzip header */
605 state
.check
= crc32(0L, Z_NULL
, 0);
606 CRC2(state
.check
, hold
);
611 state
.flags
= 0; /* expect zlib header */
612 if (state
.head
!= Z_NULL
)
613 state
.head
->done
= -1;
614 if (!(state
.wrap
& 1) || /* check if zlib header allowed */
618 ((BITS(8) << 8) + (hold
>> 8)) % 31) {
619 strm
->msg
= (char *)"incorrect header check";
623 if (BITS(4) != Z_DEFLATED
) {
624 strm
->msg
= (char *)"unknown compression method";
630 if (len
> state
.wbits
) {
631 strm
->msg
= (char *)"invalid window size";
635 state
.dmax
= 1U << len
;
636 //DEBUGF("inflate: zlib header ok\n");
637 strm
->adler
= state
.check
= adler32(0L, Z_NULL
, 0);
638 state
.mode
= hold
& 0x200 ? DICTID
: TYPE
;
644 state
.flags
= (int)(hold
);
645 if ((state
.flags
& 0xff) != Z_DEFLATED
) {
646 strm
->msg
= (char *)"unknown compression method";
650 if (state
.flags
& 0xe000) {
651 strm
->msg
= (char *)"unknown header flags set";
655 if (state
.head
!= Z_NULL
)
656 state
.head
->text
= (int)((hold
>> 8) & 1);
657 if (state
.flags
& 0x0200) CRC2(state
.check
, hold
);
662 if (state
.head
!= Z_NULL
)
663 state
.head
->time
= hold
;
664 if (state
.flags
& 0x0200) CRC4(state
.check
, hold
);
669 if (state
.head
!= Z_NULL
) {
670 state
.head
->xflags
= (int)(hold
& 0xff);
671 state
.head
->os
= (int)(hold
>> 8);
673 if (state
.flags
& 0x0200) CRC2(state
.check
, hold
);
677 if (state
.flags
& 0x0400) {
679 state
.length
= (unsigned)(hold
);
680 if (state
.head
!= Z_NULL
)
681 state
.head
->extra_len
= (unsigned)hold
;
682 if (state
.flags
& 0x0200) CRC2(state
.check
, hold
);
685 else if (state
.head
!= Z_NULL
)
686 state
.head
->extra
= Z_NULL
;
689 if (state
.flags
& 0x0400) {
691 if (copy
> have
) copy
= have
;
693 if (state
.head
!= Z_NULL
&&
694 state
.head
->extra
!= Z_NULL
) {
695 len
= state
.head
->extra_len
- state
.length
;
696 zmemcpy(state
.head
->extra
+ len
, next
,
697 len
+ copy
> state
.head
->extra_max
?
698 state
.head
->extra_max
- len
: copy
);
700 if (state
.flags
& 0x0200)
701 state
.check
= crc32(state
.check
, next
, copy
);
704 state
.length
-= copy
;
706 if (state
.length
) goto inf_leave
;
711 if (state
.flags
& 0x0800) {
712 if (have
== 0) goto inf_leave
;
715 len
= (unsigned)(next
[copy
++]);
716 if (state
.head
!= Z_NULL
&&
717 state
.head
->name
!= Z_NULL
&&
718 state
.length
< state
.head
->name_max
)
719 state
.head
->name
[state
.length
++] = len
;
720 } while (len
&& copy
< have
);
721 if (state
.flags
& 0x0200)
722 state
.check
= crc32(state
.check
, next
, copy
);
725 if (len
) goto inf_leave
;
727 else if (state
.head
!= Z_NULL
)
728 state
.head
->name
= Z_NULL
;
730 state
.mode
= COMMENT
;
732 if (state
.flags
& 0x1000) {
733 if (have
== 0) goto inf_leave
;
736 len
= (unsigned)(next
[copy
++]);
737 if (state
.head
!= Z_NULL
&&
738 state
.head
->comment
!= Z_NULL
&&
739 state
.length
< state
.head
->comm_max
)
740 state
.head
->comment
[state
.length
++] = len
;
741 } while (len
&& copy
< have
);
742 if (state
.flags
& 0x0200)
743 state
.check
= crc32(state
.check
, next
, copy
);
746 if (len
) goto inf_leave
;
748 else if (state
.head
!= Z_NULL
)
749 state
.head
->comment
= Z_NULL
;
752 if (state
.flags
& 0x0200) {
754 if (hold
!= (state
.check
& 0xffff)) {
755 strm
->msg
= (char *)"header crc mismatch";
761 if (state
.head
!= Z_NULL
) {
762 state
.head
->hcrc
= (int)((state
.flags
>> 9) & 1);
763 state
.head
->done
= 1;
765 strm
->adler
= state
.check
= crc32(0L, Z_NULL
, 0);
771 strm
->adler
= state
.check
= REVERSE(hold
);
775 if (state
.havedict
== 0) {
779 strm
->adler
= state
.check
= adler32(0L, Z_NULL
, 0);
782 if (flush
== Z_BLOCK
) goto inf_leave
;
790 state
.last
= BITS(1);
793 case 0: /* stored block */
794 //DEBUGF("inflate: stored block%s\n",
795 //state.last ? " (last)" : "");
798 case 1: /* fixed block */
800 //DEBUGF("inflate: fixed codes block%s\n",
801 //state.last ? " (last)" : "");
802 state
.mode
= LEN
; /* decode codes */
804 case 2: /* dynamic block */
805 //DEBUGF("inflate: dynamic codes block%s\n",
806 //state.last ? " (last)" : "");
810 strm
->msg
= (char *)"invalid block type";
816 BYTEBITS(); /* go to byte boundary */
818 if ((hold
& 0xffff) != ((hold
>> 16) ^ 0xffff)) {
819 strm
->msg
= (char *)"invalid stored block lengths";
823 state
.length
= (unsigned)hold
& 0xffff;
824 //DEBUGF("inflate: stored length %u\n",
831 if (copy
> have
) copy
= have
;
832 if (copy
> left
) copy
= left
;
833 if (copy
== 0) goto inf_leave
;
834 zmemcpy(put
, next
, copy
);
839 state
.length
-= copy
;
842 //DEBUGF("inflate: stored end\n");
847 state
.nlen
= BITS(5) + 257;
849 state
.ndist
= BITS(5) + 1;
851 state
.ncode
= BITS(4) + 4;
853 #ifndef PKZIP_BUG_WORKAROUND
854 if (state
.nlen
> 286 || state
.ndist
> 30) {
855 strm
->msg
= (char *)"too many length or distance symbols";
860 //DEBUGF("inflate: table sizes ok\n");
862 state
.mode
= LENLENS
;
864 while (state
.have
< state
.ncode
) {
866 state
.lens
[order
[state
.have
++]] = (unsigned short)BITS(3);
869 while (state
.have
< 19)
870 state
.lens
[order
[state
.have
++]] = 0;
871 state
.next
= state
.codes
;
872 state
.lencode
= (code
const FAR
*)(state
.next
);
874 ret
= inflate_table(CODES
, state
.lens
, 19, &(state
.next
),
875 &(state
.lenbits
), state
.work
);
877 strm
->msg
= (char *)"invalid code lengths set";
881 //DEBUGF("inflate: code lengths ok\n");
883 state
.mode
= CODELENS
;
885 while (state
.have
< state
.nlen
+ state
.ndist
) {
887 this = state
.lencode
[BITS(state
.lenbits
)];
888 if ((unsigned)(this.bits
) <= bits
) break;
894 state
.lens
[state
.have
++] = this.val
;
897 if (this.val
== 16) {
898 NEEDBITS(this.bits
+ 2);
900 if (state
.have
== 0) {
901 strm
->msg
= (char *)"invalid bit length repeat";
905 len
= state
.lens
[state
.have
- 1];
909 else if (this.val
== 17) {
910 NEEDBITS(this.bits
+ 3);
917 NEEDBITS(this.bits
+ 7);
923 if (state
.have
+ copy
> state
.nlen
+ state
.ndist
) {
924 strm
->msg
= (char *)"invalid bit length repeat";
929 state
.lens
[state
.have
++] = (unsigned short)len
;
933 /* handle error breaks in while */
934 if (state
.mode
== BAD
) break;
936 /* build code tables */
937 state
.next
= state
.codes
;
938 state
.lencode
= (code
const FAR
*)(state
.next
);
940 ret
= inflate_table(LENS
, state
.lens
, state
.nlen
, &(state
.next
),
941 &(state
.lenbits
), state
.work
);
943 strm
->msg
= (char *)"invalid literal/lengths set";
947 state
.distcode
= (code
const FAR
*)(state
.next
);
949 ret
= inflate_table(DISTS
, state
.lens
+ state
.nlen
, state
.ndist
,
950 &(state
.next
), &(state
.distbits
), state
.work
);
952 strm
->msg
= (char *)"invalid distances set";
956 //DEBUGF("inflate: codes ok\n");
959 if (have
>= 6 && left
>= 258) {
961 inflate_fast(strm
, out
);
966 this = state
.lencode
[BITS(state
.lenbits
)];
967 if ((unsigned)(this.bits
) <= bits
) break;
970 if (this.op
&& (this.op
& 0xf0) == 0) {
973 this = state
.lencode
[last
.val
+
974 (BITS(last
.bits
+ last
.op
) >> last
.bits
)];
975 if ((unsigned)(last
.bits
+ this.bits
) <= bits
) break;
981 state
.length
= (unsigned)this.val
;
982 if ((int)(this.op
) == 0) {
983 //DEBUGF(this.val >= 0x20 && this.val < 0x7f ?
984 //"inflate: literal '%c'\n" :
985 //"inflate: literal 0x%02x\n", this.val);
990 //DEBUGF("inflate: end of block\n");
995 strm
->msg
= (char *)"invalid literal/length code";
999 state
.extra
= (unsigned)(this.op
) & 15;
1000 state
.mode
= LENEXT
;
1003 NEEDBITS(state
.extra
);
1004 state
.length
+= BITS(state
.extra
);
1005 DROPBITS(state
.extra
);
1007 //DEBUGF("inflate: length %u\n", state.length);
1011 this = state
.distcode
[BITS(state
.distbits
)];
1012 if ((unsigned)(this.bits
) <= bits
) break;
1015 if ((this.op
& 0xf0) == 0) {
1018 this = state
.distcode
[last
.val
+
1019 (BITS(last
.bits
+ last
.op
) >> last
.bits
)];
1020 if ((unsigned)(last
.bits
+ this.bits
) <= bits
) break;
1023 DROPBITS(last
.bits
);
1025 DROPBITS(this.bits
);
1027 strm
->msg
= (char *)"invalid distance code";
1031 state
.offset
= (unsigned)this.val
;
1032 state
.extra
= (unsigned)(this.op
) & 15;
1033 state
.mode
= DISTEXT
;
1036 NEEDBITS(state
.extra
);
1037 state
.offset
+= BITS(state
.extra
);
1038 DROPBITS(state
.extra
);
1040 #ifdef INFLATE_STRICT
1041 if (state
.offset
> state
.dmax
) {
1042 strm
->msg
= (char *)"invalid distance too far back";
1047 if (state
.offset
> state
.whave
+ out
- left
) {
1048 strm
->msg
= (char *)"invalid distance too far back";
1052 //DEBUGF("inflate: distance %u\n", state.offset);
1055 if (left
== 0) goto inf_leave
;
1057 if (state
.offset
> copy
) { /* copy from window */
1058 copy
= state
.offset
- copy
;
1059 if (copy
> state
.write
) {
1060 copy
-= state
.write
;
1061 from
= state
.window
+ (state
.wsize
- copy
);
1064 from
= state
.window
+ (state
.write
- copy
);
1065 if (copy
> state
.length
) copy
= state
.length
;
1067 else { /* copy from output */
1068 from
= put
- state
.offset
;
1069 copy
= state
.length
;
1071 if (copy
> left
) copy
= left
;
1073 state
.length
-= copy
;
1077 if (state
.length
== 0) state
.mode
= LEN
;
1080 if (left
== 0) goto inf_leave
;
1081 *put
++ = (unsigned char)(state
.length
);
1089 strm
->total_out
+= out
;
1092 strm
->adler
= state
.check
=
1093 UPDATE(state
.check
, put
- out
, out
);
1097 state
.flags
? hold
:
1099 REVERSE(hold
)) != state
.check
) {
1100 strm
->msg
= (char *)"incorrect data check";
1105 //DEBUGF("inflate: check matches trailer\n");
1108 state
.mode
= LENGTH
;
1110 if (state
.wrap
&& state
.flags
) {
1112 if (hold
!= (state
.total
& 0xffffffffUL
)) {
1113 strm
->msg
= (char *)"incorrect length check";
1118 Tracev((stderr
, "inflate: length matches trailer\n"));
1132 return Z_STREAM_ERROR
;
1134 //DEBUGF("%d / %d\n", strm->total_in, strm->avail_in);
1135 if (rb
->button_get(false) == PNG_MENU
)
1136 return PLUGIN_ABORT
;
1137 else cb_progress(insize
- strm
->avail_in
, insize
);
1141 Return from inflate(), updating the total counts and the check value.
1142 If there was no progress during the inflate() call, return a buffer
1143 error. Call updatewindow() to create and/or update the window state.
1144 Note: a memory error from inflate() is non-recoverable.
1148 if (state
.wsize
|| (state
.mode
< CHECK
&& out
!= strm
->avail_out
))
1149 if (updatewindow(strm
, out
)) {
1153 in
-= strm
->avail_in
;
1154 out
-= strm
->avail_out
;
1155 strm
->total_in
+= in
;
1156 strm
->total_out
+= out
;
1158 if (state
.wrap
&& out
)
1159 strm
->adler
= state
.check
=
1160 UPDATE(state
.check
, strm
->next_out
- out
, out
);
1161 strm
->data_type
= state
.bits
+ (state
.last
? 64 : 0) +
1162 (state
.mode
== TYPE
? 128 : 0);
1163 if (((in
== 0 && out
== 0) || flush
== Z_FINISH
) && ret
== Z_OK
)
1168 int ZEXPORT
inflateEnd(strm
)
1171 //struct inflate_state FAR *state;
1172 if (strm
== Z_NULL
/*|| strm->zfree == (free_func)0*/)
1173 return Z_STREAM_ERROR
;
1174 //state = (struct inflate_state FAR *)strm->state;
1175 //if (state.window != Z_NULL) ZFREE(strm, state.window);
1176 //ZFREE(strm, strm->state);
1177 //strm->state = Z_NULL;
1178 //DEBUGF("inflate: end\n");
1182 int ZEXPORT
inflateSetDictionary(strm
, dictionary
, dictLength
)
1184 const Bytef
*dictionary
;
1187 //struct inflate_state FAR *state;
1191 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
1192 //state = (struct inflate_state FAR *)strm->state;
1193 if (state
.wrap
!= 0 && state
.mode
!= DICT
)
1194 return Z_STREAM_ERROR
;
1196 /* check for correct dictionary id */
1197 if (state
.mode
== DICT
) {
1198 id
= adler32(0L, Z_NULL
, 0);
1199 id
= adler32(id
, dictionary
, dictLength
);
1200 if (id
!= state
.check
)
1201 return Z_DATA_ERROR
;
1204 /* copy dictionary to window */
1205 if (updatewindow(strm
, strm
->avail_out
)) {
1209 if (dictLength
> state
.wsize
) {
1210 zmemcpy(state
.window
, dictionary
+ dictLength
- state
.wsize
,
1212 state
.whave
= state
.wsize
;
1215 zmemcpy(state
.window
+ state
.wsize
- dictLength
, dictionary
,
1217 state
.whave
= dictLength
;
1220 //DEBUGF("inflate: dictionary set\n");
1224 int ZEXPORT
inflateGetHeader(strm
, head
)
1228 //struct inflate_state FAR *state;
1231 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
1232 //state = (struct inflate_state FAR *)strm->state;
1233 if ((state
.wrap
& 2) == 0) return Z_STREAM_ERROR
;
1235 /* save header structure */
1242 Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
1243 or when out of input. When called, *have is the number of pattern bytes
1244 found in order so far, in 0..3. On return *have is updated to the new
1245 state. If on return *have equals four, then the pattern was found and the
1246 return value is how many bytes were read including the last byte of the
1247 pattern. If *have is less than four, then the pattern has not been found
1248 yet and the return value is len. In the latter case, syncsearch() can be
1249 called again with more data and the *have state. *have is initialized to
1250 zero for the first call.
1252 local
unsigned syncsearch(have
, buf
, len
)
1254 unsigned char FAR
*buf
;
1262 while (next
< len
&& got
< 4) {
1263 if ((int)(buf
[next
]) == (got
< 2 ? 0 : 0xff))
1275 int ZEXPORT
inflateSync(strm
)
1278 unsigned len
; /* number of bytes to look at or looked at */
1279 unsigned long in
, out
; /* temporary to save total_in and total_out */
1280 unsigned char buf
[4]; /* to restore bit buffer to byte string */
1281 //struct inflate_state FAR *state;
1283 /* check parameters */
1284 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
1285 //state = (struct inflate_state FAR *)strm->state;
1286 if (strm
->avail_in
== 0 && state
.bits
< 8) return Z_BUF_ERROR
;
1288 /* if first time, start search in bit buffer */
1289 if (state
.mode
!= SYNC
) {
1291 state
.hold
<<= state
.bits
& 7;
1292 state
.bits
-= state
.bits
& 7;
1294 while (state
.bits
>= 8) {
1295 buf
[len
++] = (unsigned char)(state
.hold
);
1300 syncsearch(&(state
.have
), buf
, len
);
1303 /* search available input */
1304 len
= syncsearch(&(state
.have
), strm
->next_in
, strm
->avail_in
);
1305 strm
->avail_in
-= len
;
1306 strm
->next_in
+= len
;
1307 strm
->total_in
+= len
;
1309 /* return no joy or set up to restart inflate() on a new block */
1310 if (state
.have
!= 4) return Z_DATA_ERROR
;
1311 in
= strm
->total_in
; out
= strm
->total_out
;
1313 strm
->total_in
= in
; strm
->total_out
= out
;
1319 Returns true if inflate is currently at the end of a block generated by
1320 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
1321 implementation to provide an additional safety check. PPP uses
1322 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
1323 block. When decompressing, PPP checks that at the end of input packet,
1324 inflate is waiting for these length bytes.
1326 int ZEXPORT
inflateSyncPoint(strm
)
1329 //struct inflate_state FAR *state;
1331 if (strm
== Z_NULL
) return Z_STREAM_ERROR
;
1332 //state = (struct inflate_state FAR *)strm->state;
1333 return state
.mode
== STORED
&& state
.bits
== 0;