Lines Matching refs:codes
318 /* number of length codes, not counting the special END_BLOCK code */
324 /* number of Literal or Length codes, including the END_BLOCK code */
327 /* number of distance codes */
330 /* number of codes used to transfer the bit lengths */
336 /* All codes must not exceed MAX_BITS bits */
483 /* number of codes at each bit length for an optimal tree */
825 * output size for (length,distance) codes is <= 24 bits.
1993 /* Bit length codes must not exceed MAX_BL_BITS bits */
2018 /* The lengths of the bit length codes are sent in order of decreasing
2019 * probability, to avoid transmitting the lengths for unused bit length codes.
2038 * need for the L_CODES extra codes used during heap construction. However
2039 * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
2044 /* The static distance tree. (Actually a trivial tree since all codes use
2049 /* Distance codes. The first 256 values correspond to the distances
2201 int max_length; /* max bit length for the codes */
2337 /* number of codes at each bit length for an optimal tree */
2395 /* Construct the codes of the static literal tree */
2673 * Generate the codes for a given tree and bit counts (which need not be
2682 * ushf *bl_count; number of codes at each bit length
2752 * two codes of non zero frequency.
2802 /* The field len is now set, we can generate the bit codes */
2807 * Scan a literal or distance tree to determine the frequencies of the codes
2853 * Send a literal or distance tree in compressed form, using the codes in
2920 * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
2923 /* Determine the number of bit length codes to send. The pkzip format
2924 * requires that at least 4 bit length codes be sent. (appnote.txt says
2940 * lengths of the bit length codes, the literal tree and the distance tree.
2948 Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
2950 "too many codes");
2990 * last two codes for the previous block (real code plus EOB) were coded
3796 uInt, /* number of literal/length codes */
3797 uInt, /* number of distance codes */
3845 /* infutil.h -- types and macros common to blocks and codes
3883 uIntf *blens; /* bit lengths of codes */
3889 *codes;
3974 codes exist, they are coded using one bit each (0 and 1).
3975 5. There is no way of sending zero distance codes--a dummy must be
3977 store blocks with no distance codes, but this was discovered to be
3979 zero distance codes, which is sent as one code of zero bits in
3981 6. There are up to 286 literal/length codes. Code 256 represents the
3983 288 codes just to fill out the Huffman codes. Codes 286 and 287
3985 defined for them. Similarily, there are up to 30 distance codes.
3986 However, static trees define 32 codes (all 5 bits) to fill out the
3987 Huffman codes, but the last two had better not show up in the data.
3991 literal codes sent minus 257.
3992 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
3994 three codes (1+1+1), whereas to output four times the same length,
3995 you only need two codes (1+3). Hmm.
3998 11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19)
4020 inflate_codes_free(s->sub.decode.codes, z);
4096 Tracev((stderr, "inflate: fixed codes block%s\n",
4103 s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
4104 if (s->sub.decode.codes == Z_NULL)
4114 Tracev((stderr, "inflate: dynamic codes block%s\n",
4276 s->sub.decode.codes = c;
4285 inflate_codes_free(s->sub.decode.codes, z);
4287 Tracev((stderr, "inflate: codes end, %lu total out\n",
4382 uInt, /* number of codes */
4383 uInt, /* number of "simple" codes */
4384 const uIntf *, /* list of base values for non-simple codes */
4385 const uIntf *, /* list of extra bits for non-simple codes */
4393 static const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
4397 static const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
4400 static const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
4404 static const uInt cpdext[30] = { /* Extra bits for distance codes */
4414 is not very long. The most common codes are necessarily the
4415 shortest codes, so those codes dominate the decoding time, and hence
4417 shorter, more probable codes, and then point to subsidiary tables for
4418 the longer codes. The time it costs to decode the longer codes is
4423 length codes can decode in one step, and dbits is the same thing for
4424 the distance codes. Subsequent tables are also less than or equal to
4426 codes are shorter than that, in which case the longest code length in
4433 codes 286 possible values, or in a flat code, a little over eight
4434 bits. The distance table codes 30 possible values, or a little less
4446 tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
4451 uInt n; /* number of codes (assumed <= 288) */
4452 uInt s; /* number of simple-valued codes (0..s-1) */
4453 const uIntf *d; /* list of base values for non-simple codes */
4454 const uIntf *e; /* list of extra bits for non-simple codes */
4467 uInt a; /* counter for codes of length k */
4484 int y; /* number of dummy codes added */
4498 if (c[0] == n) /* null input--all zero length codes */
4523 /* Adjust last length count to fill out codes, if needed */
4549 /* Generate the Huffman codes and for each, make the table entries */
4575 { /* too few codes for k-w bit table */
4576 f -= a + 1; /* deduct codes from patterns left */
4582 break; /* enough codes to use up j bits */
4583 f -= *xp; /* else deduct codes from patterns */
4678 uInt nl; /* number of literal/length codes */
4679 uInt nd; /* number of distance codes */
4752 /* inffixed.h -- table for decoding fixed codes
5022 /* inflate codes private state */
5067 Tracev((stderr, "inflate: codes new\n"));
5088 inflate_codes_statef *c = s->sub.decode.codes; /* codes state */
5242 Tracev((stderr, "inflate: codes free\n"));
5247 /* inflate_util.c -- data and routines common to blocks and codes