public int DeflateEnd()
        {
            if (dstate == null)
            {
                return(Z_STREAM_ERROR);
            }
            int ret = dstate.DeflateEnd();

            dstate = null;
            return(ret);
        }
예제 #2
0
		public int DeflateEnd()
		{
			if (dstate == null)
			{
				return Z_STREAM_ERROR;
			}
			int ret = dstate.DeflateEnd();
			dstate = null;
			return ret;
		}
예제 #3
0
		public int DeflateInit(int level, int bits, bool nowrap)
		{
			dstate = new NSch.ZLib.Deflate();
			return dstate.DeflateInit(this, level, nowrap ? -bits : bits);
		}
예제 #4
0
		// 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);
		}
예제 #5
0
		// 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));
 }