Lines Matching refs:code
13 * Each code tree is stored in a compressed form which is itself
14 * a Huffman encoding of the lengths of all the code strings (in
15 * ascending order by source values). The actual code strings are
51 /* end of block literal code */
62 local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
65 local const int extra_dbits[D_CODES] /* extra bits for each distance code */
68 local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
105 /* length code for each normalized match length (0 == MIN_MATCH) */
108 /* First normalized length for each code (0 = MIN_MATCH) */
111 /* First normalized distance for each code (0 = distance of 1) */
119 const intf *extra_bits; /* extra bits for each code or NULL */
150 * Reverse the first len bits of a code, using straightforward code (a faster
154 local unsigned bi_reverse(unsigned code, int len) {
157 res |= code & 1;
158 code >>= 1, res <<= 1;
199 * OUT assertion: the field code is set for all tree elements of non
200 * zero code length.
203 ush next_code[MAX_BITS+1]; /* next code value for each bit length */
204 unsigned code = 0; /* running code value */
206 int n; /* code index */
208 /* The distribution counts are first used to generate the code values
212 code = (code + bl_count[bits - 1]) << 1;
213 next_code[bits] = (ush)code;
215 /* Check that the bit counts in bl_count are consistent. The last code
218 Assert (code + bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1,
239 /* Send a code of the given tree. c and tree must not have side effects */
300 int code; /* code value */
316 /* Initialize the mapping length (0..255) -> length code (0..28) */
318 for (code = 0; code < LENGTH_CODES-1; code++) {
319 base_length[code] = length;
320 for (n = 0; n < (1 << extra_lbits[code]); n++) {
321 _length_code[length++] = (uch)code;
326 * in two different ways: code 284 + 5 bits or code 285, so we
329 _length_code[length - 1] = (uch)code;
331 /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
333 for (code = 0 ; code < 16; code++) {
334 base_dist[code] = dist;
335 for (n = 0; n < (1 << extra_dbits[code]); n++) {
336 _dist_code[dist++] = (uch)code;
341 for ( ; code < D_CODES; code++) {
342 base_dist[code] = dist << 7;
343 for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
344 _dist_code[256 + dist++] = (uch)code;
357 * tree construction to get a canonical Huffman tree (longest code
604 Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
618 * Construct one Huffman tree and assigns the code bit strings and lengths.
621 * OUT assertions: the fields len and code are set to the optimal bit length
622 * and corresponding code. The length opt_len is updated; static_len is
630 int max_code = -1; /* largest code with non zero frequency */
648 /* The pkzip format requires that at least one distance code exists,
650 * possible code. So to avoid special checks later on we force at least
713 int curlen; /* length of current code */
714 int nextlen = tree[0].Len; /* length of next code */
715 int count = 0; /* repeat count of the current code */
754 int curlen; /* length of current code */
755 int nextlen = tree[0].Len; /* length of next code */
756 int count = 0; /* repeat count of the current code */
796 * bl_order of the last bit length code to send.
799 int max_blindex; /* index of last bit length code of non zero freq */
843 Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
903 unsigned code; /* the code to send */
920 code = _length_code[lc];
921 send_code(s, code + LITERALS + 1, ltree); /* send length code */
922 extra = extra_lbits[code];
924 lc -= base_length[code];
928 code = d_code(dist);
929 Assert (code < D_CODES, "bad d_code");
931 send_code(s, code, dtree); /* send the distance code */
932 extra = extra_dbits[code];
934 dist -= (unsigned)base_dist[code];
999 int max_blindex = 0; /* index of last bit length code of non zero freq */
1021 * in bl_order of the last bit length code to send.