PM: sleep: core: Switch back to async_schedule_dev()
[linux/fpc-iii.git] / lib / zlib_inflate / inflate.c
blob48f14cd58c77647d20e60ba9b5fc0ac81198254c
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
5 * Based on zlib 1.2.3 but modified for the Linux Kernel by
6 * Richard Purdie <richard@openedhand.com>
8 * Changes mainly for static instead of dynamic memory allocation
12 #include <linux/zutil.h>
13 #include "inftrees.h"
14 #include "inflate.h"
15 #include "inffast.h"
16 #include "infutil.h"
18 int zlib_inflate_workspacesize(void)
20 return sizeof(struct inflate_workspace);
23 int zlib_inflateReset(z_streamp strm)
25 struct inflate_state *state;
27 if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
28 state = (struct inflate_state *)strm->state;
29 strm->total_in = strm->total_out = state->total = 0;
30 strm->msg = NULL;
31 strm->adler = 1; /* to support ill-conceived Java test suite */
32 state->mode = HEAD;
33 state->last = 0;
34 state->havedict = 0;
35 state->dmax = 32768U;
36 state->hold = 0;
37 state->bits = 0;
38 state->lencode = state->distcode = state->next = state->codes;
40 /* Initialise Window */
41 state->wsize = 1U << state->wbits;
42 state->write = 0;
43 state->whave = 0;
45 return Z_OK;
48 int zlib_inflateInit2(z_streamp strm, int windowBits)
50 struct inflate_state *state;
52 if (strm == NULL) return Z_STREAM_ERROR;
53 strm->msg = NULL; /* in case we return an error */
55 state = &WS(strm)->inflate_state;
56 strm->state = (struct internal_state *)state;
58 if (windowBits < 0) {
59 state->wrap = 0;
60 windowBits = -windowBits;
62 else {
63 state->wrap = (windowBits >> 4) + 1;
65 if (windowBits < 8 || windowBits > 15) {
66 return Z_STREAM_ERROR;
68 state->wbits = (unsigned)windowBits;
69 state->window = &WS(strm)->working_window[0];
71 return zlib_inflateReset(strm);
75 Return state with length and distance decoding tables and index sizes set to
76 fixed code decoding. This returns fixed tables from inffixed.h.
78 static void zlib_fixedtables(struct inflate_state *state)
80 # include "inffixed.h"
81 state->lencode = lenfix;
82 state->lenbits = 9;
83 state->distcode = distfix;
84 state->distbits = 5;
89 Update the window with the last wsize (normally 32K) bytes written before
90 returning. This is only called when a window is already in use, or when
91 output has been written during this inflate call, but the end of the deflate
92 stream has not been reached yet. It is also called to window dictionary data
93 when a dictionary is loaded.
95 Providing output buffers larger than 32K to inflate() should provide a speed
96 advantage, since only the last 32K of output is copied to the sliding window
97 upon return from inflate(), and since all distances after the first 32K of
98 output will fall in the output data, making match copies simpler and faster.
99 The advantage may be dependent on the size of the processor's data caches.
101 static void zlib_updatewindow(z_streamp strm, unsigned out)
103 struct inflate_state *state;
104 unsigned copy, dist;
106 state = (struct inflate_state *)strm->state;
108 /* copy state->wsize or less output bytes into the circular window */
109 copy = out - strm->avail_out;
110 if (copy >= state->wsize) {
111 memcpy(state->window, strm->next_out - state->wsize, state->wsize);
112 state->write = 0;
113 state->whave = state->wsize;
115 else {
116 dist = state->wsize - state->write;
117 if (dist > copy) dist = copy;
118 memcpy(state->window + state->write, strm->next_out - copy, dist);
119 copy -= dist;
120 if (copy) {
121 memcpy(state->window, strm->next_out - copy, copy);
122 state->write = copy;
123 state->whave = state->wsize;
125 else {
126 state->write += dist;
127 if (state->write == state->wsize) state->write = 0;
128 if (state->whave < state->wsize) state->whave += dist;
135 * At the end of a Deflate-compressed PPP packet, we expect to have seen
136 * a `stored' block type value but not the (zero) length bytes.
139 Returns true if inflate is currently at the end of a block generated by
140 Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
141 implementation to provide an additional safety check. PPP uses
142 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
143 block. When decompressing, PPP checks that at the end of input packet,
144 inflate is waiting for these length bytes.
146 static int zlib_inflateSyncPacket(z_streamp strm)
148 struct inflate_state *state;
150 if (strm == NULL || strm->state == NULL) return Z_STREAM_ERROR;
151 state = (struct inflate_state *)strm->state;
153 if (state->mode == STORED && state->bits == 0) {
154 state->mode = TYPE;
155 return Z_OK;
157 return Z_DATA_ERROR;
160 /* Macros for inflate(): */
162 /* check function to use adler32() for zlib or crc32() for gzip */
163 #define UPDATE(check, buf, len) zlib_adler32(check, buf, len)
165 /* Load registers with state in inflate() for speed */
166 #define LOAD() \
167 do { \
168 put = strm->next_out; \
169 left = strm->avail_out; \
170 next = strm->next_in; \
171 have = strm->avail_in; \
172 hold = state->hold; \
173 bits = state->bits; \
174 } while (0)
176 /* Restore state from registers in inflate() */
177 #define RESTORE() \
178 do { \
179 strm->next_out = put; \
180 strm->avail_out = left; \
181 strm->next_in = next; \
182 strm->avail_in = have; \
183 state->hold = hold; \
184 state->bits = bits; \
185 } while (0)
187 /* Clear the input bit accumulator */
188 #define INITBITS() \
189 do { \
190 hold = 0; \
191 bits = 0; \
192 } while (0)
194 /* Get a byte of input into the bit accumulator, or return from inflate()
195 if there is no input available. */
196 #define PULLBYTE() \
197 do { \
198 if (have == 0) goto inf_leave; \
199 have--; \
200 hold += (unsigned long)(*next++) << bits; \
201 bits += 8; \
202 } while (0)
204 /* Assure that there are at least n bits in the bit accumulator. If there is
205 not enough available input to do that, then return from inflate(). */
206 #define NEEDBITS(n) \
207 do { \
208 while (bits < (unsigned)(n)) \
209 PULLBYTE(); \
210 } while (0)
212 /* Return the low n bits of the bit accumulator (n < 16) */
213 #define BITS(n) \
214 ((unsigned)hold & ((1U << (n)) - 1))
216 /* Remove n bits from the bit accumulator */
217 #define DROPBITS(n) \
218 do { \
219 hold >>= (n); \
220 bits -= (unsigned)(n); \
221 } while (0)
223 /* Remove zero to seven bits as needed to go to a byte boundary */
224 #define BYTEBITS() \
225 do { \
226 hold >>= bits & 7; \
227 bits -= bits & 7; \
228 } while (0)
230 /* Reverse the bytes in a 32-bit value */
231 #define REVERSE(q) \
232 ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
233 (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
236 inflate() uses a state machine to process as much input data and generate as
237 much output data as possible before returning. The state machine is
238 structured roughly as follows:
240 for (;;) switch (state) {
242 case STATEn:
243 if (not enough input data or output space to make progress)
244 return;
245 ... make progress ...
246 state = STATEm;
247 break;
251 so when inflate() is called again, the same case is attempted again, and
252 if the appropriate resources are provided, the machine proceeds to the
253 next state. The NEEDBITS() macro is usually the way the state evaluates
254 whether it can proceed or should return. NEEDBITS() does the return if
255 the requested bits are not available. The typical use of the BITS macros
258 NEEDBITS(n);
259 ... do something with BITS(n) ...
260 DROPBITS(n);
262 where NEEDBITS(n) either returns from inflate() if there isn't enough
263 input left to load n bits into the accumulator, or it continues. BITS(n)
264 gives the low n bits in the accumulator. When done, DROPBITS(n) drops
265 the low n bits off the accumulator. INITBITS() clears the accumulator
266 and sets the number of available bits to zero. BYTEBITS() discards just
267 enough bits to put the accumulator on a byte boundary. After BYTEBITS()
268 and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
270 NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
271 if there is no input available. The decoding of variable length codes uses
272 PULLBYTE() directly in order to pull just enough bytes to decode the next
273 code, and no more.
275 Some states loop until they get enough input, making sure that enough
276 state information is maintained to continue the loop where it left off
277 if NEEDBITS() returns in the loop. For example, want, need, and keep
278 would all have to actually be part of the saved state in case NEEDBITS()
279 returns:
281 case STATEw:
282 while (want < need) {
283 NEEDBITS(n);
284 keep[want++] = BITS(n);
285 DROPBITS(n);
287 state = STATEx;
288 case STATEx:
290 As shown above, if the next state is also the next case, then the break
291 is omitted.
293 A state may also return if there is not enough output space available to
294 complete that state. Those states are copying stored data, writing a
295 literal byte, and copying a matching string.
297 When returning, a "goto inf_leave" is used to update the total counters,
298 update the check value, and determine whether any progress has been made
299 during that inflate() call in order to return the proper return code.
300 Progress is defined as a change in either strm->avail_in or strm->avail_out.
301 When there is a window, goto inf_leave will update the window with the last
302 output written. If a goto inf_leave occurs in the middle of decompression
303 and there is no window currently, goto inf_leave will create one and copy
304 output to the window for the next call of inflate().
306 In this implementation, the flush parameter of inflate() only affects the
307 return code (per zlib.h). inflate() always writes as much as possible to
308 strm->next_out, given the space available and the provided input--the effect
309 documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
310 the allocation of and copying into a sliding window until necessary, which
311 provides the effect documented in zlib.h for Z_FINISH when the entire input
312 stream available. So the only thing the flush parameter actually does is:
313 when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
314 will return Z_BUF_ERROR if it has not reached the end of the stream.
317 int zlib_inflate(z_streamp strm, int flush)
319 struct inflate_state *state;
320 const unsigned char *next; /* next input */
321 unsigned char *put; /* next output */
322 unsigned have, left; /* available input and output */
323 unsigned long hold; /* bit buffer */
324 unsigned bits; /* bits in bit buffer */
325 unsigned in, out; /* save starting available input and output */
326 unsigned copy; /* number of stored or match bytes to copy */
327 unsigned char *from; /* where to copy match bytes from */
328 code this; /* current decoding table entry */
329 code last; /* parent table entry */
330 unsigned len; /* length to copy for repeats, bits to drop */
331 int ret; /* return code */
332 static const unsigned short order[19] = /* permutation of code lengths */
333 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
335 /* Do not check for strm->next_out == NULL here as ppc zImage
336 inflates to strm->next_out = 0 */
338 if (strm == NULL || strm->state == NULL ||
339 (strm->next_in == NULL && strm->avail_in != 0))
340 return Z_STREAM_ERROR;
342 state = (struct inflate_state *)strm->state;
344 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
345 LOAD();
346 in = have;
347 out = left;
348 ret = Z_OK;
349 for (;;)
350 switch (state->mode) {
351 case HEAD:
352 if (state->wrap == 0) {
353 state->mode = TYPEDO;
354 break;
356 NEEDBITS(16);
357 if (
358 ((BITS(8) << 8) + (hold >> 8)) % 31) {
359 strm->msg = (char *)"incorrect header check";
360 state->mode = BAD;
361 break;
363 if (BITS(4) != Z_DEFLATED) {
364 strm->msg = (char *)"unknown compression method";
365 state->mode = BAD;
366 break;
368 DROPBITS(4);
369 len = BITS(4) + 8;
370 if (len > state->wbits) {
371 strm->msg = (char *)"invalid window size";
372 state->mode = BAD;
373 break;
375 state->dmax = 1U << len;
376 strm->adler = state->check = zlib_adler32(0L, NULL, 0);
377 state->mode = hold & 0x200 ? DICTID : TYPE;
378 INITBITS();
379 break;
380 case DICTID:
381 NEEDBITS(32);
382 strm->adler = state->check = REVERSE(hold);
383 INITBITS();
384 state->mode = DICT;
385 /* fall through */
386 case DICT:
387 if (state->havedict == 0) {
388 RESTORE();
389 return Z_NEED_DICT;
391 strm->adler = state->check = zlib_adler32(0L, NULL, 0);
392 state->mode = TYPE;
393 /* fall through */
394 case TYPE:
395 if (flush == Z_BLOCK) goto inf_leave;
396 /* fall through */
397 case TYPEDO:
398 if (state->last) {
399 BYTEBITS();
400 state->mode = CHECK;
401 break;
403 NEEDBITS(3);
404 state->last = BITS(1);
405 DROPBITS(1);
406 switch (BITS(2)) {
407 case 0: /* stored block */
408 state->mode = STORED;
409 break;
410 case 1: /* fixed block */
411 zlib_fixedtables(state);
412 state->mode = LEN; /* decode codes */
413 break;
414 case 2: /* dynamic block */
415 state->mode = TABLE;
416 break;
417 case 3:
418 strm->msg = (char *)"invalid block type";
419 state->mode = BAD;
421 DROPBITS(2);
422 break;
423 case STORED:
424 BYTEBITS(); /* go to byte boundary */
425 NEEDBITS(32);
426 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
427 strm->msg = (char *)"invalid stored block lengths";
428 state->mode = BAD;
429 break;
431 state->length = (unsigned)hold & 0xffff;
432 INITBITS();
433 state->mode = COPY;
434 /* fall through */
435 case COPY:
436 copy = state->length;
437 if (copy) {
438 if (copy > have) copy = have;
439 if (copy > left) copy = left;
440 if (copy == 0) goto inf_leave;
441 memcpy(put, next, copy);
442 have -= copy;
443 next += copy;
444 left -= copy;
445 put += copy;
446 state->length -= copy;
447 break;
449 state->mode = TYPE;
450 break;
451 case TABLE:
452 NEEDBITS(14);
453 state->nlen = BITS(5) + 257;
454 DROPBITS(5);
455 state->ndist = BITS(5) + 1;
456 DROPBITS(5);
457 state->ncode = BITS(4) + 4;
458 DROPBITS(4);
459 #ifndef PKZIP_BUG_WORKAROUND
460 if (state->nlen > 286 || state->ndist > 30) {
461 strm->msg = (char *)"too many length or distance symbols";
462 state->mode = BAD;
463 break;
465 #endif
466 state->have = 0;
467 state->mode = LENLENS;
468 /* fall through */
469 case LENLENS:
470 while (state->have < state->ncode) {
471 NEEDBITS(3);
472 state->lens[order[state->have++]] = (unsigned short)BITS(3);
473 DROPBITS(3);
475 while (state->have < 19)
476 state->lens[order[state->have++]] = 0;
477 state->next = state->codes;
478 state->lencode = (code const *)(state->next);
479 state->lenbits = 7;
480 ret = zlib_inflate_table(CODES, state->lens, 19, &(state->next),
481 &(state->lenbits), state->work);
482 if (ret) {
483 strm->msg = (char *)"invalid code lengths set";
484 state->mode = BAD;
485 break;
487 state->have = 0;
488 state->mode = CODELENS;
489 /* fall through */
490 case CODELENS:
491 while (state->have < state->nlen + state->ndist) {
492 for (;;) {
493 this = state->lencode[BITS(state->lenbits)];
494 if ((unsigned)(this.bits) <= bits) break;
495 PULLBYTE();
497 if (this.val < 16) {
498 NEEDBITS(this.bits);
499 DROPBITS(this.bits);
500 state->lens[state->have++] = this.val;
502 else {
503 if (this.val == 16) {
504 NEEDBITS(this.bits + 2);
505 DROPBITS(this.bits);
506 if (state->have == 0) {
507 strm->msg = (char *)"invalid bit length repeat";
508 state->mode = BAD;
509 break;
511 len = state->lens[state->have - 1];
512 copy = 3 + BITS(2);
513 DROPBITS(2);
515 else if (this.val == 17) {
516 NEEDBITS(this.bits + 3);
517 DROPBITS(this.bits);
518 len = 0;
519 copy = 3 + BITS(3);
520 DROPBITS(3);
522 else {
523 NEEDBITS(this.bits + 7);
524 DROPBITS(this.bits);
525 len = 0;
526 copy = 11 + BITS(7);
527 DROPBITS(7);
529 if (state->have + copy > state->nlen + state->ndist) {
530 strm->msg = (char *)"invalid bit length repeat";
531 state->mode = BAD;
532 break;
534 while (copy--)
535 state->lens[state->have++] = (unsigned short)len;
539 /* handle error breaks in while */
540 if (state->mode == BAD) break;
542 /* build code tables */
543 state->next = state->codes;
544 state->lencode = (code const *)(state->next);
545 state->lenbits = 9;
546 ret = zlib_inflate_table(LENS, state->lens, state->nlen, &(state->next),
547 &(state->lenbits), state->work);
548 if (ret) {
549 strm->msg = (char *)"invalid literal/lengths set";
550 state->mode = BAD;
551 break;
553 state->distcode = (code const *)(state->next);
554 state->distbits = 6;
555 ret = zlib_inflate_table(DISTS, state->lens + state->nlen, state->ndist,
556 &(state->next), &(state->distbits), state->work);
557 if (ret) {
558 strm->msg = (char *)"invalid distances set";
559 state->mode = BAD;
560 break;
562 state->mode = LEN;
563 /* fall through */
564 case LEN:
565 if (have >= 6 && left >= 258) {
566 RESTORE();
567 inflate_fast(strm, out);
568 LOAD();
569 break;
571 for (;;) {
572 this = state->lencode[BITS(state->lenbits)];
573 if ((unsigned)(this.bits) <= bits) break;
574 PULLBYTE();
576 if (this.op && (this.op & 0xf0) == 0) {
577 last = this;
578 for (;;) {
579 this = state->lencode[last.val +
580 (BITS(last.bits + last.op) >> last.bits)];
581 if ((unsigned)(last.bits + this.bits) <= bits) break;
582 PULLBYTE();
584 DROPBITS(last.bits);
586 DROPBITS(this.bits);
587 state->length = (unsigned)this.val;
588 if ((int)(this.op) == 0) {
589 state->mode = LIT;
590 break;
592 if (this.op & 32) {
593 state->mode = TYPE;
594 break;
596 if (this.op & 64) {
597 strm->msg = (char *)"invalid literal/length code";
598 state->mode = BAD;
599 break;
601 state->extra = (unsigned)(this.op) & 15;
602 state->mode = LENEXT;
603 /* fall through */
604 case LENEXT:
605 if (state->extra) {
606 NEEDBITS(state->extra);
607 state->length += BITS(state->extra);
608 DROPBITS(state->extra);
610 state->mode = DIST;
611 /* fall through */
612 case DIST:
613 for (;;) {
614 this = state->distcode[BITS(state->distbits)];
615 if ((unsigned)(this.bits) <= bits) break;
616 PULLBYTE();
618 if ((this.op & 0xf0) == 0) {
619 last = this;
620 for (;;) {
621 this = state->distcode[last.val +
622 (BITS(last.bits + last.op) >> last.bits)];
623 if ((unsigned)(last.bits + this.bits) <= bits) break;
624 PULLBYTE();
626 DROPBITS(last.bits);
628 DROPBITS(this.bits);
629 if (this.op & 64) {
630 strm->msg = (char *)"invalid distance code";
631 state->mode = BAD;
632 break;
634 state->offset = (unsigned)this.val;
635 state->extra = (unsigned)(this.op) & 15;
636 state->mode = DISTEXT;
637 /* fall through */
638 case DISTEXT:
639 if (state->extra) {
640 NEEDBITS(state->extra);
641 state->offset += BITS(state->extra);
642 DROPBITS(state->extra);
644 #ifdef INFLATE_STRICT
645 if (state->offset > state->dmax) {
646 strm->msg = (char *)"invalid distance too far back";
647 state->mode = BAD;
648 break;
650 #endif
651 if (state->offset > state->whave + out - left) {
652 strm->msg = (char *)"invalid distance too far back";
653 state->mode = BAD;
654 break;
656 state->mode = MATCH;
657 /* fall through */
658 case MATCH:
659 if (left == 0) goto inf_leave;
660 copy = out - left;
661 if (state->offset > copy) { /* copy from window */
662 copy = state->offset - copy;
663 if (copy > state->write) {
664 copy -= state->write;
665 from = state->window + (state->wsize - copy);
667 else
668 from = state->window + (state->write - copy);
669 if (copy > state->length) copy = state->length;
671 else { /* copy from output */
672 from = put - state->offset;
673 copy = state->length;
675 if (copy > left) copy = left;
676 left -= copy;
677 state->length -= copy;
678 do {
679 *put++ = *from++;
680 } while (--copy);
681 if (state->length == 0) state->mode = LEN;
682 break;
683 case LIT:
684 if (left == 0) goto inf_leave;
685 *put++ = (unsigned char)(state->length);
686 left--;
687 state->mode = LEN;
688 break;
689 case CHECK:
690 if (state->wrap) {
691 NEEDBITS(32);
692 out -= left;
693 strm->total_out += out;
694 state->total += out;
695 if (out)
696 strm->adler = state->check =
697 UPDATE(state->check, put - out, out);
698 out = left;
699 if ((
700 REVERSE(hold)) != state->check) {
701 strm->msg = (char *)"incorrect data check";
702 state->mode = BAD;
703 break;
705 INITBITS();
707 state->mode = DONE;
708 /* fall through */
709 case DONE:
710 ret = Z_STREAM_END;
711 goto inf_leave;
712 case BAD:
713 ret = Z_DATA_ERROR;
714 goto inf_leave;
715 case MEM:
716 return Z_MEM_ERROR;
717 case SYNC:
718 default:
719 return Z_STREAM_ERROR;
723 Return from inflate(), updating the total counts and the check value.
724 If there was no progress during the inflate() call, return a buffer
725 error. Call zlib_updatewindow() to create and/or update the window state.
727 inf_leave:
728 RESTORE();
729 if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
730 zlib_updatewindow(strm, out);
732 in -= strm->avail_in;
733 out -= strm->avail_out;
734 strm->total_in += in;
735 strm->total_out += out;
736 state->total += out;
737 if (state->wrap && out)
738 strm->adler = state->check =
739 UPDATE(state->check, strm->next_out - out, out);
741 strm->data_type = state->bits + (state->last ? 64 : 0) +
742 (state->mode == TYPE ? 128 : 0);
744 if (flush == Z_PACKET_FLUSH && ret == Z_OK &&
745 strm->avail_out != 0 && strm->avail_in == 0)
746 return zlib_inflateSyncPacket(strm);
748 if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
749 ret = Z_BUF_ERROR;
751 return ret;
754 int zlib_inflateEnd(z_streamp strm)
756 if (strm == NULL || strm->state == NULL)
757 return Z_STREAM_ERROR;
758 return Z_OK;
762 * This subroutine adds the data at next_in/avail_in to the output history
763 * without performing any output. The output buffer must be "caught up";
764 * i.e. no pending output but this should always be the case. The state must
765 * be waiting on the start of a block (i.e. mode == TYPE or HEAD). On exit,
766 * the output will also be caught up, and the checksum will have been updated
767 * if need be.
769 int zlib_inflateIncomp(z_stream *z)
771 struct inflate_state *state = (struct inflate_state *)z->state;
772 Byte *saved_no = z->next_out;
773 uInt saved_ao = z->avail_out;
775 if (state->mode != TYPE && state->mode != HEAD)
776 return Z_DATA_ERROR;
778 /* Setup some variables to allow misuse of updateWindow */
779 z->avail_out = 0;
780 z->next_out = (unsigned char*)z->next_in + z->avail_in;
782 zlib_updatewindow(z, z->avail_in);
784 /* Restore saved variables */
785 z->avail_out = saved_ao;
786 z->next_out = saved_no;
788 z->adler = state->check =
789 UPDATE(state->check, z->next_in, z->avail_in);
791 z->total_out += z->avail_in;
792 z->total_in += z->avail_in;
793 z->next_in += z->avail_in;
794 state->total += z->avail_in;
795 z->avail_in = 0;
797 return Z_OK;