#
source:
trunk/third/zlib/inftrees.c
@
17315

Revision 17315, 15.6 KB checked in by zacheiss, 22 years ago (diff) |
---|

Line | |
---|---|

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(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), or Z_DATA_ERROR if the input is invalid. */ |

108 | { |

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 | uInt mask; /* (1 << w) - 1, to avoid cc -O bug on HP */ |

120 | register uIntf *p; /* pointer into c[], b[], or v[] */ |

121 | inflate_huft *q; /* points to current table */ |

122 | struct inflate_huft_s r; /* table entry for structure assignment */ |

123 | inflate_huft *u[BMAX]; /* table stack */ |

124 | register int w; /* bits before this table == (l * h) */ |

125 | uInt x[BMAX+1]; /* bit offsets, then code stack */ |

126 | uIntf *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 | n = x[g]; /* set n to length of v */ |

190 | |

191 | |

192 | /* Generate the Huffman codes and for each, make the table entries */ |

193 | x[0] = i = 0; /* first Huffman code is zero */ |

194 | p = v; /* grab values in bit order */ |

195 | h = -1; /* no tables yet--level -1 */ |

196 | w = -l; /* bits decoded == (l * h) */ |

197 | u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */ |

198 | q = (inflate_huft *)Z_NULL; /* ditto */ |

199 | z = 0; /* ditto */ |

200 | |

201 | /* go through the bit lengths (k already is bits in shortest code) */ |

202 | for (; k <= g; k++) |

203 | { |

204 | a = c[k]; |

205 | while (a--) |

206 | { |

207 | /* here i is the Huffman code of length k bits for value *p */ |

208 | /* make tables up to required level */ |

209 | while (k > w + l) |

210 | { |

211 | h++; |

212 | w += l; /* previous table always l bits */ |

213 | |

214 | /* compute minimum size table less than or equal to l bits */ |

215 | z = g - w; |

216 | z = z > (uInt)l ? l : z; /* table size upper limit */ |

217 | if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ |

218 | { /* too few codes for k-w bit table */ |

219 | f -= a + 1; /* deduct codes from patterns left */ |

220 | xp = c + k; |

221 | if (j < z) |

222 | while (++j < z) /* try smaller tables up to z bits */ |

223 | { |

224 | if ((f <<= 1) <= *++xp) |

225 | break; /* enough codes to use up j bits */ |

226 | f -= *xp; /* else deduct codes from patterns */ |

227 | } |

228 | } |

229 | z = 1 << j; /* table entries for j-bit table */ |

230 | |

231 | /* allocate new table */ |

232 | if (*hn + z > MANY) /* (note: doesn't matter for fixed) */ |

233 | return Z_DATA_ERROR; /* overflow of MANY */ |

234 | u[h] = q = hp + *hn; |

235 | *hn += z; |

236 | |

237 | /* connect to last table, if there is one */ |

238 | if (h) |

239 | { |

240 | x[h] = i; /* save pattern for backing up */ |

241 | r.bits = (Byte)l; /* bits to dump before this table */ |

242 | r.exop = (Byte)j; /* bits in this table */ |

243 | j = i >> (w - l); |

244 | r.base = (uInt)(q - u[h-1] - j); /* offset to this table */ |

245 | u[h-1][j] = r; /* connect to last table */ |

246 | } |

247 | else |

248 | *t = q; /* first table is returned result */ |

249 | } |

250 | |

251 | /* set up table entry in r */ |

252 | r.bits = (Byte)(k - w); |

253 | if (p >= v + n) |

254 | r.exop = 128 + 64; /* out of values--invalid code */ |

255 | else if (*p < s) |

256 | { |

257 | r.exop = (Byte)(*p < 256 ? 0 : 32 + 64); /* 256 is end-of-block */ |

258 | r.base = *p++; /* simple code is just the value */ |

259 | } |

260 | else |

261 | { |

262 | r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */ |

263 | r.base = d[*p++ - s]; |

264 | } |

265 | |

266 | /* fill code-like entries with r */ |

267 | f = 1 << (k - w); |

268 | for (j = i >> w; j < z; j += f) |

269 | q[j] = r; |

270 | |

271 | /* backwards increment the k-bit code i */ |

272 | for (j = 1 << (k - 1); i & j; j >>= 1) |

273 | i ^= j; |

274 | i ^= j; |

275 | |

276 | /* backup over finished tables */ |

277 | mask = (1 << w) - 1; /* needed on HP, cc -O bug */ |

278 | while ((i & mask) != x[h]) |

279 | { |

280 | h--; /* don't need to update q */ |

281 | w -= l; |

282 | mask = (1 << w) - 1; |

283 | } |

284 | } |

285 | } |

286 | |

287 | |

288 | /* Return Z_BUF_ERROR if we were given an incomplete table */ |

289 | return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK; |

290 | } |

291 | |

292 | |

293 | int inflate_trees_bits(c, bb, tb, hp, z) |

294 | uIntf *c; /* 19 code lengths */ |

295 | uIntf *bb; /* bits tree desired/actual depth */ |

296 | inflate_huft * FAR *tb; /* bits tree result */ |

297 | inflate_huft *hp; /* space for trees */ |

298 | z_streamp z; /* for messages */ |

299 | { |

300 | int r; |

301 | uInt hn = 0; /* hufts used in space */ |

302 | uIntf *v; /* work area for huft_build */ |

303 | |

304 | if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL) |

305 | return Z_MEM_ERROR; |

306 | r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, |

307 | tb, bb, hp, &hn, v); |

308 | if (r == Z_DATA_ERROR) |

