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