public int DeflateEnd()
{
if (dstate == null)
{
return(Z_STREAM_ERROR);
}
int ret = dstate.DeflateEnd();
dstate = null;
return(ret);
}
public int DeflateEnd()
{
if (dstate == null)
{
return Z_STREAM_ERROR;
}
int ret = dstate.DeflateEnd();
dstate = null;
return ret;
}
public int DeflateInit(int level, int bits, bool nowrap)
{
dstate = new NSch.ZLib.Deflate();
return dstate.DeflateInit(this, level, nowrap ? -bits : bits);
}
// 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;
int 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;
do
{
// next internal node of the tree
// 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] = unchecked((byte)(Math.Max(s.depth[n], 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);
}
// the dynamic tree
// largest code with non zero frequency
// 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 = stat_desc.extra_base;
int max_length = stat_desc.max_length;
int h;
// heap index
int n;
int 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)
{
xbits = extra[n - @base];
}
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;
}
do
{
// This happens for example on obj2 and pic of the Calgary corpus
// Find the first bit length which could increase:
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] += 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) (((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, bool nowrap)
{
dstate = new NSch.ZLib.Deflate();
return(dstate.DeflateInit(this, level, nowrap ? -bits : bits));
}
