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 13const 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 */ 21struct 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 28local 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. */ 41local 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 */ 45local 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 */ 48local 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}; 52local 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 93local int huft_build(b, n, s, d, e, t, m, hp, hn, v) 94uIntf *b; /* code lengths in bits (all assumed <= BMAX) */ 95uInt n; /* number of codes (assumed <= 288) */ 96uInt s; /* number of simple-valued codes (0..s-1) */ 97const uIntf *d; /* list of base values for non-simple codes */ 98const uIntf *e; /* list of extra bits for non-simple codes */ 99inflate_huft * FAR *t; /* result: starting table */ 100uIntf *m; /* maximum lookup bits, returns actual */ 101inflate_huft *hp; /* space for trees */ 102uInt *hn; /* hufts used in space */ 103uIntf *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; 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_MEM_ERROR; /* not enough memory */ 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 295int inflate_trees_bits(c, bb, tb, hp, z) 296uIntf *c; /* 19 code lengths */ 297uIntf *bb; /* bits tree desired/actual depth */ 298inflate_huft * FAR *tb; /* bits tree result */ 299inflate_huft *hp; /* space for trees */ 300z_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 322int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z) 323uInt nl; /* number of literal/length codes */ 324uInt nd; /* number of distance codes */ 325uIntf *c; /* that many (total) code lengths */ 326uIntf *bl; /* literal desired/actual bit depth */ 327uIntf *bd; /* distance desired/actual bit depth */ 328inflate_huft * FAR *tl; /* literal/length tree result */ 329inflate_huft * FAR *td; /* distance tree result */ 330inflate_huft *hp; /* space for trees */ 331z_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 388local int fixed_built = 0; 389#define FIXEDH 544 /* number of hufts used by fixed tables */ 390local inflate_huft fixed_mem[FIXEDH]; 391local uInt fixed_bl; 392local uInt fixed_bd; 393local inflate_huft *fixed_tl; 394local inflate_huft *fixed_td; 395#else 396#include "inffixed.h" 397#endif 398 399 400int inflate_trees_fixed(bl, bd, tl, td, z) 401uIntf *bl; /* literal desired/actual bit depth */ 402uIntf *bd; /* distance desired/actual bit depth */ 403inflate_huft * FAR *tl; /* literal/length tree result */ 404inflate_huft * FAR *td; /* distance tree result */ 405z_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} 457