public int deflateEnd()
{
if (this.dstate == null)
{
return(-2);
}
int arg_1D_0 = this.dstate.deflateEnd();
this.dstate = null;
return(arg_1D_0);
}
public int deflateEnd()
{
if (this.dstate == null)
{
return(-2);
}
int result = this.dstate.deflateEnd();
this.dstate = null;
return(result);
}
public int deflateEnd()
{
if (dstate == null)
{
return(Z_STREAM_ERROR);
}
int ret = dstate.deflateEnd();
dstate = null;
return(ret);
}
internal void pqdownheap(short[] tree, int k)
{
int num1 = this.heap[k];
for (int num2 = k << 1; num2 <= this.heap_len; num2 = num2 << 1)
{
if ((num2 < this.heap_len) && Deflate.smaller(tree, this.heap[num2 + 1], this.heap[num2], this.depth))
{
num2++;
}
if (Deflate.smaller(tree, num1, this.heap[num2], this.depth))
{
break;
}
this.heap[k] = this.heap[num2];
k = num2;
}
this.heap[k] = num1;
}
internal void pqdownheap(short[] tree, int k)
{
int num = this.heap[k];
for (int i = k << 1; i <= this.heap_len; i <<= 1)
{
if (i < this.heap_len && Deflate.smaller(tree, this.heap[i + 1], this.heap[i], this.depth))
{
i++;
}
if (Deflate.smaller(tree, num, this.heap[i], this.depth))
{
break;
}
this.heap[k] = this.heap[i];
k = i;
}
this.heap[k] = num;
}
internal void gen_bitlen(Deflate s)
{
short[] array = this.dyn_tree;
short[] static_tree = this.stat_desc.static_tree;
int[] extra_bits = this.stat_desc.extra_bits;
int extra_base = this.stat_desc.extra_base;
int max_length = this.stat_desc.max_length;
int num = 0;
for (int i = 0; i <= 15; i++)
{
s.bl_count[i] = 0;
}
array[s.heap[s.heap_max] * 2 + 1] = 0;
int j;
for (j = s.heap_max + 1; j < Tree.HEAP_SIZE; j++)
{
int num2 = s.heap[j];
int i = (int)(array[(int)(array[num2 * 2 + 1] * 2 + 1)] + 1);
if (i > max_length)
{
i = max_length;
num++;
}
array[num2 * 2 + 1] = (short)i;
if (num2 <= this.max_code)
{
short[] expr_C8_cp_0 = s.bl_count;
int expr_C8_cp_1 = i;
expr_C8_cp_0[expr_C8_cp_1] += 1;
int num3 = 0;
if (num2 >= extra_base)
{
num3 = extra_bits[num2 - extra_base];
}
short num4 = array[num2 * 2];
s.opt_len += (int)num4 * (i + num3);
if (static_tree != null)
{
s.static_len += (int)num4 * ((int)static_tree[num2 * 2 + 1] + num3);
}
}
}
if (num == 0)
{
return;
}
do
{
int i = max_length - 1;
while (s.bl_count[i] == 0)
{
i--;
}
short[] expr_156_cp_0 = s.bl_count;
int expr_156_cp_1 = i;
expr_156_cp_0[expr_156_cp_1] -= 1;
s.bl_count[i + 1] = (short)(s.bl_count[i + 1] + 2);
short[] expr_182_cp_0 = s.bl_count;
int expr_182_cp_1 = max_length;
expr_182_cp_0[expr_182_cp_1] -= 1;
num -= 2;
}while (num > 0);
for (int i = max_length; i != 0; i--)
{
int num2 = (int)s.bl_count[i];
while (num2 != 0)
{
int num5 = s.heap[--j];
if (num5 <= this.max_code)
{
if ((int)array[num5 * 2 + 1] != i)
{
s.opt_len = (int)((long)s.opt_len + ((long)i - (long)array[num5 * 2 + 1]) * (long)array[num5 * 2]);
array[num5 * 2 + 1] = (short)i;
}
num2--;
}
}
}
}
internal void gen_bitlen(Deflate s)
{
int num4;
short[] numArray1 = this.dyn_tree;
short[] numArray2 = this.stat_desc.static_tree;
int[] numArray3 = this.stat_desc.extra_bits;
int num1 = this.stat_desc.extra_base;
int num2 = this.stat_desc.max_length;
int num6 = 0;
int num5 = 0;
while (num5 <= 15)
{
s.bl_count[num5] = 0;
num5++;
}
numArray1[(s.heap[s.heap_max] * 2) + 1] = 0;
int num3 = s.heap_max + 1;
while (num3 < Tree.HEAP_SIZE)
{
num4 = s.heap[num3];
num5 = numArray1[(numArray1[(num4 * 2) + 1] * 2) + 1] + 1;
if (num5 > num2)
{
num5 = num2;
num6++;
}
numArray1[(num4 * 2) + 1] = (short)num5;
if (num4 <= this.max_code)
{
s.bl_count[num5] = (short)(s.bl_count[num5] + 1);
int num7 = 0;
if (num4 >= num1)
{
num7 = numArray3[num4 - num1];
}
short num8 = numArray1[num4 * 2];
s.opt_len += num8 * (num5 + num7);
if (numArray2 != null)
{
s.static_len += num8 * (numArray2[(num4 * 2) + 1] + num7);
}
}
num3++;
}
if (num6 != 0)
{
do
{
num5 = num2 - 1;
while (s.bl_count[num5] == 0)
{
num5--;
}
s.bl_count[num5] = (short)(s.bl_count[num5] - 1);
s.bl_count[num5 + 1] = (short)(s.bl_count[num5 + 1] + 2);
s.bl_count[num2] = (short)(s.bl_count[num2] - 1);
num6 -= 2;
}while (num6 > 0);
for (num5 = num2; num5 != 0; num5--)
{
num4 = s.bl_count[num5];
while (num4 != 0)
{
int num9 = s.heap[--num3];
if (num9 <= this.max_code)
{
if (numArray1[(num9 * 2) + 1] != num5)
{
s.opt_len += (num5 - numArray1[(num9 * 2) + 1]) * numArray1[num9 * 2];
numArray1[(num9 * 2) + 1] = (short)num5;
}
num4--;
}
}
}
}
}
public int deflateEnd()
{
if (dstate == null)
return Z_STREAM_ERROR;
var ret = dstate.deflateEnd();
dstate = null;
return ret;
}
internal void build_tree(Deflate s)
{
short[] array = this.dyn_tree;
short[] static_tree = this.stat_desc.static_tree;
int elems = this.stat_desc.elems;
int num = -1;
s.heap_len = 0;
s.heap_max = Tree.HEAP_SIZE;
int num2;
for (int i = 0; i < elems; i++)
{
if (array[i * 2] != 0)
{
int[] arg_5D_0 = s.heap;
num2 = s.heap_len + 1;
s.heap_len = num2;
num = (arg_5D_0[num2] = i);
s.depth[i] = 0;
}
else
{
array[i * 2 + 1] = 0;
}
}
int num3;
while (s.heap_len < 2)
{
int[] arg_A7_0 = s.heap;
num2 = s.heap_len + 1;
s.heap_len = num2;
num3 = (arg_A7_0[num2] = ((num < 2) ? (++num) : 0));
array[num3 * 2] = 1;
s.depth[num3] = 0;
s.opt_len--;
if (static_tree != null)
{
s.static_len -= (int)static_tree[num3 * 2 + 1];
}
}
this.max_code = num;
for (int i = s.heap_len / 2; i >= 1; i--)
{
s.pqdownheap(array, i);
}
num3 = elems;
do
{
int i = s.heap[1];
int[] arg_13D_0 = s.heap;
int arg_13D_1 = 1;
int[] arg_13C_0 = s.heap;
num2 = s.heap_len;
s.heap_len = num2 - 1;
arg_13D_0[arg_13D_1] = arg_13C_0[num2];
s.pqdownheap(array, 1);
int num4 = s.heap[1];
int[] arg_16B_0 = s.heap;
num2 = s.heap_max - 1;
s.heap_max = num2;
arg_16B_0[num2] = i;
int[] arg_188_0 = s.heap;
num2 = s.heap_max - 1;
s.heap_max = num2;
arg_188_0[num2] = num4;
array[num3 * 2] = (short)(array[i * 2] + array[num4 * 2]);
s.depth[num3] = (byte)(Math.Max(s.depth[i], s.depth[num4]) + 1);
array[i * 2 + 1] = (array[num4 * 2 + 1] = (short)num3);
s.heap[1] = num3++;
s.pqdownheap(array, 1);
}while (s.heap_len >= 2);
int[] arg_21A_0 = s.heap;
num2 = s.heap_max - 1;
s.heap_max = num2;
arg_21A_0[num2] = s.heap[1];
this.gen_bitlen(s);
Tree.gen_codes(array, num, s.bl_count);
}
// Construct one Huffman tree and assigns the code bit strings and lengths.
// Update the total bit length for the current block.
// IN assertion: the field freq is set for all tree elements.
// OUT assertions: the fields len and code are set to the optimal bit length
// and corresponding code. The length opt_len is updated; static_len is
// also updated if stree is not null. The field max_code is set.
internal void build_tree(Deflate s)
{
short[] tree = dyn_tree;
short[] stree = stat_desc.static_tree;
int elems = stat_desc.elems;
int n, m; // iterate over heap elements
int max_code = -1; // largest code with non zero frequency
int node; // new node being created
// Construct the initial heap, with least frequent element in
// heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
// heap[0] is not used.
s.heap_len = 0;
s.heap_max = HEAP_SIZE;
for (n = 0; n < elems; n++)
{
if (tree[n * 2] != 0)
{
s.heap[++s.heap_len] = max_code = n;
s.depth[n] = 0;
}
else
{
tree[n * 2 + 1] = 0;
}
}
// The pkzip format requires that at least one distance code exists,
// and that at least one bit should be sent even if there is only one
// possible code. So to avoid special checks later on we force at least
// two codes of non zero frequency.
while (s.heap_len < 2)
{
node = s.heap[++s.heap_len] = (max_code < 2?++max_code:0);
tree[node * 2] = 1;
s.depth[node] = 0;
s.opt_len--;
if (stree != null)
{
s.static_len -= stree[node * 2 + 1];
}
// node is 0 or 1 so it does not have extra bits
}
this.max_code = max_code;
// The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
// establish sub-heaps of increasing lengths:
for (n = s.heap_len / 2; n >= 1; n--)
{
s.pqdownheap(tree, n);
}
// Construct the Huffman tree by repeatedly combining the least two
// frequent nodes.
node = elems; // next internal node of the tree
do
{
// n = node of least frequency
n = s.heap[1];
s.heap[1] = s.heap[s.heap_len--];
s.pqdownheap(tree, 1);
m = s.heap[1]; // m = node of next least frequency
s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency
s.heap[--s.heap_max] = m;
// Create a new node father of n and m
tree[node * 2] = (short)(tree[n * 2] + tree[m * 2]);
s.depth[node] = (byte)(System.Math.Max((byte)s.depth[n], (byte)s.depth[m]) + 1);
tree[n * 2 + 1] = tree[m * 2 + 1] = (short)node;
// and insert the new node in the heap
s.heap[1] = node++;
s.pqdownheap(tree, 1);
}while (s.heap_len >= 2);
s.heap[--s.heap_max] = s.heap[1];
// At this point, the fields freq and dad are set. We can now
// generate the bit lengths.
gen_bitlen(s);
// The field len is now set, we can generate the bit codes
gen_codes(tree, max_code, s.bl_count);
}
public int deflateInit(int level, int bits)
{
dstate = new Deflate();
return dstate.deflateInit(this, level, bits);
}
// Compute the optimal bit lengths for a tree and update the total bit length
// for the current block.
// IN assertion: the fields freq and dad are set, heap[heap_max] and
// above are the tree nodes sorted by increasing frequency.
// OUT assertions: the field len is set to the optimal bit length, the
// array bl_count contains the frequencies for each bit length.
// The length opt_len is updated; static_len is also updated if stree is
// not null.
internal void gen_bitlen(Deflate 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--;
}
}
}
internal StaticTree stat_desc; // the corresponding static tree
// Compute the optimal bit lengths for a tree and update the total bit length
// for the current block.
// IN assertion: the fields freq and dad are set, heap[heap_max] and
// above are the tree nodes sorted by increasing frequency.
// OUT assertions: the field len is set to the optimal bit length, the
// array bl_count contains the frequencies for each bit length.
// The length opt_len is updated; static_len is also updated if stree is
// not null.
internal void gen_bitlen(Deflate 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--;
}
}
}
public int deflateInit(int level, int bits)
{
dstate = new Deflate();
return(dstate.deflateInit(this, level, bits));
}
internal void gen_bitlen(Deflate s)
{
int num4;
short[] numArray4;
IntPtr ptr;
short[] numArray = this.dyn_tree;
short[] numArray2 = this.stat_desc.static_tree;
int[] numArray3 = this.stat_desc.extra_bits;
int num = this.stat_desc.extra_base;
int num2 = this.stat_desc.max_length;
int num9 = 0;
int index = 0;
while (index <= 15)
{
s.bl_count[index] = 0;
index++;
}
numArray[(s.heap[s.heap_max] * 2) + 1] = 0;
int num3 = s.heap_max + 1;
while (num3 < HEAP_SIZE)
{
num4 = s.heap[num3];
index = numArray[(numArray[(num4 * 2) + 1] * 2) + 1] + 1;
if (index > num2)
{
index = num2;
num9++;
}
numArray[(num4 * 2) + 1] = (short) index;
if (num4 <= this.max_code)
{
(numArray4 = s.bl_count)[(int) (ptr = (IntPtr) index)] = (short) (numArray4[(int) ptr] + 1);
int num7 = 0;
if (num4 >= num)
{
num7 = numArray3[num4 - num];
}
short num8 = numArray[num4 * 2];
s.opt_len += num8 * (index + num7);
if (numArray2 != null)
{
s.static_len += num8 * (numArray2[(num4 * 2) + 1] + num7);
}
}
num3++;
}
if (num9 != 0)
{
do
{
index = num2 - 1;
while (s.bl_count[index] == 0)
{
index--;
}
(numArray4 = s.bl_count)[(int) (ptr = (IntPtr) index)] = (short) (numArray4[(int) ptr] - 1);
s.bl_count[index + 1] = (short) (s.bl_count[index + 1] + 2);
(numArray4 = s.bl_count)[(int) (ptr = (IntPtr) num2)] = (short) (numArray4[(int) ptr] - 1);
num9 -= 2;
}
while (num9 > 0);
for (index = num2; index != 0; index--)
{
num4 = s.bl_count[index];
while (num4 != 0)
{
int num5 = s.heap[--num3];
if (num5 <= this.max_code)
{
if (numArray[(num5 * 2) + 1] != index)
{
s.opt_len += (index - numArray[(num5 * 2) + 1]) * numArray[num5 * 2];
numArray[(num5 * 2) + 1] = (short) index;
}
num4--;
}
}
}
}
}
internal void build_tree(Deflate s)
{
int num4;
short[] numArray1 = this.dyn_tree;
short[] numArray2 = this.stat_desc.static_tree;
int num1 = this.stat_desc.elems;
int num3 = -1;
s.heap_len = 0;
s.heap_max = Tree.HEAP_SIZE;
int num2 = 0;
while (num2 < num1)
{
if (numArray1[num2 * 2] != 0)
{
s.heap[++s.heap_len] = num3 = num2;
s.depth[num2] = 0;
}
else
{
numArray1[(num2 * 2) + 1] = 0;
}
num2++;
}
while (s.heap_len < 2)
{
num4 = s.heap[++s.heap_len] = (num3 < 2) ? ++num3 : 0;
numArray1[num4 * 2] = 1;
s.depth[num4] = 0;
s.opt_len--;
if (numArray2 != null)
{
s.static_len -= numArray2[(num4 * 2) + 1];
}
}
this.max_code = num3;
num2 = s.heap_len / 2;
while (num2 >= 1)
{
s.pqdownheap(numArray1, num2);
num2--;
}
num4 = num1;
do
{
num2 = s.heap[1];
s.heap[1] = s.heap[s.heap_len--];
s.pqdownheap(numArray1, 1);
int num5 = s.heap[1];
s.heap[--s.heap_max] = num2;
s.heap[--s.heap_max] = num5;
numArray1[num4 * 2] = (short)(numArray1[num2 * 2] + numArray1[num5 * 2]);
s.depth[num4] = (byte)(Math.Max(s.depth[num2], s.depth[num5]) + 1);
numArray1[(num2 * 2) + 1] = numArray1[(num5 * 2) + 1] = (short)num4;
s.heap[1] = num4++;
s.pqdownheap(numArray1, 1);
}while (s.heap_len >= 2);
s.heap[--s.heap_max] = s.heap[1];
this.gen_bitlen(s);
Tree.gen_codes(numArray1, num3, s.bl_count);
}
internal void gen_bitlen(Deflate s)
{
int num4;
short[] numArray1 = this.dyn_tree;
short[] numArray2 = this.stat_desc.static_tree;
int[] numArray3 = this.stat_desc.extra_bits;
int num1 = this.stat_desc.extra_base;
int num2 = this.stat_desc.max_length;
int num6 = 0;
int num5 = 0;
while (num5 <= 15)
{
s.bl_count[num5] = 0;
num5++;
}
numArray1[(s.heap[s.heap_max] * 2) + 1] = 0;
int num3 = s.heap_max + 1;
while (num3 < Tree.HEAP_SIZE)
{
num4 = s.heap[num3];
num5 = numArray1[(numArray1[(num4 * 2) + 1] * 2) + 1] + 1;
if (num5 > num2)
{
num5 = num2;
num6++;
}
numArray1[(num4 * 2) + 1] = (short) num5;
if (num4 <= this.max_code)
{
s.bl_count[num5] = (short) (s.bl_count[num5] + 1);
int num7 = 0;
if (num4 >= num1)
{
num7 = numArray3[num4 - num1];
}
short num8 = numArray1[num4 * 2];
s.opt_len += num8 * (num5 + num7);
if (numArray2 != null)
{
s.static_len += num8 * (numArray2[(num4 * 2) + 1] + num7);
}
}
num3++;
}
if (num6 != 0)
{
do
{
num5 = num2 - 1;
while (s.bl_count[num5] == 0)
{
num5--;
}
s.bl_count[num5] = (short) (s.bl_count[num5] - 1);
s.bl_count[num5 + 1] = (short) (s.bl_count[num5 + 1] + 2);
s.bl_count[num2] = (short) (s.bl_count[num2] - 1);
num6 -= 2;
}
while (num6 > 0);
for (num5 = num2; num5 != 0; num5--)
{
num4 = s.bl_count[num5];
while (num4 != 0)
{
int num9 = s.heap[--num3];
if (num9 <= this.max_code)
{
if (numArray1[(num9 * 2) + 1] != num5)
{
s.opt_len += (num5 - numArray1[(num9 * 2) + 1]) * numArray1[num9 * 2];
numArray1[(num9 * 2) + 1] = (short) num5;
}
num4--;
}
}
}
}
}
internal void build_tree(Deflate s)
{
int num4;
short[] numArray1 = this.dyn_tree;
short[] numArray2 = this.stat_desc.static_tree;
int num1 = this.stat_desc.elems;
int num3 = -1;
s.heap_len = 0;
s.heap_max = Tree.HEAP_SIZE;
int num2 = 0;
while (num2 < num1)
{
if (numArray1[num2 * 2] != 0)
{
s.heap[++s.heap_len] = num3 = num2;
s.depth[num2] = 0;
}
else
{
numArray1[(num2 * 2) + 1] = 0;
}
num2++;
}
while (s.heap_len < 2)
{
num4 = s.heap[++s.heap_len] = (num3 < 2) ? ++num3 : 0;
numArray1[num4 * 2] = 1;
s.depth[num4] = 0;
s.opt_len--;
if (numArray2 != null)
{
s.static_len -= numArray2[(num4 * 2) + 1];
}
}
this.max_code = num3;
num2 = s.heap_len / 2;
while (num2 >= 1)
{
s.pqdownheap(numArray1, num2);
num2--;
}
num4 = num1;
do
{
num2 = s.heap[1];
s.heap[1] = s.heap[s.heap_len--];
s.pqdownheap(numArray1, 1);
int num5 = s.heap[1];
s.heap[--s.heap_max] = num2;
s.heap[--s.heap_max] = num5;
numArray1[num4 * 2] = (short) (numArray1[num2 * 2] + numArray1[num5 * 2]);
s.depth[num4] = (byte) (Math.Max(s.depth[num2], s.depth[num5]) + 1);
numArray1[(num2 * 2) + 1] = numArray1[(num5 * 2) + 1] = (short) num4;
s.heap[1] = num4++;
s.pqdownheap(numArray1, 1);
}
while (s.heap_len >= 2);
s.heap[--s.heap_max] = s.heap[1];
this.gen_bitlen(s);
Tree.gen_codes(numArray1, num3, s.bl_count);
}
internal void build_tree(Deflate s)
{
int num2;
int num5;
short[] tree = this.dyn_tree;
short[] numArray2 = this.stat_desc.static_tree;
int elems = this.stat_desc.elems;
int num4 = -1;
s.heap_len = 0;
s.heap_max = HEAP_SIZE;
for (num2 = 0; num2 < elems; num2++)
{
if (tree[num2 * 2] != 0)
{
s.heap[++s.heap_len] = num4 = num2;
s.depth[num2] = 0;
}
else
{
tree[(num2 * 2) + 1] = 0;
}
}
while (s.heap_len < 2)
{
num5 = s.heap[++s.heap_len] = (num4 < 2) ? ++num4 : 0;
tree[num5 * 2] = 1;
s.depth[num5] = 0;
s.opt_len--;
if (numArray2 != null)
{
s.static_len -= numArray2[(num5 * 2) + 1];
}
}
this.max_code = num4;
num2 = s.heap_len / 2;
while (num2 >= 1)
{
s.pqdownheap(tree, num2);
num2--;
}
num5 = elems;
do
{
num2 = s.heap[1];
s.heap[1] = s.heap[s.heap_len--];
s.pqdownheap(tree, 1);
int index = s.heap[1];
s.heap[--s.heap_max] = num2;
s.heap[--s.heap_max] = index;
tree[num5 * 2] = (short)(tree[num2 * 2] + tree[index * 2]);
s.depth[num5] = (byte)(Math.Max(s.depth[num2], s.depth[index]) + 1);
tree[(num2 * 2) + 1] = tree[(index * 2) + 1] = (short)num5;
s.heap[1] = num5++;
s.pqdownheap(tree, 1);
}while (s.heap_len >= 2);
s.heap[--s.heap_max] = s.heap[1];
this.gen_bitlen(s);
gen_codes(tree, num4, s.bl_count);
}
internal void gen_bitlen(Deflate s)
{
int num4;
short[] numArray = this.dyn_tree;
short[] numArray2 = this.stat_desc.static_tree;
int[] numArray3 = this.stat_desc.extra_bits;
int num = this.stat_desc.extra_base;
int index = this.stat_desc.max_length;
int num9 = 0;
int num6 = 0;
while (num6 <= 15)
{
s.bl_count[num6] = 0;
num6++;
}
numArray[(s.heap[s.heap_max] * 2) + 1] = 0;
int num3 = s.heap_max + 1;
while (num3 < HEAP_SIZE)
{
num4 = s.heap[num3];
num6 = numArray[(numArray[(num4 * 2) + 1] * 2) + 1] + 1;
if (num6 > index)
{
num6 = index;
num9++;
}
numArray[(num4 * 2) + 1] = (short)num6;
if (num4 <= this.max_code)
{
s.bl_count[num6] = (short)(s.bl_count[num6] + 1);
int num7 = 0;
if (num4 >= num)
{
num7 = numArray3[num4 - num];
}
short num8 = numArray[num4 * 2];
s.opt_len += num8 * (num6 + num7);
if (numArray2 != null)
{
s.static_len += num8 * (numArray2[(num4 * 2) + 1] + num7);
}
}
num3++;
}
if (num9 != 0)
{
do
{
num6 = index - 1;
while (s.bl_count[num6] == 0)
{
num6--;
}
s.bl_count[num6] = (short)(s.bl_count[num6] - 1);
s.bl_count[num6 + 1] = (short)(s.bl_count[num6 + 1] + 2);
s.bl_count[index] = (short)(s.bl_count[index] - 1);
num9 -= 2;
}while (num9 > 0);
for (num6 = index; num6 != 0; num6--)
{
num4 = s.bl_count[num6];
while (num4 != 0)
{
int num5 = s.heap[--num3];
if (num5 <= this.max_code)
{
if (numArray[(num5 * 2) + 1] != num6)
{
s.opt_len += (num6 - numArray[(num5 * 2) + 1]) * numArray[num5 * 2];
numArray[(num5 * 2) + 1] = (short)num6;
}
num4--;
}
}
}
}
}
// Construct one Huffman tree and assigns the code bit strings and lengths.
// Update the total bit length for the current block.
// IN assertion: the field freq is set for all tree elements.
// OUT assertions: the fields len and code are set to the optimal bit length
// and corresponding code. The length opt_len is updated; static_len is
// also updated if stree is not null. The field max_code is set.
internal void build_tree(Deflate s)
{
short[] tree = dyn_tree;
short[] stree = stat_desc.static_tree;
int elems = stat_desc.elems;
int n, m; // iterate over heap elements
int max_code = - 1; // largest code with non zero frequency
int node; // new node being created
// Construct the initial heap, with least frequent element in
// heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
// heap[0] is not used.
s.heap_len = 0;
s.heap_max = HEAP_SIZE;
for (n = 0; n < elems; n++)
{
if (tree[n * 2] != 0)
{
s.heap[++s.heap_len] = max_code = n;
s.depth[n] = 0;
}
else
{
tree[n * 2 + 1] = 0;
}
}
// The pkzip format requires that at least one distance code exists,
// and that at least one bit should be sent even if there is only one
// possible code. So to avoid special checks later on we force at least
// two codes of non zero frequency.
while (s.heap_len < 2)
{
node = s.heap[++s.heap_len] = (max_code < 2?++max_code:0);
tree[node * 2] = 1;
s.depth[node] = 0;
s.opt_len--;
if (stree != null)
s.static_len -= stree[node * 2 + 1];
// node is 0 or 1 so it does not have extra bits
}
this.max_code = max_code;
// The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
// establish sub-heaps of increasing lengths:
for (n = s.heap_len / 2; n >= 1; n--)
s.pqdownheap(tree, n);
// Construct the Huffman tree by repeatedly combining the least two
// frequent nodes.
node = elems; // next internal node of the tree
do
{
// n = node of least frequency
n = s.heap[1];
s.heap[1] = s.heap[s.heap_len--];
s.pqdownheap(tree, 1);
m = s.heap[1]; // m = node of next least frequency
s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency
s.heap[--s.heap_max] = m;
// Create a new node father of n and m
tree[node * 2] = (short) (tree[n * 2] + tree[m * 2]);
s.depth[node] = (byte) (System.Math.Max((byte) s.depth[n], (byte) s.depth[m]) + 1);
tree[n * 2 + 1] = tree[m * 2 + 1] = (short) node;
// and insert the new node in the heap
s.heap[1] = node++;
s.pqdownheap(tree, 1);
}
while (s.heap_len >= 2);
s.heap[--s.heap_max] = s.heap[1];
// At this point, the fields freq and dad are set. We can now
// generate the bit lengths.
gen_bitlen(s);
// The field len is now set, we can generate the bit codes
gen_codes(tree, max_code, s.bl_count);
}
internal void build_tree(Deflate s)
{
int num2;
int num5;
short[] tree = this.dyn_tree;
short[] numArray2 = this.stat_desc.static_tree;
int elems = this.stat_desc.elems;
int num4 = -1;
s.heap_len = 0;
s.heap_max = HEAP_SIZE;
for (num2 = 0; num2 < elems; num2++)
{
if (tree[num2 * 2] != 0)
{
s.heap[++s.heap_len] = num4 = num2;
s.depth[num2] = 0;
}
else
{
tree[(num2 * 2) + 1] = 0;
}
}
while (s.heap_len < 2)
{
num5 = s.heap[++s.heap_len] = (num4 < 2) ? ++num4 : 0;
tree[num5 * 2] = 1;
s.depth[num5] = 0;
s.opt_len--;
if (numArray2 != null)
{
s.static_len -= numArray2[(num5 * 2) + 1];
}
}
this.max_code = num4;
num2 = s.heap_len / 2;
while (num2 >= 1)
{
s.pqdownheap(tree, num2);
num2--;
}
num5 = elems;
do
{
num2 = s.heap[1];
s.heap[1] = s.heap[s.heap_len--];
s.pqdownheap(tree, 1);
int index = s.heap[1];
s.heap[--s.heap_max] = num2;
s.heap[--s.heap_max] = index;
tree[num5 * 2] = (short) (tree[num2 * 2] + tree[index * 2]);
s.depth[num5] = (byte) (Math.Max(s.depth[num2], s.depth[index]) + 1);
tree[(num2 * 2) + 1] = tree[(index * 2) + 1] = (short) num5;
s.heap[1] = num5++;
s.pqdownheap(tree, 1);
}
while (s.heap_len >= 2);
s.heap[--s.heap_max] = s.heap[1];
this.gen_bitlen(s);
gen_codes(tree, num4, s.bl_count);
}
