456 lines
16 KiB
C
456 lines
16 KiB
C
/* inftrees.c -- generate Huffman trees for efficient decoding
|
|
* Copyright (C) 1995-1998 Mark Adler
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
*/
|
|
|
|
#include "zutil.h"
|
|
#include "inftrees.h"
|
|
|
|
#if !defined(BUILDFIXED) && !defined(STDC)
|
|
# define BUILDFIXED /* non ANSI compilers may not accept inffixed.h */
|
|
#endif
|
|
|
|
const char inflate_copyright[] =
|
|
" inflate 1.1.3 Copyright 1995-1998 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.
|
|
*/
|
|
struct internal_state {int dummy;}; /* for buggy compilers */
|
|
|
|
/* simplify the use of the inflate_huft type with some defines */
|
|
#define exop word.what.Exop
|
|
#define bits word.what.Bits
|
|
|
|
|
|
local int huft_build OF((
|
|
uIntf *, /* code lengths in bits */
|
|
uInt, /* number of codes */
|
|
uInt, /* number of "simple" codes */
|
|
const uIntf *, /* list of base values for non-simple codes */
|
|
const uIntf *, /* list of extra bits for non-simple codes */
|
|
inflate_huft * FAR*,/* result: starting table */
|
|
uIntf *, /* maximum lookup bits (returns actual) */
|
|
inflate_huft *, /* space for trees */
|
|
uInt *, /* hufts used in space */
|
|
uIntf * )); /* space for values */
|
|
|
|
/* Tables for deflate from PKZIP's appnote.txt. */
|
|
local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
|
|
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};
|
|
/* see note #13 above about 258 */
|
|
local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
|
|
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
|
|
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */
|
|
local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
|
|
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};
|
|
local const uInt cpdext[30] = { /* Extra bits for distance codes */
|
|
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
|
|
7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
|
|
12, 12, 13, 13};
|
|
|
|
/*
|
|
Huffman code decoding is performed using a multi-level table lookup.
|
|
The fastest way to decode is to simply build a lookup table whose
|
|
size is determined by the longest code. However, the time it takes
|
|
to build this table can also be a factor if the data being decoded
|
|
is not very long. The most common codes are necessarily the
|
|
shortest codes, so those codes dominate the decoding time, and hence
|
|
the speed. The idea is you can have a shorter table that decodes the
|
|
shorter, more probable codes, and then point to subsidiary tables for
|
|
the longer codes. The time it costs to decode the longer codes is
|
|
then traded against the time it takes to make longer tables.
|
|
|
|
This results of this trade are in the variables lbits and dbits
|
|
below. lbits is the number of bits the first level table for literal/
|
|
length codes can decode in one step, and dbits is the same thing for
|
|
the distance codes. Subsequent tables are also less than or equal to
|
|
those sizes. These values may be adjusted either when all of the
|
|
codes are shorter than that, in which case the longest code length in
|
|
bits is used, or when the shortest code is *longer* than the requested
|
|
table size, in which case the length of the shortest code in bits is
|
|
used.
|
|
|
|
There are two different values for the two tables, since they code a
|
|
different number of possibilities each. The literal/length table
|
|
codes 286 possible values, or in a flat code, a little over eight
|
|
bits. The distance table codes 30 possible values, or a little less
|
|
than five bits, flat. The optimum values for speed end up being
|
|
about one bit more than those, so lbits is 8+1 and dbits is 5+1.
|
|
The optimum values may differ though from machine to machine, and
|
|
possibly even between compilers. Your mileage may vary.
|
|
*/
|
|
|
|
|
|
/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
|
|
#define BMAX 15 /* maximum bit length of any code */
|
|
|
|
local int huft_build(b, n, s, d, e, t, m, hp, hn, v)
|
|
uIntf *b; /* code lengths in bits (all assumed <= BMAX) */
|
|
uInt n; /* number of codes (assumed <= 288) */
|
|
uInt s; /* number of simple-valued codes (0..s-1) */
|
|
const uIntf *d; /* list of base values for non-simple codes */
|
|
const uIntf *e; /* list of extra bits for non-simple codes */
|
|
inflate_huft * FAR *t; /* result: starting table */
|
|
uIntf *m; /* maximum lookup bits, returns actual */
|
|
inflate_huft *hp; /* space for trees */
|
|
uInt *hn; /* hufts used in space */
|
|
uIntf *v; /* working area: values in order of bit length */
|
|
/* Given a list of code lengths and a maximum table size, make a set of
|
|
tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
|
|
if the given code set is incomplete (the tables are still built in this
|
|
case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
|
|
lengths), or Z_MEM_ERROR if not enough memory. */
|
|
{
|
|
|
|
uInt a; /* counter for codes of length k */
|
|
uInt c[BMAX+1]; /* bit length count table */
|
|
uInt f; /* i repeats in table every f entries */
|
|
int g; /* maximum code length */
|
|
int h; /* table level */
|
|
register uInt i; /* counter, current code */
|
|
register uInt j; /* counter */
|
|
register int k; /* number of bits in current code */
|
|
int l; /* bits per table (returned in m) */
|
|
uInt mask; /* (1 << w) - 1, to avoid cc -O bug on HP */
|
|
register uIntf *p; /* pointer into c[], b[], or v[] */
|
|
inflate_huft *q; /* points to current table */
|
|
struct inflate_huft_s r; /* table entry for structure assignment */
|
|
inflate_huft *u[BMAX]; /* table stack */
|
|
register int w; /* bits before this table == (l * h) */
|
|
uInt x[BMAX+1]; /* bit offsets, then code stack */
|
|
uIntf *xp; /* pointer into x */
|
|
int y; /* number of dummy codes added */
|
|
uInt z; /* number of entries in current table */
|
|
|
|
|
|
/* Generate counts for each bit length */
|
|
p = c;
|
|
#define C0 *p++ = 0;
|
|
#define C2 C0 C0 C0 C0
|
|
#define C4 C2 C2 C2 C2
|
|
C4 /* clear c[]--assume BMAX+1 is 16 */
|
|
p = b; i = n;
|
|
do {
|
|
c[*p++]++; /* assume all entries <= BMAX */
|
|
} while (--i);
|
|
if (c[0] == n) /* null input--all zero length codes */
|
|
{
|
|
*t = (inflate_huft *)Z_NULL;
|
|
*m = 0;
|
|
return Z_OK;
|
|
}
|
|
|
|
|
|
/* Find minimum and maximum length, bound *m by those */
|
|
l = *m;
|
|
for (j = 1; j <= BMAX; j++)
|
|
if (c[j])
|
|
break;
|
|
k = j; /* minimum code length */
|
|
if ((uInt)l < j)
|
|
l = j;
|
|
for (i = BMAX; i; i--)
|
|
if (c[i])
|
|
break;
|
|
g = i; /* maximum code length */
|
|
if ((uInt)l > i)
|
|
l = i;
|
|
*m = l;
|
|
|
|
|
|
/* Adjust last length count to fill out codes, if needed */
|
|
for (y = 1 << j; j < i; j++, y <<= 1)
|
|
if ((y -= c[j]) < 0)
|
|
return Z_DATA_ERROR;
|
|
if ((y -= c[i]) < 0)
|
|
return Z_DATA_ERROR;
|
|
c[i] += y;
|
|
|
|
|
|
/* Generate starting offsets into the value table for each length */
|
|
x[1] = j = 0;
|
|
p = c + 1; xp = x + 2;
|
|
while (--i) { /* note that i == g from above */
|
|
*xp++ = (j += *p++);
|
|
}
|
|
|
|
|
|
/* Make a table of values in order of bit lengths */
|
|
p = b; i = 0;
|
|
do {
|
|
if ((j = *p++) != 0)
|
|
v[x[j]++] = i;
|
|
} while (++i < n);
|
|
n = x[g]; /* set n to length of v */
|
|
|
|
|
|
/* Generate the Huffman codes and for each, make the table entries */
|
|
x[0] = i = 0; /* first Huffman code is zero */
|
|
p = v; /* grab values in bit order */
|
|
h = -1; /* no tables yet--level -1 */
|
|
w = -l; /* bits decoded == (l * h) */
|
|
u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */
|
|
q = (inflate_huft *)Z_NULL; /* ditto */
|
|
z = 0; /* ditto */
|
|
|
|
/* go through the bit lengths (k already is bits in shortest code) */
|
|
for (; k <= g; k++)
|
|
{
|
|
a = c[k];
|
|
while (a--)
|
|
{
|
|
/* here i is the Huffman code of length k bits for value *p */
|
|
/* make tables up to required level */
|
|
while (k > w + l)
|
|
{
|
|
h++;
|
|
w += l; /* previous table always l bits */
|
|
|
|
/* compute minimum size table less than or equal to l bits */
|
|
z = g - w;
|
|
z = z > (uInt)l ? l : z; /* table size upper limit */
|
|
if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */
|
|
{ /* too few codes for k-w bit table */
|
|
f -= a + 1; /* deduct codes from patterns left */
|
|
xp = c + k;
|
|
if (j < z)
|
|
while (++j < z) /* try smaller tables up to z bits */
|
|
{
|
|
if ((f <<= 1) <= *++xp)
|
|
break; /* enough codes to use up j bits */
|
|
f -= *xp; /* else deduct codes from patterns */
|
|
}
|
|
}
|
|
z = 1 << j; /* table entries for j-bit table */
|
|
|
|
/* allocate new table */
|
|
if (*hn + z > MANY) /* (note: doesn't matter for fixed) */
|
|
return Z_MEM_ERROR; /* not enough memory */
|
|
u[h] = q = hp + *hn;
|
|
*hn += z;
|
|
|
|
/* connect to last table, if there is one */
|
|
if (h)
|
|
{
|
|
x[h] = i; /* save pattern for backing up */
|
|
r.bits = (Byte)l; /* bits to dump before this table */
|
|
r.exop = (Byte)j; /* bits in this table */
|
|
j = i >> (w - l);
|
|
r.base = (uInt)(q - u[h-1] - j); /* offset to this table */
|
|
u[h-1][j] = r; /* connect to last table */
|
|
}
|
|
else
|
|
*t = q; /* first table is returned result */
|
|
}
|
|
|
|
/* set up table entry in r */
|
|
r.bits = (Byte)(k - w);
|
|
if (p >= v + n)
|
|
r.exop = 128 + 64; /* out of values--invalid code */
|
|
else if (*p < s)
|
|
{
|
|
r.exop = (Byte)(*p < 256 ? 0 : 32 + 64); /* 256 is end-of-block */
|
|
r.base = *p++; /* simple code is just the value */
|
|
}
|
|
else
|
|
{
|
|
r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */
|
|
r.base = d[*p++ - s];
|
|
}
|
|
|
|
/* fill code-like entries with r */
|
|
f = 1 << (k - w);
|
|
for (j = i >> w; j < z; j += f)
|
|
q[j] = r;
|
|
|
|
/* backwards increment the k-bit code i */
|
|
for (j = 1 << (k - 1); i & j; j >>= 1)
|
|
i ^= j;
|
|
i ^= j;
|
|
|
|
/* backup over finished tables */
|
|
mask = (1 << w) - 1; /* needed on HP, cc -O bug */
|
|
while ((i & mask) != x[h])
|
|
{
|
|
h--; /* don't need to update q */
|
|
w -= l;
|
|
mask = (1 << w) - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Return Z_BUF_ERROR if we were given an incomplete table */
|
|
return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
|
|
}
|
|
|
|
|
|
int inflate_trees_bits(c, bb, tb, hp, z)
|
|
uIntf *c; /* 19 code lengths */
|
|
uIntf *bb; /* bits tree desired/actual depth */
|
|
inflate_huft * FAR *tb; /* bits tree result */
|
|
inflate_huft *hp; /* space for trees */
|
|
z_streamp z; /* for messages */
|
|
{
|
|
int r;
|
|
uInt hn = 0; /* hufts used in space */
|
|
uIntf *v; /* work area for huft_build */
|
|
|
|
if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)
|
|
return Z_MEM_ERROR;
|
|
r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL,
|
|
tb, bb, hp, &hn, v);
|
|
if (r == Z_DATA_ERROR)
|
|
z->msg = (char*)"oversubscribed dynamic bit lengths tree";
|
|
else if (r == Z_BUF_ERROR || *bb == 0)
|
|
{
|
|
z->msg = (char*)"incomplete dynamic bit lengths tree";
|
|
r = Z_DATA_ERROR;
|
|
}
|
|
ZFREE(z, v);
|
|
return r;
|
|
}
|
|
|
|
|
|
int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z)
|
|
uInt nl; /* number of literal/length codes */
|
|
uInt nd; /* number of distance codes */
|
|
uIntf *c; /* that many (total) code lengths */
|
|
uIntf *bl; /* literal desired/actual bit depth */
|
|
uIntf *bd; /* distance desired/actual bit depth */
|
|
inflate_huft * FAR *tl; /* literal/length tree result */
|
|
inflate_huft * FAR *td; /* distance tree result */
|
|
inflate_huft *hp; /* space for trees */
|
|
z_streamp z; /* for messages */
|
|
{
|
|
int r;
|
|
uInt hn = 0; /* hufts used in space */
|
|
uIntf *v; /* work area for huft_build */
|
|
|
|
/* allocate work area */
|
|
if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
|
|
return Z_MEM_ERROR;
|
|
|
|
/* build literal/length tree */
|
|
r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
|
|
if (r != Z_OK || *bl == 0)
|
|
{
|
|
if (r == Z_DATA_ERROR)
|
|
z->msg = (char*)"oversubscribed literal/length tree";
|
|
else if (r != Z_MEM_ERROR)
|
|
{
|
|
z->msg = (char*)"incomplete literal/length tree";
|
|
r = Z_DATA_ERROR;
|
|
}
|
|
ZFREE(z, v);
|
|
return r;
|
|
}
|
|
|
|
/* build distance tree */
|
|
r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
|
|
if (r != Z_OK || (*bd == 0 && nl > 257))
|
|
{
|
|
if (r == Z_DATA_ERROR)
|
|
z->msg = (char*)"oversubscribed distance tree";
|
|
else if (r == Z_BUF_ERROR) {
|
|
#ifdef PKZIP_BUG_WORKAROUND
|
|
r = Z_OK;
|
|
}
|
|
#else
|
|
z->msg = (char*)"incomplete distance tree";
|
|
r = Z_DATA_ERROR;
|
|
}
|
|
else if (r != Z_MEM_ERROR)
|
|
{
|
|
z->msg = (char*)"empty distance tree with lengths";
|
|
r = Z_DATA_ERROR;
|
|
}
|
|
ZFREE(z, v);
|
|
return r;
|
|
#endif
|
|
}
|
|
|
|
/* done */
|
|
ZFREE(z, v);
|
|
return Z_OK;
|
|
}
|
|
|
|
|
|
/* build fixed tables only once--keep them here */
|
|
#ifdef BUILDFIXED
|
|
local int fixed_built = 0;
|
|
#define FIXEDH 544 /* number of hufts used by fixed tables */
|
|
local inflate_huft fixed_mem[FIXEDH];
|
|
local uInt fixed_bl;
|
|
local uInt fixed_bd;
|
|
local inflate_huft *fixed_tl;
|
|
local inflate_huft *fixed_td;
|
|
#else
|
|
#include "inffixed.h"
|
|
#endif
|
|
|
|
|
|
int inflate_trees_fixed(bl, bd, tl, td, z)
|
|
uIntf *bl; /* literal desired/actual bit depth */
|
|
uIntf *bd; /* distance desired/actual bit depth */
|
|
inflate_huft * FAR *tl; /* literal/length tree result */
|
|
inflate_huft * FAR *td; /* distance tree result */
|
|
z_streamp z; /* for memory allocation */
|
|
{
|
|
#ifdef BUILDFIXED
|
|
/* build fixed tables if not already */
|
|
if (!fixed_built)
|
|
{
|
|
int k; /* temporary variable */
|
|
uInt f = 0; /* number of hufts used in fixed_mem */
|
|
uIntf *c; /* length list for huft_build */
|
|
uIntf *v; /* work area for huft_build */
|
|
|
|
/* allocate memory */
|
|
if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
|
|
return Z_MEM_ERROR;
|
|
if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
|
|
{
|
|
ZFREE(z, c);
|
|
return Z_MEM_ERROR;
|
|
}
|
|
|
|
/* literal table */
|
|
for (k = 0; k < 144; k++)
|
|
c[k] = 8;
|
|
for (; k < 256; k++)
|
|
c[k] = 9;
|
|
for (; k < 280; k++)
|
|
c[k] = 7;
|
|
for (; k < 288; k++)
|
|
c[k] = 8;
|
|
fixed_bl = 9;
|
|
huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl,
|
|
fixed_mem, &f, v);
|
|
|
|
/* distance table */
|
|
for (k = 0; k < 30; k++)
|
|
c[k] = 5;
|
|
fixed_bd = 5;
|
|
huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd,
|
|
fixed_mem, &f, v);
|
|
|
|
/* done */
|
|
ZFREE(z, v);
|
|
ZFREE(z, c);
|
|
fixed_built = 1;
|
|
}
|
|
#endif
|
|
*bl = fixed_bl;
|
|
*bd = fixed_bd;
|
|
*tl = fixed_tl;
|
|
*td = fixed_td;
|
|
return Z_OK;
|
|
}
|