|
3
|
1 /* inftrees.c -- generate Huffman trees for efficient decoding
|
|
|
2 * Copyright (C) 1995 Mark Adler
|
|
|
3 * For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
4 */
|
|
|
5
|
|
|
6 #include "zutil.h"
|
|
|
7 #include "inftrees.h"
|
|
|
8
|
|
|
9 struct internal_state {int dummy;}; /* for buggy compilers */
|
|
|
10
|
|
|
11 /* simplify the use of the inflate_huft type with some defines */
|
|
|
12 #define base more.Base
|
|
|
13 #define next more.Next
|
|
|
14 #define exop word.what.Exop
|
|
|
15 #define bits word.what.Bits
|
|
|
16
|
|
|
17
|
|
|
18 local int huft_build __P((
|
|
|
19 uInt *, /* code lengths in bits */
|
|
|
20 uInt, /* number of codes */
|
|
|
21 uInt, /* number of "simple" codes */
|
|
|
22 uInt *, /* list of base values for non-simple codes */
|
|
|
23 uInt *, /* list of extra bits for non-simple codes */
|
|
|
24 inflate_huft **, /* result: starting table */
|
|
|
25 uInt *, /* maximum lookup bits (returns actual) */
|
|
|
26 z_stream *)); /* for zalloc function */
|
|
|
27
|
|
|
28 local voidp falloc __P((
|
|
|
29 voidp, /* opaque pointer (not used) */
|
|
|
30 uInt, /* number of items */
|
|
|
31 uInt)); /* size of item */
|
|
|
32
|
|
|
33 local void ffree __P((
|
|
|
34 voidp q, /* opaque pointer (not used) */
|
|
|
35 voidp p)); /* what to free (not used) */
|
|
|
36
|
|
|
37 /* Tables for deflate from PKZIP's appnote.txt. */
|
|
|
38 local uInt cplens[] = { /* Copy lengths for literal codes 257..285 */
|
|
|
39 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
|
|
40 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
|
|
|
41 /* actually lengths - 2; also see note #13 above about 258 */
|
|
|
42 local uInt cplext[] = { /* Extra bits for literal codes 257..285 */
|
|
|
43 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
|
|
|
44 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 128, 128}; /* 128==invalid */
|
|
|
45 local uInt cpdist[] = { /* Copy offsets for distance codes 0..29 */
|
|
|
46 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
|
|
47 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
|
|
48 8193, 12289, 16385, 24577};
|
|
|
49 local uInt cpdext[] = { /* Extra bits for distance codes */
|
|
|
50 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
|
|
|
51 7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
|
|
|
52 12, 12, 13, 13};
|
|
|
53
|
|
|
54 /*
|
|
|
55 Huffman code decoding is performed using a multi-level table lookup.
|
|
|
56 The fastest way to decode is to simply build a lookup table whose
|
|
|
57 size is determined by the longest code. However, the time it takes
|
|
|
58 to build this table can also be a factor if the data being decoded
|
|
|
59 is not very long. The most common codes are necessarily the
|
|
|
60 shortest codes, so those codes dominate the decoding time, and hence
|
|
|
61 the speed. The idea is you can have a shorter table that decodes the
|
|
|
62 shorter, more probable codes, and then point to subsidiary tables for
|
|
|
63 the longer codes. The time it costs to decode the longer codes is
|
|
|
64 then traded against the time it takes to make longer tables.
|
|
|
65
|
|
|
66 This results of this trade are in the variables lbits and dbits
|
|
|
67 below. lbits is the number of bits the first level table for literal/
|
|
|
68 length codes can decode in one step, and dbits is the same thing for
|
|
|
69 the distance codes. Subsequent tables are also less than or equal to
|
|
|
70 those sizes. These values may be adjusted either when all of the
|
|
|
71 codes are shorter than that, in which case the longest code length in
|
|
|
72 bits is used, or when the shortest code is *longer* than the requested
|
|
|
73 table size, in which case the length of the shortest code in bits is
|
|
|
74 used.
|
|
|
75
|
|
|
76 There are two different values for the two tables, since they code a
|
|
|
77 different number of possibilities each. The literal/length table
|
|
|
78 codes 286 possible values, or in a flat code, a little over eight
|
|
|
79 bits. The distance table codes 30 possible values, or a little less
|
|
|
80 than five bits, flat. The optimum values for speed end up being
|
|
|
81 about one bit more than those, so lbits is 8+1 and dbits is 5+1.
|
|
|
82 The optimum values may differ though from machine to machine, and
|
|
|
83 possibly even between compilers. Your mileage may vary.
|
|
|
84 */
|
|
|
85
|
|
|
86
|
|
|
87 /* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
|
|
|
88 #define BMAX 15 /* maximum bit length of any code */
|
|
|
89 #define N_MAX 288 /* maximum number of codes in any set */
|
|
|
90
|
|
|
91 #ifdef DEBUG
|
|
|
92 uInt inflate_hufts;
|
|
|
93 #endif
|
|
|
94
|
|
|
95 local int huft_build(b, n, s, d, e, t, m, zs)
|
|
|
96 uInt *b; /* code lengths in bits (all assumed <= BMAX) */
|
|
|
97 uInt n; /* number of codes (assumed <= N_MAX) */
|
|
|
98 uInt s; /* number of simple-valued codes (0..s-1) */
|
|
|
99 uInt *d; /* list of base values for non-simple codes */
|
|
|
100 uInt *e; /* list of extra bits for non-simple codes */
|
|
|
101 inflate_huft **t; /* result: starting table */
|
|
|
102 uInt *m; /* maximum lookup bits, returns actual */
|
|
|
103 z_stream *zs; /* for zalloc function */
|
|
|
104 /* Given a list of code lengths and a maximum table size, make a set of
|
|
|
105 tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
|
|
|
106 if the given code set is incomplete (the tables are still built in this
|
|
|
107 case), Z_DATA_ERROR if the input is invalid (all zero length codes or an
|
|
|
108 over-subscribed set of lengths), or Z_MEM_ERROR if not enough memory. */
|
|
|
109 {
|
|
|
110 uInt a; /* counter for codes of length k */
|
|
|
111 uInt c[BMAX+1]; /* bit length count table */
|
|
|
112 uInt f; /* i repeats in table every f entries */
|
|
|
113 int g; /* maximum code length */
|
|
|
114 int h; /* table level */
|
|
|
115 register uInt i; /* counter, current code */
|
|
|
116 register uInt j; /* counter */
|
|
|
117 register int k; /* number of bits in current code */
|
|
|
118 int l; /* bits per table (returned in m) */
|
|
|
119 register uInt *p; /* pointer into c[], b[], or v[] */
|
|
|
120 register inflate_huft *q; /* points to current table */
|
|
|
121 inflate_huft r; /* table entry for structure assignment */
|
|
|
122 inflate_huft *u[BMAX]; /* table stack */
|
|
|
123 uInt v[N_MAX]; /* values in order of bit length */
|
|
|
124 register int w; /* bits before this table == (l * h) */
|
|
|
125 uInt x[BMAX+1]; /* bit offsets, then code stack */
|
|
|
126 uInt *xp; /* pointer into x */
|
|
|
127 int y; /* number of dummy codes added */
|
|
|
128 uInt z; /* number of entries in current table */
|
|
|
129
|
|
|
130
|
|
|
131 /* Generate counts for each bit length */
|
|
|
132 p = c;
|
|
|
133 #define C0 *p++ = 0;
|
|
|
134 #define C2 C0 C0 C0 C0
|
|
|
135 #define C4 C2 C2 C2 C2
|
|
|
136 C4 /* clear c[]--assume BMAX+1 is 16 */
|
|
|
137 p = b; i = n;
|
|
|
138 do {
|
|
|
139 c[*p++]++; /* assume all entries <= BMAX */
|
|
|
140 } while (--i);
|
|
|
141 if (c[0] == n) /* null input--all zero length codes */
|
|
|
142 {
|
|
|
143 *t = (inflate_huft *)Z_NULL;
|
|
|
144 *m = 0;
|
|
|
145 return Z_OK;
|
|
|
146 }
|
|
|
147
|
|
|
148
|
|
|
149 /* Find minimum and maximum length, bound *m by those */
|
|
|
150 l = *m;
|
|
|
151 for (j = 1; j <= BMAX; j++)
|
|
|
152 if (c[j])
|
|
|
153 break;
|
|
|
154 k = j; /* minimum code length */
|
|
|
155 if ((uInt)l < j)
|
|
|
156 l = j;
|
|
|
157 for (i = BMAX; i; i--)
|
|
|
158 if (c[i])
|
|
|
159 break;
|
|
|
160 g = i; /* maximum code length */
|
|
|
161 if ((uInt)l > i)
|
|
|
162 l = i;
|
|
|
163 *m = l;
|
|
|
164
|
|
|
165
|
|
|
166 /* Adjust last length count to fill out codes, if needed */
|
|
|
167 for (y = 1 << j; j < i; j++, y <<= 1)
|
|
|
168 if ((y -= c[j]) < 0)
|
|
|
169 return Z_DATA_ERROR;
|
|
|
170 if ((y -= c[i]) < 0)
|
|
|
171 return Z_DATA_ERROR;
|
|
|
172 c[i] += y;
|
|
|
173
|
|
|
174
|
|
|
175 /* Generate starting offsets into the value table for each length */
|
|
|
176 x[1] = j = 0;
|
|
|
177 p = c + 1; xp = x + 2;
|
|
|
178 while (--i) { /* note that i == g from above */
|
|
|
179 *xp++ = (j += *p++);
|
|
|
180 }
|
|
|
181
|
|
|
182
|
|
|
183 /* Make a table of values in order of bit lengths */
|
|
|
184 p = b; i = 0;
|
|
|
185 do {
|
|
|
186 if ((j = *p++) != 0)
|
|
|
187 v[x[j]++] = i;
|
|
|
188 } while (++i < n);
|
|
|
189
|
|
|
190
|
|
|
191 /* Generate the Huffman codes and for each, make the table entries */
|
|
|
192 x[0] = i = 0; /* first Huffman code is zero */
|
|
|
193 p = v; /* grab values in bit order */
|
|
|
194 h = -1; /* no tables yet--level -1 */
|
|
|
195 w = -l; /* bits decoded == (l * h) */
|
|
|
196 u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */
|
|
|
197 q = (inflate_huft *)Z_NULL; /* ditto */
|
|
|
198 z = 0; /* ditto */
|
|
|
199
|
|
|
200 /* go through the bit lengths (k already is bits in shortest code) */
|
|
|
201 for (; k <= g; k++)
|
|
|
202 {
|
|
|
203 a = c[k];
|
|
|
204 while (a--)
|
|
|
205 {
|
|
|
206 /* here i is the Huffman code of length k bits for value *p */
|
|
|
207 /* make tables up to required level */
|
|
|
208 while (k > w + l)
|
|
|
209 {
|
|
|
210 h++;
|
|
|
211 w += l; /* previous table always l bits */
|
|
|
212
|
|
|
213 /* compute minimum size table less than or equal to l bits */
|
|
|
214 z = (z = g - w) > (uInt)l ? l : z; /* table size upper limit */
|
|
|
215 if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */
|
|
|
216 { /* too few codes for k-w bit table */
|
|
|
217 f -= a + 1; /* deduct codes from patterns left */
|
|
|
218 xp = c + k;
|
|
|
219 if (j < z)
|
|
|
220 while (++j < z) /* try smaller tables up to z bits */
|
|
|
221 {
|
|
|
222 if ((f <<= 1) <= *++xp)
|
|
|
223 break; /* enough codes to use up j bits */
|
|
|
224 f -= *xp; /* else deduct codes from patterns */
|
|
|
225 }
|
|
|
226 }
|
|
|
227 z = 1 << j; /* table entries for j-bit table */
|
|
|
228
|
|
|
229 /* allocate and link in new table */
|
|
|
230 if ((q = (inflate_huft *)ZALLOC
|
|
|
231 (zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
|
|
|
232 {
|
|
|
233 if (h)
|
|
|
234 inflate_trees_free(u[0], zs);
|
|
|
235 return Z_MEM_ERROR; /* not enough memory */
|
|
|
236 }
|
|
|
237 #ifdef DEBUG
|
|
|
238 inflate_hufts += z + 1;
|
|
|
239 #endif
|
|
|
240 *t = q + 1; /* link to list for huft_free() */
|
|
|
241 *(t = &(q->next)) = (inflate_huft *)Z_NULL;
|
|
|
242 u[h] = ++q; /* table starts after link */
|
|
|
243
|
|
|
244 /* connect to last table, if there is one */
|
|
|
245 if (h)
|
|
|
246 {
|
|
|
247 x[h] = i; /* save pattern for backing up */
|
|
|
248 r.bits = (Byte)l; /* bits to dump before this table */
|
|
|
249 r.exop = -(Char)j; /* bits in this table */
|
|
|
250 r.next = q; /* pointer to this table */
|
|
|
251 j = i >> (w - l); /* (get around Turbo C bug) */
|
|
|
252 u[h-1][j] = r; /* connect to last table */
|
|
|
253 }
|
|
|
254 }
|
|
|
255
|
|
|
256 /* set up table entry in r */
|
|
|
257 r.bits = (Byte)(k - w);
|
|
|
258 if (p >= v + n)
|
|
|
259 r.exop = (Char)(-128); /* out of values--invalid code */
|
|
|
260 else if (*p < s)
|
|
|
261 {
|
|
|
262 r.exop = (Char)(*p < 256 ? 16 : -64); /* 256 is end-of-block code */
|
|
|
263 r.base = *p++; /* simple code is just the value */
|
|
|
264 }
|
|
|
265 else
|
|
|
266 {
|
|
|
267 r.exop = (Char)e[*p - s]; /* non-simple--look up in lists */
|
|
|
268 r.base = d[*p++ - s];
|
|
|
269 }
|
|
|
270
|
|
|
271 /* fill code-like entries with r */
|
|
|
272 f = 1 << (k - w);
|
|
|
273 for (j = i >> w; j < z; j += f)
|
|
|
274 q[j] = r;
|
|
|
275
|
|
|
276 /* backwards increment the k-bit code i */
|
|
|
277 for (j = 1 << (k - 1); i & j; j >>= 1)
|
|
|
278 i ^= j;
|
|
|
279 i ^= j;
|
|
|
280
|
|
|
281 /* backup over finished tables */
|
|
|
282 while ((i & ((1 << w) - 1)) != x[h])
|
|
|
283 {
|
|
|
284 h--; /* don't need to update q */
|
|
|
285 w -= l;
|
|
|
286 }
|
|
|
287 }
|
|
|
288 }
|
|
|
289
|
|
|
290
|
|
|
291 /* Return Z_BUF_ERROR if we were given an incomplete table */
|
|
|
292 return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
|
|
|
293 }
|
|
|
294
|
|
|
295
|
|
|
296 int inflate_trees_bits(c, bb, tb, z)
|
|
|
297 uInt *c; /* 19 code lengths */
|
|
|
298 uInt *bb; /* bits tree desired/actual depth */
|
|
|
299 inflate_huft **tb; /* bits tree result */
|
|
|
300 z_stream *z; /* for zfree function */
|
|
|
301 {
|
|
|
302 int r;
|
|
|
303
|
|
|
304 r = huft_build(c, 19, 19, (uInt*)Z_NULL, (uInt*)Z_NULL, tb, bb, z);
|
|
|
305 if (r == Z_DATA_ERROR)
|
|
|
306 z->msg = "oversubscribed dynamic bit lengths tree";
|
|
|
307 else if (r == Z_BUF_ERROR)
|
|
|
308 {
|
|
|
309 inflate_trees_free(*tb, z);
|
|
|
310 z->msg = "incomplete dynamic bit lengths tree";
|
|
|
311 r = Z_DATA_ERROR;
|
|
|
312 }
|
|
|
313 return r;
|
|
|
314 }
|
|
|
315
|
|
|
316
|
|
|
317 int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, z)
|
|
|
318 uInt nl; /* number of literal/length codes */
|
|
|
319 uInt nd; /* number of distance codes */
|
|
|
320 uInt *c; /* that many (total) code lengths */
|
|
|
321 uInt *bl; /* literal desired/actual bit depth */
|
|
|
322 uInt *bd; /* distance desired/actual bit depth */
|
|
|
323 inflate_huft **tl; /* literal/length tree result */
|
|
|
324 inflate_huft **td; /* distance tree result */
|
|
|
325 z_stream *z; /* for zfree function */
|
|
|
326 {
|
|
|
327 int r;
|
|
|
328
|
|
|
329 /* build literal/length tree */
|
|
|
330 if ((r = huft_build(c, nl, 257, cplens, cplext, tl, bl, z)) != Z_OK)
|
|
|
331 {
|
|
|
332 if (r == Z_DATA_ERROR)
|
|
|
333 z->msg = "oversubscribed literal/length tree";
|
|
|
334 else if (r == Z_BUF_ERROR)
|
|
|
335 {
|
|
|
336 inflate_trees_free(*tl, z);
|
|
|
337 z->msg = "incomplete literal/length tree";
|
|
|
338 r = Z_DATA_ERROR;
|
|
|
339 }
|
|
|
340 return r;
|
|
|
341 }
|
|
|
342
|
|
|
343 /* build distance tree */
|
|
|
344 if ((r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, z)) != Z_OK)
|
|
|
345 {
|
|
|
346 if (r == Z_DATA_ERROR)
|
|
|
347 z->msg = "oversubscribed literal/length tree";
|
|
|
348 else if (r == Z_BUF_ERROR) {
|
|
|
349 #ifdef PKZIP_BUG_WORKAROUND
|
|
|
350 r = Z_OK;
|
|
|
351 }
|
|
|
352 #else
|
|
|
353 inflate_trees_free(*td, z);
|
|
|
354 z->msg = "incomplete literal/length tree";
|
|
|
355 r = Z_DATA_ERROR;
|
|
|
356 }
|
|
|
357 inflate_trees_free(*tl, z);
|
|
|
358 return r;
|
|
|
359 #endif
|
|
|
360 }
|
|
|
361
|
|
|
362 /* done */
|
|
|
363 return Z_OK;
|
|
|
364 }
|
|
|
365
|
|
|
366
|
|
|
367 /* build fixed tables only once--keep them here */
|
|
|
368 local int fixed_lock = 0;
|
|
|
369 local int fixed_built = 0;
|
|
|
370 #define FIXEDH 530 /* number of hufts used by fixed tables */
|
|
|
371 local uInt fixed_left = FIXEDH;
|
|
|
372 local inflate_huft fixed_mem[FIXEDH];
|
|
|
373 local uInt fixed_bl;
|
|
|
374 local uInt fixed_bd;
|
|
|
375 local inflate_huft *fixed_tl;
|
|
|
376 local inflate_huft *fixed_td;
|
|
|
377
|
|
|
378
|
|
|
379 local voidp falloc(q, n, s)
|
|
|
380 voidp q; /* opaque pointer (not used) */
|
|
|
381 uInt n; /* number of items */
|
|
|
382 uInt s; /* size of item */
|
|
|
383 {
|
|
|
384 Assert(s == sizeof(inflate_huft) && n <= fixed_left,
|
|
|
385 "inflate_trees falloc overflow");
|
|
|
386 if (q) s++; /* to make some compilers happy */
|
|
|
387 fixed_left -= n;
|
|
|
388 return (voidp)(fixed_mem + fixed_left);
|
|
|
389 }
|
|
|
390
|
|
|
391
|
|
|
392 local void ffree(q, p)
|
|
|
393 voidp q;
|
|
|
394 voidp p;
|
|
|
395 {
|
|
|
396 Assert(0, "inflate_trees ffree called!");
|
|
|
397 if (q) q = p; /* to make some compilers happy */
|
|
|
398 }
|
|
|
399
|
|
|
400
|
|
|
401 int inflate_trees_fixed(bl, bd, tl, td)
|
|
|
402 uInt *bl; /* literal desired/actual bit depth */
|
|
|
403 uInt *bd; /* distance desired/actual bit depth */
|
|
|
404 inflate_huft **tl; /* literal/length tree result */
|
|
|
405 inflate_huft **td; /* distance tree result */
|
|
|
406 {
|
|
|
407 /* build fixed tables if not built already--lock out other instances */
|
|
|
408 while (++fixed_lock > 1)
|
|
|
409 fixed_lock--;
|
|
|
410 if (!fixed_built)
|
|
|
411 {
|
|
|
412 int k; /* temporary variable */
|
|
|
413 unsigned c[288]; /* length list for huft_build */
|
|
|
414 z_stream z; /* for falloc function */
|
|
|
415
|
|
|
416 /* set up fake z_stream for memory routines */
|
|
|
417 z.zalloc = falloc;
|
|
|
418 z.zfree = ffree;
|
|
|
419 z.opaque = Z_NULL;
|
|
|
420
|
|
|
421 /* literal table */
|
|
|
422 for (k = 0; k < 144; k++)
|
|
|
423 c[k] = 8;
|
|
|
424 for (; k < 256; k++)
|
|
|
425 c[k] = 9;
|
|
|
426 for (; k < 280; k++)
|
|
|
427 c[k] = 7;
|
|
|
428 for (; k < 288; k++)
|
|
|
429 c[k] = 8;
|
|
|
430 fixed_bl = 7;
|
|
|
431 huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, &z);
|
|
|
432
|
|
|
433 /* distance table */
|
|
|
434 for (k = 0; k < 30; k++)
|
|
|
435 c[k] = 5;
|
|
|
436 fixed_bd = 5;
|
|
|
437 huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, &z);
|
|
|
438
|
|
|
439 /* done */
|
|
|
440 fixed_built = 1;
|
|
|
441 }
|
|
|
442 fixed_lock--;
|
|
|
443 *bl = fixed_bl;
|
|
|
444 *bd = fixed_bd;
|
|
|
445 *tl = fixed_tl;
|
|
|
446 *td = fixed_td;
|
|
|
447 return Z_OK;
|
|
|
448 }
|
|
|
449
|
|
|
450
|
|
|
451 int inflate_trees_free(t, z)
|
|
|
452 inflate_huft *t; /* table to free */
|
|
|
453 z_stream *z; /* for zfree function */
|
|
|
454 /* Free the malloc'ed tables built by huft_build(), which makes a linked
|
|
|
455 list of the tables it made, with the links in a dummy first entry of
|
|
|
456 each table. */
|
|
|
457 {
|
|
|
458 register inflate_huft *p, *q;
|
|
|
459
|
|
|
460 /* Don't free fixed trees */
|
|
|
461 if (t >= fixed_mem && t <= fixed_mem + FIXEDH)
|
|
|
462 return Z_OK;
|
|
|
463
|
|
|
464 /* Go through linked list, freeing from the malloced (t[-1]) address. */
|
|
|
465 p = t;
|
|
|
466 while (p != Z_NULL)
|
|
|
467 {
|
|
|
468 q = (--p)->next;
|
|
|
469 ZFREE(z,p);
|
|
|
470 p = q;
|
|
|
471 }
|
|
|
472 return Z_OK;
|
|
|
473 }
|
