public static void SetParams(Deflate/*!*/ self, [NotNull]MutableString/*!*/ dictionary)
{
byte[] buffer = dictionary.ToByteArray();
var zst = self.GetStream();
int err = zst.deflateSetDictionary(buffer, buffer.Length);
if (err != Z_OK) {
throw MakeError(err, zst.msg);
}
}
public static MutableString Flush(Deflate/*!*/ self, [DefaultParameterValue(SYNC_FLUSH)]int flush)
{
if (flush == NO_FLUSH) {
return MutableString.CreateEmpty();
}
return Compress(self, MutableString.FrozenEmpty, flush);
}
public static void SetParams(
Deflate/*!*/ self,
[DefaultParameterValue(DEFAULT_COMPRESSION)]int level,
[DefaultParameterValue(DEFAULT_STRATEGY)]int strategy)
{
var zst = self.GetStream();
int err = zst.deflateParams(level, (zlib.CompressionStrategy)strategy);
if (err != Z_OK) {
throw MakeError(err, zst.msg);
}
}
public static Deflate AppendData(Deflate/*!*/ self, [DefaultProtocol]MutableString str)
{
var zst = self.GetStream();
MutableString trailingUncompressedData = null;
int result = Process(zst, str, zlib.FlushStrategy.Z_NO_FLUSH, compress, ref trailingUncompressedData);
if (result != Z_OK) {
throw MakeError(result, zst.msg);
}
return self;
}
public static MutableString Compress(Deflate/*!*/ self, [DefaultProtocol]MutableString str, [DefaultParameterValue(NO_FLUSH)]int flush)
{
MutableString compressed;
MutableString trailingUncompressedData = null;
var zst = self.GetStream();
int result = Process(zst, str, (zlib.FlushStrategy)flush, compress, out compressed, ref trailingUncompressedData);
if (result != Z_OK) {
throw MakeError(result, zst.msg);
}
return compressed;
}
///<summary>
/// 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 count 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.
///</summary>
private 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 <= ZLibUtil.MAX_WBITS; 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 < ZLibUtil.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--;
}
}
}
///<summary>
/// 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 count 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.
///</summary>
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 = ZLibUtil.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 count is now set, we can generate the bit codes
gen_codes(tree, max_code, s.bl_count);
}
/// <summary>
/// All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending output.
/// </summary>
/// <returns>
/// deflateEnd returns <see cref="ZLibResultCode.Z_OK" /> if success, <see cref="ZLibResultCode.Z_STREAM_ERROR" /> if the stream state was inconsistent, <see cref="ZLibResultCode.Z_DATA_ERROR" /> if the stream was freed prematurely (some input or output was discarded). In the error case, <see cref="msg" /> may be set but then points to a static string (which must not be deallocated).
/// </returns>
public int deflateEnd()
{
next_in_index = 0;
next_out_index = 0;
if (_dstate == null)
return (int)ZLibResultCode.Z_STREAM_ERROR;
int ret = _dstate.deflateEnd();
_dstate = null;
return ret;
}
/// <summary>
/// Initializes the internal stream state for compression.
/// </summary>
/// <param name="level">An integer value from 0 to 9 indicating the desired compression level.</param>
/// <param name="bits"> The windowBits parameter is the base two logarithm of the window size (the size of the history buffer). It should be in the range 8..15 for this version of the library. Larger values of this parameter result in better compression at the expense of memory usage. The default value is 15 if deflateInit is used instead.</param>
/// <returns>
/// deflateInit returns <see cref="ZLibResultCode.Z_OK" /> if success, <see cref="ZLibResultCode.Z_MEM_ERROR" /> if there was not enough memory, <see cref="ZLibResultCode.Z_STREAM_ERROR" /> if level is not a valid compression level. <see cref="msg" /> is set to <c>null</c> if there is no error message. <see cref="deflateInit(int,int)" /> does not perform any compression: this will be done by <see cref="deflate" />.
/// </returns>
public int deflateInit(int level, int bits)
{
_dstate = new Deflate();
return _dstate.deflateInit(this, level, bits);
}
public int deflateInit(int level, int windowBits, int memLevel, CompressionStrategy strategy) {
_dstate = new Deflate();
return _dstate.deflateInit2(this, level, windowBits, memLevel, strategy);
}