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(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
    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 - (long) 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 }