View Javadoc
1   /*
2    * Copyright 2012 The Netty Project
3    *
4    * The Netty Project licenses this file to you under the Apache License,
5    * version 2.0 (the "License"); you may not use this file except in compliance
6    * with the License. You may obtain a copy of the License at:
7    *
8    *   http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13   * License for the specific language governing permissions and limitations
14   * under the License.
15   */
16  /*
17  Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
18  
19  Redistribution and use in source and binary forms, with or without
20  modification, are permitted provided that the following conditions are met:
21  
22    1. Redistributions of source code must retain the above copyright notice,
23       this list of conditions and the following disclaimer.
24  
25    2. Redistributions in binary form must reproduce the above copyright
26       notice, this list of conditions and the following disclaimer in
27       the documentation and/or other materials provided with the distribution.
28  
29    3. The names of the authors may not be used to endorse or promote products
30       derived from this software without specific prior written permission.
31  
32  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
33  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
34  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
35  INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
36  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
37  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
38  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
39  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
40  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
41  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42   */
43  /*
44   * This program is based on zlib-1.1.3, so all credit should go authors
45   * Jean-loup Gailly([email protected]) and Mark Adler([email protected])
46   * and contributors of zlib.
47   */
48  package org.jboss.netty.util.internal.jzlib;
49  
50  final class Tree {
51      // extra bits for each length code
52      static final int[] extra_lbits = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2,
53              2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 };
54  
55      // extra bits for each distance code
56      static final int[] extra_dbits = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5,
57              5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 };
58  
59      // extra bits for each bit length code
60      static final int[] extra_blbits = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
61              0, 0, 0, 2, 3, 7 };
62  
63      static final byte[] bl_order = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4,
64              12, 3, 13, 2, 14, 1, 15 };
65  
66      static final byte[] _dist_code = { 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7,
67              7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10,
68              10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11,
69              11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12,
70              12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
71              12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13,
72              13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
73              13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14,
74              14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
75              14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
76              14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
77              14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
78              15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
79              15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
80              15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
81              15, 0, 0, 16, 17, 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21,
82              22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 24,
83              24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25,
84              25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26,
85              26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
86              26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27,
87              27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
88              27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28,
89              28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
90              28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
91              28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
92              28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
93              29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
94              29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
95              29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
96              29, 29 };
97  
98      static final byte[] _length_code = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9,
99              10, 10, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15,
100             15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17,
101             17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19,
102             19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
103             21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22,
104             22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23,
105             23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24,
106             24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
107             24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25,
108             25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
109             25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26,
110             26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
111             26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27,
112             27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
113             27, 27, 27, 27, 27, 28 };
114 
115     static final int[] base_length = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14,
116             16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192,
117             224, 0 };
118 
119     static final int[] base_dist = { 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48,
120             64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096,
121             6144, 8192, 12288, 16384, 24576 };
122 
123     // Mapping from a distance to a distance code. dist is the distance - 1 and
124     // must not have side effects. _dist_code[256] and _dist_code[257] are never
125     // used.
126     static int d_code(int dist) {
127         return dist < 256? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
128     }
129 
130     short[] dyn_tree; // the dynamic tree
131     int max_code; // largest code with non zero frequency
132     StaticTree stat_desc; // the corresponding static tree
133 
134     // Compute the optimal bit lengths for a tree and update the total bit length
135     // for the current block.
136     // IN assertion: the fields freq and dad are set, heap[heap_max] and
137     //    above are the tree nodes sorted by increasing frequency.
138     // OUT assertions: the field len is set to the optimal bit length, the
139     //     array bl_count contains the frequencies for each bit length.
140     //     The length opt_len is updated; static_len is also updated if stree is
141     //     not null.
142     private void gen_bitlen(Deflate s) {
143         short[] tree = dyn_tree;
144         short[] stree = stat_desc.static_tree;
145         int[] extra = stat_desc.extra_bits;
146         int base = stat_desc.extra_base;
147         int max_length = stat_desc.max_length;
148         int h; // heap index
149         int n, m; // iterate over the tree elements
150         int bits; // bit length
151         int xbits; // extra bits
152         short f; // frequency
153         int overflow = 0; // number of elements with bit length too large
154 
155         for (bits = 0; bits <= JZlib.MAX_BITS; bits ++) {
156             s.bl_count[bits] = 0;
157         }
158 
159         // In a first pass, compute the optimal bit lengths (which may
160         // overflow in the case of the bit length tree).
161         tree[s.heap[s.heap_max] * 2 + 1] = 0; // root of the heap
162 
163         for (h = s.heap_max + 1; h < JZlib.HEAP_SIZE; h ++) {
164             n = s.heap[h];
165             bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
166             if (bits > max_length) {
167                 bits = max_length;
168                 overflow ++;
169             }
170             tree[n * 2 + 1] = (short) bits;
171             // We overwrite tree[n*2+1] which is no longer needed
172 
173             if (n > max_code) {
174                 continue; // not a leaf node
175             }
176 
177             s.bl_count[bits] ++;
178             xbits = 0;
179             if (n >= base) {
180                 xbits = extra[n - base];
181             }
182             f = tree[n * 2];
183             s.opt_len += f * (bits + xbits);
184             if (stree != null) {
185                 s.static_len += f * (stree[n * 2 + 1] + xbits);
186             }
187         }
188         if (overflow == 0) {
189             return;
190         }
191 
192         // This happens for example on obj2 and pic of the Calgary corpus
193         // Find the first bit length which could increase:
194         do {
195             bits = max_length - 1;
196             while (s.bl_count[bits] == 0) {
197                 bits --;
198             }
199             s.bl_count[bits] --; // move one leaf down the tree
200             s.bl_count[bits + 1] += 2; // move one overflow item as its brother
201             s.bl_count[max_length] --;
202             // The brother of the overflow item also moves one step up,
203             // but this does not affect bl_count[max_length]
204             overflow -= 2;
205         } while (overflow > 0);
206 
207         for (bits = max_length; bits != 0; bits --) {
208             n = s.bl_count[bits];
209             while (n != 0) {
210                 m = s.heap[-- h];
211                 if (m > max_code) {
212                     continue;
213                 }
214                 if (tree[m * 2 + 1] != bits) {
215                     s.opt_len += ((long) bits - tree[m * 2 + 1]) *
216                             tree[m * 2];
217                     tree[m * 2 + 1] = (short) bits;
218                 }
219                 n --;
220             }
221         }
222     }
223 
224     // Construct one Huffman tree and assigns the code bit strings and lengths.
225     // Update the total bit length for the current block.
226     // IN assertion: the field freq is set for all tree elements.
227     // OUT assertions: the fields len and code are set to the optimal bit length
228     //     and corresponding code. The length opt_len is updated; static_len is
229     //     also updated if stree is not null. The field max_code is set.
230     void build_tree(Deflate s) {
231         short[] tree = dyn_tree;
232         short[] stree = stat_desc.static_tree;
233         int elems = stat_desc.elems;
234         int n, m; // iterate over heap elements
235         int max_code = -1; // largest code with non zero frequency
236         int node; // new node being created
237 
238         // Construct the initial heap, with least frequent element in
239         // heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
240         // heap[0] is not used.
241         s.heap_len = 0;
242         s.heap_max = JZlib.HEAP_SIZE;
243 
244         for (n = 0; n < elems; n ++) {
245             if (tree[n * 2] != 0) {
246                 s.heap[++ s.heap_len] = max_code = n;
247                 s.depth[n] = 0;
248             } else {
249                 tree[n * 2 + 1] = 0;
250             }
251         }
252 
253         // The pkzip format requires that at least one distance code exists,
254         // and that at least one bit should be sent even if there is only one
255         // possible code. So to avoid special checks later on we force at least
256         // two codes of non zero frequency.
257         while (s.heap_len < 2) {
258             node = s.heap[++ s.heap_len] = max_code < 2? ++ max_code : 0;
259             tree[node * 2] = 1;
260             s.depth[node] = 0;
261             s.opt_len --;
262             if (stree != null) {
263                 s.static_len -= stree[node * 2 + 1];
264                 // node is 0 or 1 so it does not have extra bits
265             }
266         }
267         this.max_code = max_code;
268 
269         // The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
270         // establish sub-heaps of increasing lengths:
271 
272         for (n = s.heap_len / 2; n >= 1; n --) {
273             s.pqdownheap(tree, n);
274         }
275 
276         // Construct the Huffman tree by repeatedly combining the least two
277         // frequent nodes.
278 
279         node = elems; // next internal node of the tree
280         do {
281             // n = node of least frequency
282             n = s.heap[1];
283             s.heap[1] = s.heap[s.heap_len --];
284             s.pqdownheap(tree, 1);
285             m = s.heap[1]; // m = node of next least frequency
286 
287             s.heap[-- s.heap_max] = n; // keep the nodes sorted by frequency
288             s.heap[-- s.heap_max] = m;
289 
290             // Create a new node father of n and m
291             tree[node * 2] = (short) (tree[n * 2] + tree[m * 2]);
292             s.depth[node] = (byte) (Math.max(s.depth[n], s.depth[m]) + 1);
293             tree[n * 2 + 1] = tree[m * 2 + 1] = (short) node;
294 
295             // and insert the new node in the heap
296             s.heap[1] = node ++;
297             s.pqdownheap(tree, 1);
298         } while (s.heap_len >= 2);
299 
300         s.heap[-- s.heap_max] = s.heap[1];
301 
302         // At this point, the fields freq and dad are set. We can now
303         // generate the bit lengths.
304 
305         gen_bitlen(s);
306 
307         // The field len is now set, we can generate the bit codes
308         gen_codes(tree, max_code, s.bl_count);
309     }
310 
311     // Generate the codes for a given tree and bit counts (which need not be
312     // optimal).
313     // IN assertion: the array bl_count contains the bit length statistics for
314     // the given tree and the field len is set for all tree elements.
315     // OUT assertion: the field code is set for all tree elements of non
316     //     zero code length.
317     private static void gen_codes(short[] tree, // the tree to decorate
318             int max_code, // largest code with non zero frequency
319             short[] bl_count // number of codes at each bit length
320     ) {
321         short[] next_code = new short[JZlib.MAX_BITS + 1]; // next code value for each bit length
322         short code = 0; // running code value
323         int bits; // bit index
324         int n; // code index
325 
326         // The distribution counts are first used to generate the code values
327         // without bit reversal.
328         for (bits = 1; bits <= JZlib.MAX_BITS; bits ++) {
329             next_code[bits] = code = (short) (code + bl_count[bits - 1] << 1);
330         }
331 
332         // Check that the bit counts in bl_count are consistent. The last code
333         // must be all ones.
334         //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
335         //        "inconsistent bit counts");
336         //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
337 
338         for (n = 0; n <= max_code; n ++) {
339             int len = tree[n * 2 + 1];
340             if (len == 0) {
341                 continue;
342             }
343             // Now reverse the bits
344             tree[n * 2] = (short) bi_reverse(next_code[len] ++, len);
345         }
346     }
347 
348     // Reverse the first len bits of a code, using straightforward code (a faster
349     // method would use a table)
350     // IN assertion: 1 <= len <= 15
351     private static int bi_reverse(int code, // the value to invert
352             int len // its bit length
353     ) {
354         int res = 0;
355         do {
356             res |= code & 1;
357             code >>>= 1;
358             res <<= 1;
359         } while (-- len > 0);
360         return res >>> 1;
361     }
362 }