mirror of https://github.com/madler/zlib.git
Mark Adler
13 years ago
parent
4b5a43a219
commit
f81ba93d4a
37 changed files with 1235 additions and 551 deletions
@ -0,0 +1,605 @@ |
||||
/* infback9.c -- inflate deflate64 data using a call-back interface
|
||||
* Copyright (C) 1995-2003 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
#include "zutil.h" |
||||
#include "infback9.h" |
||||
#include "inftree9.h" |
||||
#include "inflate9.h" |
||||
|
||||
#define WSIZE 65536UL |
||||
|
||||
/*
|
||||
strm provides memory allocation functions in zalloc and zfree, or |
||||
Z_NULL to use the library memory allocation functions. |
||||
|
||||
window is a user-supplied window and output buffer that is 64K bytes. |
||||
*/ |
||||
int ZEXPORT inflateBack9Init_(strm, window, version, stream_size) |
||||
z_stream FAR *strm; |
||||
unsigned char FAR *window; |
||||
const char *version; |
||||
int stream_size; |
||||
{ |
||||
struct inflate_state FAR *state; |
||||
|
||||
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || |
||||
stream_size != (int)(sizeof(z_stream))) |
||||
return Z_VERSION_ERROR; |
||||
if (strm == Z_NULL || window == Z_NULL) |
||||
return Z_STREAM_ERROR; |
||||
strm->msg = Z_NULL; /* in case we return an error */ |
||||
if (strm->zalloc == (alloc_func)0) { |
||||
strm->zalloc = zcalloc; |
||||
strm->opaque = (voidpf)0; |
||||
} |
||||
if (strm->zfree == (free_func)0) strm->zfree = zcfree; |
||||
state = (struct inflate_state FAR *)ZALLOC(strm, 1, |
||||
sizeof(struct inflate_state)); |
||||
if (state == Z_NULL) return Z_MEM_ERROR; |
||||
Tracev((stderr, "inflate: allocated\n")); |
||||
strm->state = (voidpf)state; |
||||
state->window = window; |
||||
return Z_OK; |
||||
} |
||||
|
||||
/*
|
||||
Build and output length and distance decoding tables for fixed code |
||||
decoding. |
||||
*/ |
||||
#ifdef MAKEFIXED |
||||
#include <stdio.h> |
||||
|
||||
void makefixed9(void) |
||||
{ |
||||
unsigned sym, bits, low, size; |
||||
code *next, *lenfix, *distfix; |
||||
struct inflate_state state; |
||||
code fixed[544]; |
||||
|
||||
/* literal/length table */ |
||||
sym = 0; |
||||
while (sym < 144) state.lens[sym++] = 8; |
||||
while (sym < 256) state.lens[sym++] = 9; |
||||
while (sym < 280) state.lens[sym++] = 7; |
||||
while (sym < 288) state.lens[sym++] = 8; |
||||
next = fixed; |
||||
lenfix = next; |
||||
bits = 9; |
||||
inflate_table9(LENS, state.lens, 288, &(next), &(bits), state.work); |
||||
|
||||
/* distance table */ |
||||
sym = 0; |
||||
while (sym < 32) state.lens[sym++] = 5; |
||||
distfix = next; |
||||
bits = 5; |
||||
inflate_table9(DISTS, state.lens, 32, &(next), &(bits), state.work); |
||||
|
||||
/* write tables */ |
||||
puts(" /* inffix9.h -- table for decoding deflate64 fixed codes"); |
||||
puts(" * Generated automatically by makefixed9()."); |
||||
puts(" */"); |
||||
puts(""); |
||||
puts(" /* WARNING: this file should *not* be used by applications."); |
||||
puts(" It is part of the implementation of this library and is"); |
||||
puts(" subject to change. Applications should only use zlib.h."); |
||||
puts(" */"); |
||||
puts(""); |
||||
size = 1U << 9; |
||||
printf(" static const code lenfix[%u] = {", size); |
||||
low = 0; |
||||
for (;;) { |
||||
if ((low % 6) == 0) printf("\n "); |
||||
printf("{%u,%u,%d}", lenfix[low].op, lenfix[low].bits, |
||||
lenfix[low].val); |
||||
if (++low == size) break; |
||||
putchar(','); |
||||
} |
||||
puts("\n };"); |
||||
size = 1U << 5; |
||||
printf("\n static const code distfix[%u] = {", size); |
||||
low = 0; |
||||
for (;;) { |
||||
if ((low % 5) == 0) printf("\n "); |
||||
printf("{%u,%u,%d}", distfix[low].op, distfix[low].bits, |
||||
distfix[low].val); |
||||
if (++low == size) break; |
||||
putchar(','); |
||||
} |
||||
puts("\n };"); |
||||
} |
||||
#endif /* MAKEFIXED */ |
||||
|
||||
/* Macros for inflateBack(): */ |
||||
|
||||
/* Clear the input bit accumulator */ |
||||
#define INITBITS() \ |
||||
do { \
|
||||
hold = 0; \
|
||||
bits = 0; \
|
||||
} while (0) |
||||
|
||||
/* Assure that some input is available. If input is requested, but denied,
|
||||
then return a Z_BUF_ERROR from inflateBack(). */ |
||||
#define PULL() \ |
||||
do { \
|
||||
if (have == 0) { \
|
||||
have = in(in_desc, &next); \
|
||||
if (have == 0) { \
|
||||
next = Z_NULL; \
|
||||
ret = Z_BUF_ERROR; \
|
||||
goto inf_leave; \
|
||||
} \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
/* Get a byte of input into the bit accumulator, or return from inflateBack()
|
||||
with an error if there is no input available. */ |
||||
#define PULLBYTE() \ |
||||
do { \
|
||||
PULL(); \
|
||||
have--; \
|
||||
hold += (unsigned long)(*next++) << bits; \
|
||||
bits += 8; \
|
||||
} while (0) |
||||
|
||||
/* Assure that there are at least n bits in the bit accumulator. If there is
|
||||
not enough available input to do that, then return from inflateBack() with |
||||
an error. */ |
||||
#define NEEDBITS(n) \ |
||||
do { \
|
||||
while (bits < (unsigned)(n)) \
|
||||
PULLBYTE(); \
|
||||
} while (0) |
||||
|
||||
/* Return the low n bits of the bit accumulator (n <= 16) */ |
||||
#define BITS(n) \ |
||||
((unsigned)hold & ((1U << (n)) - 1)) |
||||
|
||||
/* Remove n bits from the bit accumulator */ |
||||
#define DROPBITS(n) \ |
||||
do { \
|
||||
hold >>= (n); \
|
||||
bits -= (unsigned)(n); \
|
||||
} while (0) |
||||
|
||||
/* Remove zero to seven bits as needed to go to a byte boundary */ |
||||
#define BYTEBITS() \ |
||||
do { \
|
||||
hold >>= bits & 7; \
|
||||
bits -= bits & 7; \
|
||||
} while (0) |
||||
|
||||
/* Assure that some output space is available, by writing out the window
|
||||
if it's full. If the write fails, return from inflateBack() with a |
||||
Z_BUF_ERROR. */ |
||||
#define ROOM() \ |
||||
do { \
|
||||
if (left == 0) { \
|
||||
put = window; \
|
||||
left = WSIZE; \
|
||||
wrap = 1; \
|
||||
if (out(out_desc, put, (unsigned)left)) { \
|
||||
ret = Z_BUF_ERROR; \
|
||||
goto inf_leave; \
|
||||
} \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
/*
|
||||
strm provides the memory allocation functions and window buffer on input, |
||||
and provides information on the unused input on return. For Z_DATA_ERROR |
||||
returns, strm will also provide an error message. |
||||
|
||||
in() and out() are the call-back input and output functions. When |
||||
inflateBack() needs more input, it calls in(). When inflateBack() has |
||||
filled the window with output, or when it completes with data in the |
||||
window, it calls out() to write out the data. The application must not |
||||
change the provided input until in() is called again or inflateBack() |
||||
returns. The application must not change the window/output buffer until |
||||
inflateBack() returns. |
||||
|
||||
in() and out() are called with a descriptor parameter provided in the |
||||
inflateBack() call. This parameter can be a structure that provides the |
||||
information required to do the read or write, as well as accumulated |
||||
information on the input and output such as totals and check values. |
||||
|
||||
in() should return zero on failure. out() should return non-zero on |
||||
failure. If either in() or out() fails, than inflateBack() returns a |
||||
Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it |
||||
was in() or out() that caused in the error. Otherwise, inflateBack() |
||||
returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format |
||||
error, or Z_MEM_ERROR if it could not allocate memory for the state. |
||||
inflateBack() can also return Z_STREAM_ERROR if the input parameters |
||||
are not correct, i.e. strm is Z_NULL or the state was not initialized. |
||||
*/ |
||||
int ZEXPORT inflateBack9(strm, in, in_desc, out, out_desc) |
||||
z_stream FAR *strm; |
||||
in_func in; |
||||
void FAR *in_desc; |
||||
out_func out; |
||||
void FAR *out_desc; |
||||
{ |
||||
struct inflate_state FAR *state; |
||||
unsigned char FAR *next; /* next input */ |
||||
unsigned char FAR *put; /* next output */ |
||||
unsigned have; /* available input */ |
||||
unsigned long left; /* available output */ |
||||
inflate_mode mode; /* current inflate mode */ |
||||
int lastblock; /* true if processing last block */ |
||||
int wrap; /* true if the window has wrapped */ |
||||
unsigned long write; /* window write index */ |
||||
unsigned char FAR *window; /* allocated sliding window, if needed */ |
||||
unsigned long hold; /* bit buffer */ |
||||
unsigned bits; /* bits in bit buffer */ |
||||
unsigned extra; /* extra bits needed */ |
||||
unsigned long length; /* literal or length of data to copy */ |
||||
unsigned long offset; /* distance back to copy string from */ |
||||
unsigned long copy; /* number of stored or match bytes to copy */ |
||||
unsigned char FAR *from; /* where to copy match bytes from */ |
||||
code const FAR *lencode; /* starting table for length/literal codes */ |
||||
code const FAR *distcode; /* starting table for distance codes */ |
||||
unsigned lenbits; /* index bits for lencode */ |
||||
unsigned distbits; /* index bits for distcode */ |
||||
code this; /* current decoding table entry */ |
||||
code last; /* parent table entry */ |
||||
unsigned len; /* length to copy for repeats, bits to drop */ |
||||
int ret; /* return code */ |
||||
static const unsigned short order[19] = /* permutation of code lengths */ |
||||
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; |
||||
#include "inffix9.h" |
||||
|
||||
/* Check that the strm exists and that the state was initialized */ |
||||
if (strm == Z_NULL || strm->state == Z_NULL) |
||||
return Z_STREAM_ERROR; |
||||
state = (struct inflate_state FAR *)strm->state; |
||||
|
||||
/* Reset the state */ |
||||
strm->msg = Z_NULL; |
||||
mode = TYPE; |
||||
lastblock = 0; |
||||
write = 0; |
||||
wrap = 0; |
||||
window = state->window; |
||||
next = strm->next_in; |
||||
have = next != Z_NULL ? strm->avail_in : 0; |
||||
hold = 0; |
||||
bits = 0; |
||||
put = window; |
||||
left = WSIZE; |
||||
lencode = Z_NULL; |
||||
distcode = Z_NULL; |
||||
|
||||
/* Inflate until end of block marked as last */ |
||||
for (;;) |
||||
switch (mode) { |
||||
case TYPE: |
||||
/* determine and dispatch block type */ |
||||
if (lastblock) { |
||||
BYTEBITS(); |
||||
mode = DONE; |
||||
break; |
||||
} |
||||
NEEDBITS(3); |
||||
lastblock = BITS(1); |
||||
DROPBITS(1); |
||||
switch (BITS(2)) { |
||||
case 0: /* stored block */ |
||||
Tracev((stderr, "inflate: stored block%s\n", |
||||
lastblock ? " (last)" : "")); |
||||
mode = STORED; |
||||
break; |
||||
case 1: /* fixed block */ |
||||
lencode = lenfix; |
||||
lenbits = 9; |
||||
distcode = distfix; |
||||
distbits = 5; |
||||
Tracev((stderr, "inflate: fixed codes block%s\n", |
||||
lastblock ? " (last)" : "")); |
||||
mode = LEN; /* decode codes */ |
||||
break; |
||||
case 2: /* dynamic block */ |
||||
Tracev((stderr, "inflate: dynamic codes block%s\n", |
||||
lastblock ? " (last)" : "")); |
||||
mode = TABLE; |
||||
break; |
||||
case 3: |
||||
strm->msg = (char *)"invalid block type"; |
||||
mode = BAD; |
||||
} |
||||
DROPBITS(2); |
||||
break; |
||||
|
||||
case STORED: |
||||
/* get and verify stored block length */ |
||||
BYTEBITS(); /* go to byte boundary */ |
||||
NEEDBITS(32); |
||||
if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { |
||||
strm->msg = (char *)"invalid stored block lengths"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
length = (unsigned)hold & 0xffff; |
||||
Tracev((stderr, "inflate: stored length %u\n", |
||||
length)); |
||||
INITBITS(); |
||||
|
||||
/* copy stored block from input to output */ |
||||
while (length != 0) { |
||||
copy = length; |
||||
PULL(); |
||||
ROOM(); |
||||
if (copy > have) copy = have; |
||||
if (copy > left) copy = left; |
||||
zmemcpy(put, next, copy); |
||||
have -= copy; |
||||
next += copy; |
||||
left -= copy; |
||||
put += copy; |
||||
length -= copy; |
||||
} |
||||
Tracev((stderr, "inflate: stored end\n")); |
||||
mode = TYPE; |
||||
break; |
||||
|
||||
case TABLE: |
||||
/* get dynamic table entries descriptor */ |
||||
NEEDBITS(14); |
||||
state->nlen = BITS(5) + 257; |
||||
DROPBITS(5); |
||||
state->ndist = BITS(5) + 1; |
||||
DROPBITS(5); |
||||
state->ncode = BITS(4) + 4; |
||||
DROPBITS(4); |
||||
if (state->nlen > 286) { |
||||
strm->msg = (char *)"too many length symbols"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
Tracev((stderr, "inflate: table sizes ok\n")); |
||||
|
||||
/* get code length code lengths (not a typo) */ |
||||
state->have = 0; |
||||
while (state->have < state->ncode) { |
||||
NEEDBITS(3); |
||||
state->lens[order[state->have++]] = (unsigned short)BITS(3); |
||||
DROPBITS(3); |
||||
} |
||||
while (state->have < 19) |
||||
state->lens[order[state->have++]] = 0; |
||||
state->next = state->codes; |
||||
lencode = (code const FAR *)(state->next); |
||||
lenbits = 7; |
||||
ret = inflate_table9(CODES, state->lens, 19, &(state->next), |
||||
&(lenbits), state->work); |
||||
if (ret) { |
||||
strm->msg = (char *)"invalid code lengths set"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
Tracev((stderr, "inflate: code lengths ok\n")); |
||||
|
||||
/* get length and distance code code lengths */ |
||||
state->have = 0; |
||||
while (state->have < state->nlen + state->ndist) { |
||||
for (;;) { |
||||
this = lencode[BITS(lenbits)]; |
||||
if ((unsigned)(this.bits) <= bits) break; |
||||
PULLBYTE(); |
||||
} |
||||
if (this.val < 16) { |
||||
NEEDBITS(this.bits); |
||||
DROPBITS(this.bits); |
||||
state->lens[state->have++] = this.val; |
||||
} |
||||
else { |
||||
if (this.val == 16) { |
||||
NEEDBITS(this.bits + 2); |
||||
DROPBITS(this.bits); |
||||
if (state->have == 0) { |
||||
strm->msg = (char *)"invalid bit length repeat"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
len = (unsigned)(state->lens[state->have - 1]); |
||||
copy = 3 + BITS(2); |
||||
DROPBITS(2); |
||||
} |
||||
else if (this.val == 17) { |
||||
NEEDBITS(this.bits + 3); |
||||
DROPBITS(this.bits); |
||||
len = 0; |
||||
copy = 3 + BITS(3); |
||||
DROPBITS(3); |
||||
} |
||||
else { |
||||
NEEDBITS(this.bits + 7); |
||||
DROPBITS(this.bits); |
||||
len = 0; |
||||
copy = 11 + BITS(7); |
||||
DROPBITS(7); |
||||
} |
||||
if (state->have + copy > state->nlen + state->ndist) { |
||||
strm->msg = (char *)"invalid bit length repeat"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
while (copy--) |
||||
state->lens[state->have++] = (unsigned short)len; |
||||
} |
||||
} |
||||
|
||||
/* build code tables */ |
||||
state->next = state->codes; |
||||
lencode = (code const FAR *)(state->next); |
||||
lenbits = 9; |
||||
ret = inflate_table9(LENS, state->lens, state->nlen, |
||||
&(state->next), &(lenbits), state->work); |
||||
if (ret) { |
||||
strm->msg = (char *)"invalid literal/lengths set"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
distcode = (code const FAR *)(state->next); |
||||
distbits = 6; |
||||
ret = inflate_table9(DISTS, state->lens + state->nlen, |
||||
state->ndist, &(state->next), &(distbits), |
||||
state->work); |
||||
if (ret) { |
||||
strm->msg = (char *)"invalid distances set"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
Tracev((stderr, "inflate: codes ok\n")); |
||||
mode = LEN; |
||||
|
||||
case LEN: |
||||
/* get a literal, length, or end-of-block code */ |
||||
for (;;) { |
||||
this = lencode[BITS(lenbits)]; |
||||
if ((unsigned)(this.bits) <= bits) break; |
||||
PULLBYTE(); |
||||
} |
||||
if (this.op && (this.op & 0xf0) == 0) { |
||||
last = this; |
||||
for (;;) { |
||||
this = lencode[last.val + |
||||
(BITS(last.bits + last.op) >> last.bits)]; |
||||
if ((unsigned)(last.bits + this.bits) <= bits) break; |
||||
PULLBYTE(); |
||||
} |
||||
DROPBITS(last.bits); |
||||
} |
||||
DROPBITS(this.bits); |
||||
length = (unsigned)this.val; |
||||
|
||||
/* process literal */ |
||||
if (this.op == 0) { |
||||
Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ? |
||||
"inflate: literal '%c'\n" : |
||||
"inflate: literal 0x%02x\n", this.val)); |
||||
ROOM(); |
||||
*put++ = (unsigned char)(length); |
||||
left--; |
||||
mode = LEN; |
||||
break; |
||||
} |
||||
|
||||
/* process end of block */ |
||||
if (this.op & 32) { |
||||
Tracevv((stderr, "inflate: end of block\n")); |
||||
mode = TYPE; |
||||
break; |
||||
} |
||||
|
||||
/* invalid code */ |
||||
if (this.op & 64) { |
||||
strm->msg = (char *)"invalid literal/length code"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
|
||||
/* length code -- get extra bits, if any */ |
||||
extra = (unsigned)(this.op) & 31; |
||||
if (extra != 0) { |
||||
NEEDBITS(extra); |
||||
length += BITS(extra); |
||||
DROPBITS(extra); |
||||
} |
||||
Tracevv((stderr, "inflate: length %u\n", length)); |
||||
|
||||
/* get distance code */ |
||||
for (;;) { |
||||
this = distcode[BITS(distbits)]; |
||||
if ((unsigned)(this.bits) <= bits) break; |
||||
PULLBYTE(); |
||||
} |
||||
if ((this.op & 0xf0) == 0) { |
||||
last = this; |
||||
for (;;) { |
||||
this = distcode[last.val + |
||||
(BITS(last.bits + last.op) >> last.bits)]; |
||||
if ((unsigned)(last.bits + this.bits) <= bits) break; |
||||
PULLBYTE(); |
||||
} |
||||
DROPBITS(last.bits); |
||||
} |
||||
DROPBITS(this.bits); |
||||
if (this.op & 64) { |
||||
strm->msg = (char *)"invalid distance code"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
offset = (unsigned)this.val; |
||||
|
||||
/* get distance extra bits, if any */ |
||||
extra = (unsigned)(this.op) & 15; |
||||
if (extra != 0) { |
||||
NEEDBITS(extra); |
||||
offset += BITS(extra); |
||||
DROPBITS(extra); |
||||
} |
||||
if (offset > WSIZE - (wrap ? 0: left)) { |
||||
strm->msg = (char *)"invalid distance too far back"; |
||||
mode = BAD; |
||||
break; |
||||
} |
||||
Tracevv((stderr, "inflate: distance %u\n", offset)); |
||||
|
||||
/* copy match from window to output */ |
||||
do { |
||||
ROOM(); |
||||
copy = WSIZE - offset; |
||||
if (copy < left) { |
||||
from = put + copy; |
||||
copy = left - copy; |
||||
} |
||||
else { |
||||
from = put - offset; |
||||
copy = left; |
||||
} |
||||
if (copy > length) copy = length; |
||||
length -= copy; |
||||
left -= copy; |
||||
do { |
||||
*put++ = *from++; |
||||
} while (--copy); |
||||
} while (length != 0); |
||||
break; |
||||
|
||||
case DONE: |
||||
/* inflate stream terminated properly -- write leftover output */ |
||||
ret = Z_STREAM_END; |
||||
if (left < WSIZE) { |
||||
if (out(out_desc, window, (unsigned)(WSIZE - left))) |
||||
ret = Z_BUF_ERROR; |
||||
} |
||||
goto inf_leave; |
||||
|
||||
case BAD: |
||||
ret = Z_DATA_ERROR; |
||||
goto inf_leave; |
||||
|
||||
default: /* can't happen, but makes compilers happy */ |
||||
ret = Z_STREAM_ERROR; |
||||
goto inf_leave; |
||||
} |
||||
|
||||
/* Return unused input */ |
||||
inf_leave: |
||||
strm->next_in = next; |
||||
strm->avail_in = have; |
||||
return ret; |
||||
} |
||||
|
||||
int ZEXPORT inflateBack9End(strm) |
||||
z_stream FAR *strm; |
||||
{ |
||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) |
||||
return Z_STREAM_ERROR; |
||||
ZFREE(strm, strm->state); |
||||
strm->state = Z_NULL; |
||||
Tracev((stderr, "inflate: end\n")); |
||||
return Z_OK; |
||||
} |
||||
@ -1,427 +0,0 @@ |
||||
*** infback.c Mon Aug 11 16:48:06 2003
|
||||
--- infback9.c Mon Sep 8 21:22:46 2003
|
||||
***************
|
||||
*** 1,19 ****
|
||||
! /* infback.c -- inflate using a call-back interface
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
- /*
|
||||
- This code is largely copied from inflate.c. Normally either infback.o or
|
||||
- inflate.o would be linked into an application--not both. The interface
|
||||
- with inffast.c is retained so that optimized assembler-coded versions of
|
||||
- inflate_fast() can be used with either inflate.c or infback.c.
|
||||
- */
|
||||
-
|
||||
#include "zutil.h"
|
||||
! #include "inftrees.h"
|
||||
#include "inflate.h"
|
||||
- #include "inffast.h"
|
||||
|
||||
/* function prototypes */
|
||||
local void fixedtables OF((struct inflate_state FAR *state));
|
||||
--- 1,12 ----
|
||||
! /* infback9.c -- inflate deflate64 data using a call-back interface
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
! #include "infback9.h"
|
||||
! #include "inftree9.h"
|
||||
#include "inflate.h"
|
||||
|
||||
/* function prototypes */
|
||||
local void fixedtables OF((struct inflate_state FAR *state));
|
||||
***************
|
||||
*** 22,33 ****
|
||||
strm provides memory allocation functions in zalloc and zfree, or
|
||||
Z_NULL to use the library memory allocation functions.
|
||||
|
||||
! windowBits is in the range 8..15, and window is a user-supplied
|
||||
! window and output buffer that is 2**windowBits bytes.
|
||||
*/
|
||||
! int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
|
||||
z_stream FAR *strm;
|
||||
- int windowBits;
|
||||
unsigned char FAR *window;
|
||||
const char *version;
|
||||
int stream_size;
|
||||
--- 15,24 ----
|
||||
strm provides memory allocation functions in zalloc and zfree, or
|
||||
Z_NULL to use the library memory allocation functions.
|
||||
|
||||
! window is a user-supplied window and output buffer that is 64K bytes.
|
||||
*/
|
||||
! int ZEXPORT inflateBack9Init_(strm, window, version, stream_size)
|
||||
z_stream FAR *strm;
|
||||
unsigned char FAR *window;
|
||||
const char *version;
|
||||
int stream_size;
|
||||
***************
|
||||
*** 37,44 ****
|
||||
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
|
||||
stream_size != (int)(sizeof(z_stream)))
|
||||
return Z_VERSION_ERROR;
|
||||
! if (strm == Z_NULL || window == Z_NULL ||
|
||||
! windowBits < 8 || windowBits > 15)
|
||||
return Z_STREAM_ERROR;
|
||||
strm->msg = Z_NULL; /* in case we return an error */
|
||||
if (strm->zalloc == (alloc_func)0) {
|
||||
--- 28,34 ----
|
||||
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
|
||||
stream_size != (int)(sizeof(z_stream)))
|
||||
return Z_VERSION_ERROR;
|
||||
! if (strm == Z_NULL || window == Z_NULL)
|
||||
return Z_STREAM_ERROR;
|
||||
strm->msg = Z_NULL; /* in case we return an error */
|
||||
if (strm->zalloc == (alloc_func)0) {
|
||||
***************
|
||||
*** 51,58 ****
|
||||
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||
Tracev((stderr, "inflate: allocated\n"));
|
||||
strm->state = (voidpf)state;
|
||||
! state->wbits = windowBits;
|
||||
! state->wsize = 1U << windowBits;
|
||||
state->window = window;
|
||||
state->write = 0;
|
||||
state->whave = 0;
|
||||
--- 41,48 ----
|
||||
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||
Tracev((stderr, "inflate: allocated\n"));
|
||||
strm->state = (voidpf)state;
|
||||
! state->wbits = 16;
|
||||
! state->wsize = 1U << 16;
|
||||
state->window = window;
|
||||
state->write = 0;
|
||||
state->whave = 0;
|
||||
***************
|
||||
*** 91,110 ****
|
||||
next = fixed;
|
||||
lenfix = next;
|
||||
bits = 9;
|
||||
! inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
|
||||
|
||||
/* distance table */
|
||||
sym = 0;
|
||||
while (sym < 32) state->lens[sym++] = 5;
|
||||
distfix = next;
|
||||
bits = 5;
|
||||
! inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
|
||||
|
||||
/* do this just once */
|
||||
virgin = 0;
|
||||
}
|
||||
#else /* !BUILDFIXED */
|
||||
! # include "inffixed.h"
|
||||
#endif /* BUILDFIXED */
|
||||
state->lencode = lenfix;
|
||||
state->lenbits = 9;
|
||||
--- 81,100 ----
|
||||
next = fixed;
|
||||
lenfix = next;
|
||||
bits = 9;
|
||||
! inflate_table9(LENS, state->lens, 288, &(next), &(bits), state->work);
|
||||
|
||||
/* distance table */
|
||||
sym = 0;
|
||||
while (sym < 32) state->lens[sym++] = 5;
|
||||
distfix = next;
|
||||
bits = 5;
|
||||
! inflate_table9(DISTS, state->lens, 32, &(next), &(bits), state->work);
|
||||
|
||||
/* do this just once */
|
||||
virgin = 0;
|
||||
}
|
||||
#else /* !BUILDFIXED */
|
||||
! # include "inffix9.h"
|
||||
#endif /* BUILDFIXED */
|
||||
state->lencode = lenfix;
|
||||
state->lenbits = 9;
|
||||
***************
|
||||
*** 114,141 ****
|
||||
|
||||
/* Macros for inflateBack(): */
|
||||
|
||||
- /* Load returned state from inflate_fast() */
|
||||
- #define LOAD() \
|
||||
- do { \
|
||||
- put = strm->next_out; \
|
||||
- left = strm->avail_out; \
|
||||
- next = strm->next_in; \
|
||||
- have = strm->avail_in; \
|
||||
- hold = state->hold; \
|
||||
- bits = state->bits; \
|
||||
- } while (0)
|
||||
-
|
||||
- /* Set state from registers for inflate_fast() */
|
||||
- #define RESTORE() \
|
||||
- do { \
|
||||
- strm->next_out = put; \
|
||||
- strm->avail_out = left; \
|
||||
- strm->next_in = next; \
|
||||
- strm->avail_in = have; \
|
||||
- state->hold = hold; \
|
||||
- state->bits = bits; \
|
||||
- } while (0)
|
||||
-
|
||||
/* Clear the input bit accumulator */
|
||||
#define INITBITS() \
|
||||
do { \
|
||||
--- 104,109 ----
|
||||
***************
|
||||
*** 237,243 ****
|
||||
inflateBack() can also return Z_STREAM_ERROR if the input parameters
|
||||
are not correct, i.e. strm is Z_NULL or the state was not initialized.
|
||||
*/
|
||||
! int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
|
||||
z_stream FAR *strm;
|
||||
in_func in;
|
||||
void FAR *in_desc;
|
||||
--- 205,211 ----
|
||||
inflateBack() can also return Z_STREAM_ERROR if the input parameters
|
||||
are not correct, i.e. strm is Z_NULL or the state was not initialized.
|
||||
*/
|
||||
! int ZEXPORT inflateBack9(strm, in, in_desc, out, out_desc)
|
||||
z_stream FAR *strm;
|
||||
in_func in;
|
||||
void FAR *in_desc;
|
||||
***************
|
||||
*** 354,366 ****
|
||||
DROPBITS(5);
|
||||
state->ncode = BITS(4) + 4;
|
||||
DROPBITS(4);
|
||||
! #ifndef PKZIP_BUG_WORKAROUND
|
||||
! if (state->nlen > 286 || state->ndist > 30) {
|
||||
! strm->msg = (char *)"too many length or distance symbols";
|
||||
state->mode = BAD;
|
||||
break;
|
||||
}
|
||||
- #endif
|
||||
Tracev((stderr, "inflate: table sizes ok\n"));
|
||||
|
||||
/* get code length code lengths (not a typo) */
|
||||
--- 322,332 ----
|
||||
DROPBITS(5);
|
||||
state->ncode = BITS(4) + 4;
|
||||
DROPBITS(4);
|
||||
! if (state->nlen > 286) {
|
||||
! strm->msg = (char *)"too many length symbols";
|
||||
state->mode = BAD;
|
||||
break;
|
||||
}
|
||||
Tracev((stderr, "inflate: table sizes ok\n"));
|
||||
|
||||
/* get code length code lengths (not a typo) */
|
||||
***************
|
||||
*** 375,381 ****
|
||||
state->next = state->codes;
|
||||
state->lencode = (code const FAR *)(state->next);
|
||||
state->lenbits = 7;
|
||||
! ret = inflate_table(CODES, state->lens, 19, &(state->next),
|
||||
&(state->lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid code lengths set";
|
||||
--- 341,347 ----
|
||||
state->next = state->codes;
|
||||
state->lencode = (code const FAR *)(state->next);
|
||||
state->lenbits = 7;
|
||||
! ret = inflate_table9(CODES, state->lens, 19, &(state->next),
|
||||
&(state->lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid code lengths set";
|
||||
***************
|
||||
*** 438,445 ****
|
||||
state->next = state->codes;
|
||||
state->lencode = (code const FAR *)(state->next);
|
||||
state->lenbits = 9;
|
||||
! ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
|
||||
! &(state->lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid literal/lengths set";
|
||||
state->mode = BAD;
|
||||
--- 404,411 ----
|
||||
state->next = state->codes;
|
||||
state->lencode = (code const FAR *)(state->next);
|
||||
state->lenbits = 9;
|
||||
! ret = inflate_table9(LENS, state->lens, state->nlen,
|
||||
! &(state->next), &(state->lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid literal/lengths set";
|
||||
state->mode = BAD;
|
||||
***************
|
||||
*** 447,454 ****
|
||||
}
|
||||
state->distcode = (code const FAR *)(state->next);
|
||||
state->distbits = 6;
|
||||
! ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
|
||||
! &(state->next), &(state->distbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid distances set";
|
||||
state->mode = BAD;
|
||||
--- 413,421 ----
|
||||
}
|
||||
state->distcode = (code const FAR *)(state->next);
|
||||
state->distbits = 6;
|
||||
! ret = inflate_table9(DISTS, state->lens + state->nlen,
|
||||
! state->ndist, &(state->next), &(state->distbits),
|
||||
! state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid distances set";
|
||||
state->mode = BAD;
|
||||
***************
|
||||
*** 458,473 ****
|
||||
state->mode = LEN;
|
||||
|
||||
case LEN:
|
||||
- /* use inflate_fast() if we have enough input and output */
|
||||
- if (have >= 6 && left >= 258) {
|
||||
- RESTORE();
|
||||
- if (state->whave < state->wsize)
|
||||
- state->whave = state->wsize - left;
|
||||
- inflate_fast(strm, state->wsize);
|
||||
- LOAD();
|
||||
- break;
|
||||
- }
|
||||
-
|
||||
/* get a literal, length, or end-of-block code */
|
||||
for (;;) {
|
||||
this = state->lencode[BITS(state->lenbits)];
|
||||
--- 425,430 ----
|
||||
***************
|
||||
*** 607,613 ****
|
||||
return ret;
|
||||
}
|
||||
|
||||
! int ZEXPORT inflateBackEnd(strm)
|
||||
z_stream FAR *strm;
|
||||
{
|
||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
|
||||
--- 564,570 ----
|
||||
return ret;
|
||||
}
|
||||
|
||||
! int ZEXPORT inflateBack9End(strm)
|
||||
z_stream FAR *strm;
|
||||
{
|
||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
|
||||
*** inftrees.c Sun Sep 7 10:59:10 2003
|
||||
--- inftree9.c Mon Sep 8 20:54:36 2003
|
||||
***************
|
||||
*** 1,15 ****
|
||||
! /* inftrees.c -- generate Huffman trees for efficient decoding
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
! #include "inftrees.h"
|
||||
|
||||
#define MAXBITS 15
|
||||
|
||||
! const char inflate_copyright[] =
|
||||
! " inflate 1.2.0.5 Copyright 1995-2003 Mark Adler ";
|
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome
|
||||
in the documentation of your product. If for some reason you cannot
|
||||
--- 1,15 ----
|
||||
! /* inftree9.c -- generate Huffman trees for efficient decoding
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
! #include "inftree9.h"
|
||||
|
||||
#define MAXBITS 15
|
||||
|
||||
! const char inflate9_copyright[] =
|
||||
! " inflate9 1.2.0.5 Copyright 1995-2003 Mark Adler ";
|
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome
|
||||
in the documentation of your product. If for some reason you cannot
|
||||
***************
|
||||
*** 29,35 ****
|
||||
table index bits. It will differ if the request is greater than the
|
||||
longest code or if it is less than the shortest code.
|
||||
*/
|
||||
! int inflate_table(type, lens, codes, table, bits, work)
|
||||
codetype type;
|
||||
unsigned short FAR *lens;
|
||||
unsigned codes;
|
||||
--- 29,35 ----
|
||||
table index bits. It will differ if the request is greater than the
|
||||
longest code or if it is less than the shortest code.
|
||||
*/
|
||||
! int inflate_table9(type, lens, codes, table, bits, work)
|
||||
codetype type;
|
||||
unsigned short FAR *lens;
|
||||
unsigned codes;
|
||||
***************
|
||||
*** 59,76 ****
|
||||
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
|
||||
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
|
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
||||
! 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
|
||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
||||
! 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 192, 78};
|
||||
! static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
||||
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
||||
! 8193, 12289, 16385, 24577, 0, 0};
|
||||
! static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
|
||||
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
|
||||
23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
|
||||
! 28, 28, 29, 29, 64, 64};
|
||||
|
||||
/*
|
||||
Process a set of code lengths to create a canonical Huffman code. The
|
||||
--- 59,76 ----
|
||||
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
|
||||
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
|
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
||||
! 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 3, 0, 0};
|
||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
||||
! 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 32, 192, 78};
|
||||
! static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
||||
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
||||
! 8193, 12289, 16385, 24577, 32769, 49153};
|
||||
! static const unsigned short dext[32] = { /* Distance codes 0..31 extra */
|
||||
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
|
||||
23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
|
||||
! 28, 28, 29, 29, 30, 30};
|
||||
|
||||
/*
|
||||
Process a set of code lengths to create a canonical Huffman code. The
|
||||
*** inftrees.h Sun Aug 10 15:15:50 2003
|
||||
--- inftree9.h Mon Sep 8 20:54:51 2003
|
||||
***************
|
||||
*** 1,4 ****
|
||||
! /* inftrees.h -- header to use inftrees.c
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
--- 1,4 ----
|
||||
! /* inftree9.h -- header to use inftree9.c
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
***************
|
||||
*** 50,55 ****
|
||||
DISTS
|
||||
} codetype;
|
||||
|
||||
! extern int inflate_table OF((codetype type, unsigned short FAR *lens,
|
||||
unsigned codes, code FAR * FAR *table,
|
||||
unsigned FAR *bits, unsigned short FAR *work));
|
||||
--- 50,55 ----
|
||||
DISTS
|
||||
} codetype;
|
||||
|
||||
! extern int inflate_table9 OF((codetype type, unsigned short FAR *lens,
|
||||
unsigned codes, code FAR * FAR *table,
|
||||
unsigned FAR *bits, unsigned short FAR *work));
|
||||
@ -0,0 +1,47 @@ |
||||
/* inflate9.h -- internal inflate state definition
|
||||
* Copyright (C) 1995-2003 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
/* Possible inflate modes between inflate() calls */ |
||||
typedef enum { |
||||
TYPE, /* i: waiting for type bits, including last-flag bit */ |
||||
STORED, /* i: waiting for stored size (length and complement) */ |
||||
TABLE, /* i: waiting for dynamic block table lengths */ |
||||
LEN, /* i: waiting for length/lit code */ |
||||
DONE, /* finished check, done -- remain here until reset */ |
||||
BAD /* got a data error -- remain here until reset */ |
||||
} inflate_mode; |
||||
|
||||
/*
|
||||
State transitions between above modes - |
||||
|
||||
(most modes can go to the BAD mode -- not shown for clarity) |
||||
|
||||
Read deflate blocks: |
||||
TYPE -> STORED or TABLE or LEN or DONE |
||||
STORED -> TYPE |
||||
TABLE -> LENLENS -> CODELENS -> LEN |
||||
Read deflate codes: |
||||
LEN -> LEN or TYPE |
||||
*/ |
||||
|
||||
/* state maintained between inflate() calls. Approximately 7K bytes. */ |
||||
struct inflate_state { |
||||
/* sliding window */ |
||||
unsigned char FAR *window; /* allocated sliding window, if needed */ |
||||
/* dynamic table building */ |
||||
unsigned ncode; /* number of code length code lengths */ |
||||
unsigned nlen; /* number of length code lengths */ |
||||
unsigned ndist; /* number of distance code lengths */ |
||||
unsigned have; /* number of code lengths in lens[] */ |
||||
code FAR *next; /* next available space in codes[] */ |
||||
unsigned short lens[320]; /* temporary storage for code lengths */ |
||||
unsigned short work[288]; /* work area for code table building */ |
||||
code codes[ENOUGH]; /* space for code tables */ |
||||
}; |
||||
@ -0,0 +1,323 @@ |
||||
/* inftree9.c -- generate Huffman trees for efficient decoding
|
||||
* Copyright (C) 1995-2003 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
#include "zutil.h" |
||||
#include "inftree9.h" |
||||
|
||||
#define MAXBITS 15 |
||||
|
||||
const char inflate9_copyright[] = |
||||
" inflate9 1.2.0.6 Copyright 1995-2003 Mark Adler "; |
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome |
||||
in the documentation of your product. If for some reason you cannot |
||||
include such an acknowledgment, I would appreciate that you keep this |
||||
copyright string in the executable of your product. |
||||
*/ |
||||
|
||||
/*
|
||||
Build a set of tables to decode the provided canonical Huffman code. |
||||
The code lengths are lens[0..codes-1]. The result starts at *table, |
||||
whose indices are 0..2^bits-1. work is a writable array of at least |
||||
lens shorts, which is used as a work area. type is the type of code |
||||
to be generated, CODES, LENS, or DISTS. On return, zero is success, |
||||
-1 is an invalid code, and +1 means that ENOUGH isn't enough. table |
||||
on return points to the next available entry's address. bits is the |
||||
requested root table index bits, and on return it is the actual root |
||||
table index bits. It will differ if the request is greater than the |
||||
longest code or if it is less than the shortest code. |
||||
*/ |
||||
int inflate_table9(type, lens, codes, table, bits, work) |
||||
codetype type; |
||||
unsigned short FAR *lens; |
||||
unsigned codes; |
||||
code FAR * FAR *table; |
||||
unsigned FAR *bits; |
||||
unsigned short FAR *work; |
||||
{ |
||||
unsigned len; /* a code's length in bits */ |
||||
unsigned sym; /* index of code symbols */ |
||||
unsigned min, max; /* minimum and maximum code lengths */ |
||||
unsigned root; /* number of index bits for root table */ |
||||
unsigned curr; /* number of index bits for current table */ |
||||
unsigned drop; /* code bits to drop for sub-table */ |
||||
int left; /* number of prefix codes available */ |
||||
unsigned used; /* code entries in table used */ |
||||
unsigned huff; /* Huffman code */ |
||||
unsigned incr; /* for incrementing code, index */ |
||||
unsigned fill; /* index for replicating entries */ |
||||
unsigned low; /* low bits for current root entry */ |
||||
unsigned mask; /* mask for low root bits */ |
||||
code this; /* table entry for duplication */ |
||||
code FAR *next; /* next available space in table */ |
||||
const unsigned short FAR *base; /* base value table to use */ |
||||
const unsigned short FAR *extra; /* extra bits table to use */ |
||||
int end; /* use base and extra for symbol > end */ |
||||
unsigned short count[MAXBITS+1]; /* number of codes of each length */ |
||||
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ |
||||
static const unsigned short lbase[31] = { /* Length codes 257..285 base */ |
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, |
||||
19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, |
||||
131, 163, 195, 227, 3, 0, 0}; |
||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */ |
||||
128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, |
||||
130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132, |
||||
133, 133, 133, 133, 144, 65, 77}; |
||||
static const unsigned short dbase[32] = { /* Distance codes 0..31 base */ |
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, |
||||
65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, |
||||
4097, 6145, 8193, 12289, 16385, 24577, 32769, 49153}; |
||||
static const unsigned short dext[32] = { /* Distance codes 0..31 extra */ |
||||
128, 128, 128, 128, 129, 129, 130, 130, 131, 131, 132, 132, |
||||
133, 133, 134, 134, 135, 135, 136, 136, 137, 137, 138, 138, |
||||
139, 139, 140, 140, 141, 141, 142, 142}; |
||||
|
||||
/*
|
||||
Process a set of code lengths to create a canonical Huffman code. The |
||||
code lengths are lens[0..codes-1]. Each length corresponds to the |
||||
symbols 0..codes-1. The Huffman code is generated by first sorting the |
||||
symbols by length from short to long, and retaining the symbol order |
||||
for codes with equal lengths. Then the code starts with all zero bits |
||||
for the first code of the shortest length, and the codes are integer |
||||
increments for the same length, and zeros are appended as the length |
||||
increases. For the deflate format, these bits are stored backwards |
||||
from their more natural integer increment ordering, and so when the |
||||
decoding tables are built in the large loop below, the integer codes |
||||
are incremented backwards. |
||||
|
||||
This routine assumes, but does not check, that all of the entries in |
||||
lens[] are in the range 0..MAXBITS. The caller must assure this. |
||||
1..MAXBITS is interpreted as that code length. zero means that that |
||||
symbol does not occur in this code. |
||||
|
||||
The codes are sorted by computing a count of codes for each length, |
||||
creating from that a table of starting indices for each length in the |
||||
sorted table, and then entering the symbols in order in the sorted |
||||
table. The sorted table is work[], with that space being provided by |
||||
the caller. |
||||
|
||||
The length counts are used for other purposes as well, i.e. finding |
||||
the minimum and maximum length codes, determining if there are any |
||||
codes at all, checking for a valid set of lengths, and looking ahead |
||||
at length counts to determine sub-table sizes when building the |
||||
decoding tables. |
||||
*/ |
||||
|
||||
/* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ |
||||
for (len = 0; len <= MAXBITS; len++) |
||||
count[len] = 0; |
||||
for (sym = 0; sym < codes; sym++) |
||||
count[lens[sym]]++; |
||||
|
||||
/* bound code lengths, force root to be within code lengths */ |
||||
root = *bits; |
||||
for (max = MAXBITS; max >= 1; max--) |
||||
if (count[max] != 0) break; |
||||
if (root > max) root = max; |
||||
if (max == 0) return -1; /* no codes! */ |
||||
for (min = 1; min <= MAXBITS; min++) |
||||
if (count[min] != 0) break; |
||||
if (root < min) root = min; |
||||
|
||||
/* check for an over-subscribed or incomplete set of lengths */ |
||||
left = 1; |
||||
for (len = 1; len <= MAXBITS; len++) { |
||||
left <<= 1; |
||||
left -= count[len]; |
||||
if (left < 0) return -1; /* over-subscribed */ |
||||
} |
||||
if (left > 0 && (type == CODES || (codes - count[0] != 1))) |
||||
return -1; /* incomplete set */ |
||||
|
||||
/* generate offsets into symbol table for each length for sorting */ |
||||
offs[1] = 0; |
||||
for (len = 1; len < MAXBITS; len++) |
||||
offs[len + 1] = offs[len] + count[len]; |
||||
|
||||
/* sort symbols by length, by symbol order within each length */ |
||||
for (sym = 0; sym < codes; sym++) |
||||
if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; |
||||
|
||||
/*
|
||||
Create and fill in decoding tables. In this loop, the table being |
||||
filled is at next and has curr index bits. The code being used is huff |
||||
with length len. That code is converted to an index by dropping drop |
||||
bits off of the bottom. For codes where len is less than drop + curr, |
||||
those top drop + curr - len bits are incremented through all values to |
||||
fill the table with replicated entries. |
||||
|
||||
root is the number of index bits for the root table. When len exceeds |
||||
root, sub-tables are created pointed to by the root entry with an index |
||||
of the low root bits of huff. This is saved in low to check for when a |
||||
new sub-table should be started. drop is zero when the root table is |
||||
being filled, and drop is root when sub-tables are being filled. |
||||
|
||||
When a new sub-table is needed, it is necessary to look ahead in the |
||||
code lengths to determine what size sub-table is needed. The length |
||||
counts are used for this, and so count[] is decremented as codes are |
||||
entered in the tables. |
||||
|
||||
used keeps track of how many table entries have been allocated from the |
||||
provided *table space. It is checked when a LENS table is being made |
||||
against the space in *table, ENOUGH, minus the maximum space needed by |
||||
the worst case distance code, MAXD. This should never happen, but the |
||||
sufficiency of ENOUGH has not been proven exhaustively, hence the check. |
||||
This assumes that when type == LENS, bits == 9. |
||||
|
||||
sym increments through all symbols, and the loop terminates when |
||||
all codes of length max, i.e. all codes, have been processed. This |
||||
routine permits incomplete codes, so another loop after this one fills |
||||
in the rest of the decoding tables with invalid code markers. |
||||
*/ |
||||
|
||||
/* set up for code type */ |
||||
switch (type) { |
||||
case CODES: |
||||
base = extra = work; /* dummy value--not used */ |
||||
end = 19; |
||||
break; |
||||
case LENS: |
||||
base = lbase; |
||||
base -= 257; |
||||
extra = lext; |
||||
extra -= 257; |
||||
end = 256; |
||||
break; |
||||
default: /* DISTS */ |
||||
base = dbase; |
||||
extra = dext; |
||||
end = -1; |
||||
} |
||||
|
||||
/* initialize state for loop */ |
||||
huff = 0; /* starting code */ |
||||
sym = 0; /* starting code symbol */ |
||||
len = min; /* starting code length */ |
||||
next = *table; /* current table to fill in */ |
||||
curr = root; /* current table index bits */ |
||||
drop = 0; /* current bits to drop from code for index */ |
||||
low = (unsigned)(-1); /* trigger new sub-table when len > root */ |
||||
used = 1U << root; /* use root table entries */ |
||||
mask = used - 1; /* mask for comparing low */ |
||||
|
||||
/* check available table space */ |
||||
if (type == LENS && used >= ENOUGH - MAXD) |
||||
return 1; |
||||
|
||||
/* process all codes and make table entries */ |
||||
for (;;) { |
||||
/* create table entry */ |
||||
this.bits = (unsigned char)(len - drop); |
||||
if ((int)(work[sym]) < end) { |
||||
this.op = (unsigned char)0; |
||||
this.val = work[sym]; |
||||
} |
||||
else if ((int)(work[sym]) > end) { |
||||
this.op = (unsigned char)(extra[work[sym]]); |
||||
this.val = base[work[sym]]; |
||||
} |
||||
else { |
||||
this.op = (unsigned char)(32 + 64); /* end of block */ |
||||
this.val = 0; |
||||
} |
||||
|
||||
/* replicate for those indices with low len bits equal to huff */ |
||||
incr = 1U << (len - drop); |
||||
fill = 1U << curr; |
||||
do { |
||||
fill -= incr; |
||||
next[(huff >> drop) + fill] = this; |
||||
} while (fill != 0); |
||||
|
||||
/* backwards increment the len-bit code huff */ |
||||
incr = 1U << (len - 1); |
||||
while (huff & incr) |
||||
incr >>= 1; |
||||
if (incr != 0) { |
||||
huff &= incr - 1; |
||||
huff += incr; |
||||
} |
||||
else |
||||
huff = 0; |
||||
|
||||
/* go to next symbol, update count, len */ |
||||
sym++; |
||||
if (--(count[len]) == 0) { |
||||
if (len == max) break; |
||||
len = lens[work[sym]]; |
||||
} |
||||
|
||||
/* create new sub-table if needed */ |
||||
if (len > root && (huff & mask) != low) { |
||||
/* if first time, transition to sub-tables */ |
||||
if (drop == 0) |
||||
drop = root; |
||||
|
||||
/* increment past last table */ |
||||
next += 1U << curr; |
||||
|
||||
/* determine length of next table */ |
||||
curr = len - drop; |
||||
left = (int)(1 << curr); |
||||
while (curr + drop < max) { |
||||
left -= count[curr + drop]; |
||||
if (left <= 0) break; |
||||
curr++; |
||||
left <<= 1; |
||||
} |
||||
|
||||
/* check for enough space */ |
||||
used += 1U << curr; |
||||
if (type == LENS && used >= ENOUGH - MAXD) |
||||
return 1; |
||||
|
||||
/* point entry in root table to sub-table */ |
||||
low = huff & mask; |
||||
(*table)[low].op = (unsigned char)curr; |
||||
(*table)[low].bits = (unsigned char)root; |
||||
(*table)[low].val = (unsigned short)(next - *table); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
Fill in rest of table for incomplete codes. This loop is similar to the |
||||
loop above in incrementing huff for table indices. It is assumed that |
||||
len is equal to curr + drop, so there is no loop needed to increment |
||||
through high index bits. When the current sub-table is filled, the loop |
||||
drops back to the root table to fill in any remaining entries there. |
||||
*/ |
||||
this.op = (unsigned char)64; /* invalid code marker */ |
||||
this.bits = (unsigned char)(len - drop); |
||||
this.val = (unsigned short)0; |
||||
while (huff != 0) { |
||||
/* when done with sub-table, drop back to root table */ |
||||
if (drop != 0 && (huff & mask) != low) { |
||||
drop = 0; |
||||
len = root; |
||||
next = *table; |
||||
curr = root; |
||||
this.bits = (unsigned char)len; |
||||
} |
||||
|
||||
/* put invalid code marker in table */ |
||||
next[huff >> drop] = this; |
||||
|
||||
/* backwards increment the len-bit code huff */ |
||||
incr = 1U << (len - 1); |
||||
while (huff & incr) |
||||
incr >>= 1; |
||||
if (incr != 0) { |
||||
huff &= incr - 1; |
||||
huff += incr; |
||||
} |
||||
else |
||||
huff = 0; |
||||
} |
||||
|
||||
/* set return parameters */ |
||||
*table += used; |
||||
*bits = root; |
||||
return 0; |
||||
} |
||||
@ -0,0 +1,55 @@ |
||||
/* inftree9.h -- header to use inftree9.c
|
||||
* Copyright (C) 1995-2003 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
/* Structure for decoding tables. Each entry provides either the
|
||||
information needed to do the operation requested by the code that |
||||
indexed that table entry, or it provides a pointer to another |
||||
table that indexes more bits of the code. op indicates whether |
||||
the entry is a pointer to another table, a literal, a length or |
||||
distance, an end-of-block, or an invalid code. For a table |
||||
pointer, the low four bits of op is the number of index bits of |
||||
that table. For a length or distance, the low four bits of op |
||||
is the number of extra bits to get after the code. bits is |
||||
the number of bits in this code or part of the code to drop off |
||||
of the bit buffer. val is the actual byte to output in the case |
||||
of a literal, the base length or distance, or the offset from |
||||
the current table to the next table. Each entry is four bytes. */ |
||||
typedef struct { |
||||
unsigned char op; /* operation, extra bits, table bits */ |
||||
unsigned char bits; /* bits in this part of the code */ |
||||
unsigned short val; /* offset in table or code value */ |
||||
} code; |
||||
|
||||
/* op values as set by inflate_table():
|
||||
00000000 - literal |
||||
0000tttt - table link, tttt != 0 is the number of table index bits |
||||
100eeeee - length or distance, eeee is the number of extra bits |
||||
01100000 - end of block |
||||
01000000 - invalid code |
||||
*/ |
||||
|
||||
/* Maximum size of dynamic tree. The maximum found in a long but non-
|
||||
exhaustive search was 1004 code structures (850 for length/literals |
||||
and 154 for distances, the latter actually the result of an |
||||
exhaustive search). The true maximum is not known, but the value |
||||
below is more than safe. */ |
||||
#define ENOUGH 1440 |
||||
#define MAXD 154 |
||||
|
||||
/* Type of code to build for inftable() */ |
||||
typedef enum { |
||||
CODES, |
||||
LENS, |
||||
DISTS |
||||
} codetype; |
||||
|
||||
extern int inflate_table9 OF((codetype type, unsigned short FAR *lens, |
||||
unsigned codes, code FAR * FAR *table, |
||||
unsigned FAR *bits, unsigned short FAR *work)); |
||||
Loading…
Reference in new issue