|
1 /* inftrees.c -- generate Huffman trees for efficient decoding |
|
2 * Copyright (C) 1995-2002 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.4 Copyright 1995-2002 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( |
|
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), or Z_DATA_ERROR if the input is invalid. */ |
|
108 { |
|
109 // Line to stop compiler warning about unused mandatory global variable |
|
110 char __z=inflate_copyright[0]; __z=__z; |
|
111 |
|
112 uInt a; /* counter for codes of length k */ |
|
113 uInt c[BMAX+1]; /* bit length count table */ |
|
114 uInt f; /* i repeats in table every f entries */ |
|
115 int g; /* maximum code length */ |
|
116 int h; /* table level */ |
|
117 register uInt i; /* counter, current code */ |
|
118 register uInt j; /* counter */ |
|
119 register int k; /* number of bits in current code */ |
|
120 int l; /* bits per table (returned in m) */ |
|
121 uInt mask; /* (1 << w) - 1, to avoid cc -O bug on HP */ |
|
122 register uIntf *p; /* pointer into c[], b[], or v[] */ |
|
123 inflate_huft *q; /* points to current table */ |
|
124 struct inflate_huft_s r; /* table entry for structure assignment */ |
|
125 inflate_huft *u[BMAX]; /* table stack */ |
|
126 register int w; /* bits before this table == (l * h) */ |
|
127 uInt x[BMAX+1]; /* bit offsets, then code stack */ |
|
128 uIntf *xp; /* pointer into x */ |
|
129 int y; /* number of dummy codes added */ |
|
130 uInt z; /* number of entries in current table */ |
|
131 |
|
132 |
|
133 /* Generate counts for each bit length */ |
|
134 p = c; |
|
135 #define C0 *p++ = 0; |
|
136 #define C2 C0 C0 C0 C0 |
|
137 #define C4 C2 C2 C2 C2 |
|
138 C4 /* clear c[]--assume BMAX+1 is 16 */ |
|
139 p = b; i = n; |
|
140 do { |
|
141 c[*p++]++; /* assume all entries <= BMAX */ |
|
142 } while (--i); |
|
143 if (c[0] == n) /* null input--all zero length codes */ |
|
144 { |
|
145 *t = (inflate_huft *)Z_NULL; |
|
146 *m = 0; |
|
147 return Z_OK; |
|
148 } |
|
149 |
|
150 |
|
151 /* Find minimum and maximum length, bound *m by those */ |
|
152 l = *m; |
|
153 for (j = 1; j <= BMAX; j++) |
|
154 if (c[j]) |
|
155 break; |
|
156 k = j; /* minimum code length */ |
|
157 if ((uInt)l < j) |
|
158 l = j; |
|
159 for (i = BMAX; i; i--) |
|
160 if (c[i]) |
|
161 break; |
|
162 g = i; /* maximum code length */ |
|
163 if ((uInt)l > i) |
|
164 l = i; |
|
165 *m = l; |
|
166 |
|
167 |
|
168 /* Adjust last length count to fill out codes, if needed */ |
|
169 for (y = 1 << j; j < i; j++, y <<= 1) |
|
170 if ((y -= c[j]) < 0) |
|
171 return Z_DATA_ERROR; |
|
172 if ((y -= c[i]) < 0) |
|
173 return Z_DATA_ERROR; |
|
174 c[i] += y; |
|
175 |
|
176 |
|
177 /* Generate starting offsets into the value table for each length */ |
|
178 x[1] = j = 0; |
|
179 p = c + 1; xp = x + 2; |
|
180 while (--i) { /* note that i == g from above */ |
|
181 *xp++ = (j += *p++); |
|
182 } |
|
183 |
|
184 |
|
185 /* Make a table of values in order of bit lengths */ |
|
186 p = b; i = 0; |
|
187 do { |
|
188 if ((j = *p++) != 0) |
|
189 v[x[j]++] = i; |
|
190 } while (++i < n); |
|
191 n = x[g]; /* set n to length of v */ |
|
192 |
|
193 |
|
194 /* Generate the Huffman codes and for each, make the table entries */ |
|
195 x[0] = i = 0; /* first Huffman code is zero */ |
|
196 p = v; /* grab values in bit order */ |
|
197 h = -1; /* no tables yet--level -1 */ |
|
198 w = -l; /* bits decoded == (l * h) */ |
|
199 u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */ |
|
200 q = (inflate_huft *)Z_NULL; /* ditto */ |
|
201 z = 0; /* ditto */ |
|
202 |
|
203 /* go through the bit lengths (k already is bits in shortest code) */ |
|
204 for (; k <= g; k++) |
|
205 { |
|
206 a = c[k]; |
|
207 while (a--) |
|
208 { |
|
209 /* here i is the Huffman code of length k bits for value *p */ |
|
210 /* make tables up to required level */ |
|
211 while (k > w + l) |
|
212 { |
|
213 h++; |
|
214 w += l; /* previous table always l bits */ |
|
215 |
|
216 /* compute minimum size table less than or equal to l bits */ |
|
217 z = g - w; |
|
218 z = z > (uInt)l ? l : z; /* table size upper limit */ |
|
219 if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ |
|
220 { /* too few codes for k-w bit table */ |
|
221 f -= a + 1; /* deduct codes from patterns left */ |
|
222 xp = c + k; |
|
223 if (j < z) |
|
224 while (++j < z) /* try smaller tables up to z bits */ |
|
225 { |
|
226 if ((f <<= 1) <= *++xp) |
|
227 break; /* enough codes to use up j bits */ |
|
228 f -= *xp; /* else deduct codes from patterns */ |
|
229 } |
|
230 } |
|
231 z = 1 << j; /* table entries for j-bit table */ |
|
232 |
|
233 /* allocate new table */ |
|
234 if (*hn + z > MANY) /* (note: doesn't matter for fixed) */ |
|
235 return Z_DATA_ERROR; /* overflow of MANY */ |
|
236 u[h] = q = hp + *hn; |
|
237 *hn += z; |
|
238 |
|
239 /* connect to last table, if there is one */ |
|
240 if (h) |
|
241 { |
|
242 x[h] = i; /* save pattern for backing up */ |
|
243 r.bits = (Byte)l; /* bits to dump before this table */ |
|
244 r.exop = (Byte)j; /* bits in this table */ |
|
245 j = i >> (w - l); |
|
246 r.base = (uInt)(q - u[h-1] - j); /* offset to this table */ |
|
247 u[h-1][j] = r; /* connect to last table */ |
|
248 } |
|
249 else |
|
250 *t = q; /* first table is returned result */ |
|
251 } |
|
252 |
|
253 /* set up table entry in r */ |
|
254 r.bits = (Byte)(k - w); |
|
255 if (p >= v + n) |
|
256 r.exop = 128 + 64; /* out of values--invalid code */ |
|
257 else if (*p < s) |
|
258 { |
|
259 r.exop = (Byte)(*p < 256 ? 0 : 32 + 64); /* 256 is end-of-block */ |
|
260 r.base = *p++; /* simple code is just the value */ |
|
261 } |
|
262 else |
|
263 { |
|
264 r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */ |
|
265 r.base = d[*p++ - s]; |
|
266 } |
|
267 |
|
268 /* fill code-like entries with r */ |
|
269 f = 1 << (k - w); |
|
270 for (j = i >> w; j < z; j += f) |
|
271 q[j] = r; |
|
272 |
|
273 /* backwards increment the k-bit code i */ |
|
274 for (j = 1 << (k - 1); i & j; j >>= 1) |
|
275 i ^= j; |
|
276 i ^= j; |
|
277 |
|
278 /* backup over finished tables */ |
|
279 mask = (1 << w) - 1; /* needed on HP, cc -O bug */ |
|
280 while ((i & mask) != x[h]) |
|
281 { |
|
282 h--; /* don't need to update q */ |
|
283 w -= l; |
|
284 mask = (1 << w) - 1; |
|
285 } |
|
286 } |
|
287 } |
|
288 |
|
289 |
|
290 /* Return Z_BUF_ERROR if we were given an incomplete table */ |
|
291 return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK; |
|
292 } |
|
293 |
|
294 |
|
295 int inflate_trees_bits( |
|
296 uIntf *c, /* 19 code lengths */ |
|
297 uIntf *bb, /* bits tree desired/actual depth */ |
|
298 inflate_huft * FAR *tb, /* bits tree result */ |
|
299 inflate_huft *hp, /* space for trees */ |
|
300 z_streamp z) /* for messages */ |
|
301 { |
|
302 int r; |
|
303 uInt hn = 0; /* hufts used in space */ |
|
304 uIntf *v; /* work area for huft_build */ |
|
305 |
|
306 if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL) |
|
307 return Z_MEM_ERROR; |
|
308 r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, |
|
309 tb, bb, hp, &hn, v); |
|
310 if (r == Z_DATA_ERROR) |
|
311 z->msg = (char*)"oversubscribed dynamic bit lengths tree"; |
|
312 else if (r == Z_BUF_ERROR || *bb == 0) |
|
313 { |
|
314 z->msg = (char*)"incomplete dynamic bit lengths tree"; |
|
315 r = Z_DATA_ERROR; |
|
316 } |
|
317 ZFREE(z, v); |
|
318 return r; |
|
319 } |
|
320 |
|
321 |
|
322 int inflate_trees_dynamic( |
|
323 uInt nl, /* number of literal/length codes */ |
|
324 uInt nd, /* number of distance codes */ |
|
325 uIntf *c, /* that many (total) code lengths */ |
|
326 uIntf *bl, /* literal desired/actual bit depth */ |
|
327 uIntf *bd, /* distance desired/actual bit depth */ |
|
328 inflate_huft * FAR *tl, /* literal/length tree result */ |
|
329 inflate_huft * FAR *td, /* distance tree result */ |
|
330 inflate_huft *hp, /* space for trees */ |
|
331 z_streamp z) /* for messages */ |
|
332 { |
|
333 int r; |
|
334 uInt hn = 0; /* hufts used in space */ |
|
335 uIntf *v; /* work area for huft_build */ |
|
336 |
|
337 /* allocate work area */ |
|
338 if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) |
|
339 return Z_MEM_ERROR; |
|
340 |
|
341 /* build literal/length tree */ |
|
342 r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v); |
|
343 if (r != Z_OK || *bl == 0) |
|
344 { |
|
345 if (r == Z_DATA_ERROR) |
|
346 z->msg = (char*)"oversubscribed literal/length tree"; |
|
347 else if (r != Z_MEM_ERROR) |
|
348 { |
|
349 z->msg = (char*)"incomplete literal/length tree"; |
|
350 r = Z_DATA_ERROR; |
|
351 } |
|
352 ZFREE(z, v); |
|
353 return r; |
|
354 } |
|
355 |
|
356 /* build distance tree */ |
|
357 r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v); |
|
358 if (r != Z_OK || (*bd == 0 && nl > 257)) |
|
359 { |
|
360 if (r == Z_DATA_ERROR) |
|
361 z->msg = (char*)"oversubscribed distance tree"; |
|
362 else if (r == Z_BUF_ERROR) { |
|
363 #ifdef PKZIP_BUG_WORKAROUND |
|
364 r = Z_OK; |
|
365 } |
|
366 #else |
|
367 z->msg = (char*)"incomplete distance tree"; |
|
368 r = Z_DATA_ERROR; |
|
369 } |
|
370 else if (r != Z_MEM_ERROR) |
|
371 { |
|
372 z->msg = (char*)"empty distance tree with lengths"; |
|
373 r = Z_DATA_ERROR; |
|
374 } |
|
375 ZFREE(z, v); |
|
376 return r; |
|
377 #endif |
|
378 } |
|
379 |
|
380 /* done */ |
|
381 ZFREE(z, v); |
|
382 return Z_OK; |
|
383 } |
|
384 |
|
385 |
|
386 /* build fixed tables only once--keep them here */ |
|
387 #ifdef BUILDFIXED |
|
388 local int fixed_built = 0; |
|
389 #define FIXEDH 544 /* number of hufts used by fixed tables */ |
|
390 local inflate_huft fixed_mem[FIXEDH]; |
|
391 local uInt fixed_bl; |
|
392 local uInt fixed_bd; |
|
393 local inflate_huft *fixed_tl; |
|
394 local inflate_huft *fixed_td; |
|
395 #else |
|
396 #include "inffixed.h" |
|
397 #endif |
|
398 |
|
399 |
|
400 int inflate_trees_fixed( |
|
401 uIntf *bl, /* literal desired/actual bit depth */ |
|
402 uIntf *bd, /* distance desired/actual bit depth */ |
|
403 const inflate_huft * FAR *tl, /* literal/length tree result */ |
|
404 const inflate_huft * FAR *td, /* distance tree result */ |
|
405 z_streamp /*z*/) /* for memory allocation */ |
|
406 { |
|
407 #ifdef BUILDFIXED |
|
408 /* build fixed tables if not already */ |
|
409 if (!fixed_built) |
|
410 { |
|
411 int k; /* temporary variable */ |
|
412 uInt f = 0; /* number of hufts used in fixed_mem */ |
|
413 uIntf *c; /* length list for huft_build */ |
|
414 uIntf *v; /* work area for huft_build */ |
|
415 |
|
416 /* allocate memory */ |
|
417 if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) |
|
418 return Z_MEM_ERROR; |
|
419 if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) |
|
420 { |
|
421 ZFREE(z, c); |
|
422 return Z_MEM_ERROR; |
|
423 } |
|
424 |
|
425 /* literal table */ |
|
426 for (k = 0; k < 144; k++) |
|
427 c[k] = 8; |
|
428 for (; k < 256; k++) |
|
429 c[k] = 9; |
|
430 for (; k < 280; k++) |
|
431 c[k] = 7; |
|
432 for (; k < 288; k++) |
|
433 c[k] = 8; |
|
434 fixed_bl = 9; |
|
435 huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, |
|
436 fixed_mem, &f, v); |
|
437 |
|
438 /* distance table */ |
|
439 for (k = 0; k < 30; k++) |
|
440 c[k] = 5; |
|
441 fixed_bd = 5; |
|
442 huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, |
|
443 fixed_mem, &f, v); |
|
444 |
|
445 /* done */ |
|
446 ZFREE(z, v); |
|
447 ZFREE(z, c); |
|
448 fixed_built = 1; |
|
449 } |
|
450 #endif |
|
451 *bl = fixed_bl; |
|
452 *bd = fixed_bd; |
|
453 *tl = fixed_tl; |
|
454 *td = fixed_td; |
|
455 return Z_OK; |
|
456 } |