internal void gen_bitlen(DeflateManager s)
{
short[] tree = dyn_tree;
short[] stree = stat_desc.static_tree;
int[] extra = stat_desc.extra_bits;
int base_Renamed = stat_desc.extra_base;
int max_length = stat_desc.max_length;
int h; // heap index
int n, m; // iterate over the tree elements
int bits; // bit length
int xbits; // extra bits
short f; // frequency
int overflow = 0; // number of elements with bit length too large
for (bits = 0; bits <= MAX_BITS; bits++)
s.bl_count [bits] = 0;
// In a first pass, compute the optimal bit lengths (which may
// overflow in the case of the bit length tree).
tree [s.heap [s.heap_max] * 2 + 1] = 0; // root of the heap
for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
n = s.heap [h];
bits = tree [tree [n * 2 + 1] * 2 + 1] + 1;
if (bits > max_length) {
bits = max_length;
overflow++;
}
tree [n * 2 + 1] = (short)bits;
// We overwrite tree[n*2+1] which is no longer needed
if (n > max_code)
continue; // not a leaf node
s.bl_count [bits]++;
xbits = 0;
if (n >= base_Renamed)
xbits = extra [n - base_Renamed];
f = tree [n * 2];
s.opt_len += f * (bits + xbits);
if (stree != null)
s.static_len += f * (stree [n * 2 + 1] + xbits);
}
if (overflow == 0)
return;
// This happens for example on obj2 and pic of the Calgary corpus
// Find the first bit length which could increase:
do {
bits = max_length - 1;
while (s.bl_count[bits] == 0)
bits--;
s.bl_count [bits]--; // move one leaf down the tree
s.bl_count [bits + 1] = (short)(s.bl_count [bits + 1] + 2); // move one overflow item as its brother
s.bl_count [max_length]--;
// The brother of the overflow item also moves one step up,
// but this does not affect bl_count[max_length]
overflow -= 2;
} while (overflow > 0);
for (bits = max_length; bits != 0; bits--) {
n = s.bl_count [bits];
while (n != 0) {
m = s.heap [--h];
if (m > max_code)
continue;
if (tree [m * 2 + 1] != bits) {
s.opt_len = (int)(s.opt_len + ((long)bits - (long)tree [m * 2 + 1]) * (long)tree [m * 2]);
tree [m * 2 + 1] = (short)bits;
}
n--;
}
}
}