309 | z->msg = (char*)"oversubscribed dynamic bit lengths tree"; |

310 | else if (r == Z_BUF_ERROR || *bb == 0) |

311 | { |

312 | z->msg = (char*)"incomplete dynamic bit lengths tree"; |

313 | r = Z_DATA_ERROR; |

314 | } |

315 | ZFREE(z, v); |

316 | return r; |

317 | } |

318 | |

319 | |

320 | int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z) |

321 | uInt nl; /* number of literal/length codes */ |

322 | uInt nd; /* number of distance codes */ |

323 | uIntf *c; /* that many (total) code lengths */ |

324 | uIntf *bl; /* literal desired/actual bit depth */ |

325 | uIntf *bd; /* distance desired/actual bit depth */ |

326 | inflate_huft * FAR *tl; /* literal/length tree result */ |

327 | inflate_huft * FAR *td; /* distance tree result */ |

328 | inflate_huft *hp; /* space for trees */ |

329 | z_streamp z; /* for messages */ |

330 | { |

331 | int r; |

332 | uInt hn = 0; /* hufts used in space */ |

333 | uIntf *v; /* work area for huft_build */ |

334 | |

335 | /* allocate work area */ |

336 | if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) |

337 | return Z_MEM_ERROR; |

338 | |

339 | /* build literal/length tree */ |

340 | r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v); |

341 | if (r != Z_OK || *bl == 0) |

342 | { |

343 | if (r == Z_DATA_ERROR) |

344 | z->msg = (char*)"oversubscribed literal/length tree"; |

345 | else if (r != Z_MEM_ERROR) |

346 | { |

347 | z->msg = (char*)"incomplete literal/length tree"; |

348 | r = Z_DATA_ERROR; |

349 | } |

350 | ZFREE(z, v); |

351 | return r; |

352 | } |

353 | |

354 | /* build distance tree */ |

355 | r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v); |

356 | if (r != Z_OK || (*bd == 0 && nl > 257)) |

357 | { |

358 | if (r == Z_DATA_ERROR) |

359 | z->msg = (char*)"oversubscribed distance tree"; |

360 | else if (r == Z_BUF_ERROR) { |

361 | #ifdef PKZIP_BUG_WORKAROUND |

362 | r = Z_OK; |

363 | } |

364 | #else |

365 | z->msg = (char*)"incomplete distance tree"; |

366 | r = Z_DATA_ERROR; |

367 | } |

368 | else if (r != Z_MEM_ERROR) |

369 | { |

370 | z->msg = (char*)"empty distance tree with lengths"; |

371 | r = Z_DATA_ERROR; |

372 | } |

373 | ZFREE(z, v); |

374 | return r; |

375 | #endif |

376 | } |

377 | |

378 | /* done */ |

379 | ZFREE(z, v); |

380 | return Z_OK; |

381 | } |

382 | |

383 | |

384 | /* build fixed tables only once--keep them here */ |

385 | #ifdef BUILDFIXED |

386 | local int fixed_built = 0; |

387 | #define FIXEDH 544 /* number of hufts used by fixed tables */ |

388 | local inflate_huft fixed_mem[FIXEDH]; |

389 | local uInt fixed_bl; |

390 | local uInt fixed_bd; |

391 | local inflate_huft *fixed_tl; |

392 | local inflate_huft *fixed_td; |

393 | #else |

394 | #include "inffixed.h" |

395 | #endif |

396 | |

397 | |

398 | int inflate_trees_fixed(bl, bd, tl, td, z) |

399 | uIntf *bl; /* literal desired/actual bit depth */ |

400 | uIntf *bd; /* distance desired/actual bit depth */ |

401 | inflate_huft * FAR *tl; /* literal/length tree result */ |

402 | inflate_huft * FAR *td; /* distance tree result */ |

403 | z_streamp z; /* for memory allocation */ |

404 | { |

405 | #ifdef BUILDFIXED |

406 | /* build fixed tables if not already */ |

407 | if (!fixed_built) |

408 | { |

409 | int k; /* temporary variable */ |

410 | uInt f = 0; /* number of hufts used in fixed_mem */ |

411 | uIntf *c; /* length list for huft_build */ |

412 | uIntf *v; /* work area for huft_build */ |

413 | |

414 | /* allocate memory */ |

415 | if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) |

416 | return Z_MEM_ERROR; |

417 | if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) |

418 | { |

419 | ZFREE(z, c); |

420 | return Z_MEM_ERROR; |

421 | } |

422 | |

423 | /* literal table */ |

424 | for (k = 0; k < 144; k++) |

425 | c[k] = 8; |

426 | for (; k < 256; k++) |

427 | c[k] = 9; |

428 | for (; k < 280; k++) |

429 | c[k] = 7; |

430 | for (; k < 288; k++) |

431 | c[k] = 8; |

432 | fixed_bl = 9; |

433 | huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, |

434 | fixed_mem, &f, v); |

435 | |

436 | /* distance table */ |

437 | for (k = 0; k < 30; k++) |

438 | c[k] = 5; |

439 | fixed_bd = 5; |

440 | huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, |

441 | fixed_mem, &f, v); |

442 | |

443 | /* done */ |

444 | ZFREE(z, v); |

445 | ZFREE(z, c); |

446 | fixed_built = 1; |

447 | } |

448 | #endif |

449 | *bl = fixed_bl; |

450 | *bd = fixed_bd; |

451 | *tl = fixed_tl; |

452 | *td = fixed_td; |

453 | return Z_OK; |

454 | } |

**Note:**See TracBrowser for help on using the repository browser.