pqdownheap() private method

private pqdownheap ( short tree, int k ) : void
tree short
k int
return void
Esempio n. 1
0
        internal void build_tree(Deflate s)
        {
            short[] array       = dyn_tree;
            short[] static_tree = stat_desc.static_tree;
            int     elems       = stat_desc.elems;
            int     num         = -1;

            s.heap_len = 0;
            s.heap_max = HEAP_SIZE;
            for (int i = 0; i < elems; i++)
            {
                if (array[i * 2] != 0)
                {
                    num        = (s.heap[++s.heap_len] = i);
                    s.depth[i] = 0;
                }
                else
                {
                    array[i * 2 + 1] = 0;
                }
            }
            int num2;

            while (s.heap_len < 2)
            {
                num2            = (s.heap[++s.heap_len] = ((num < 2) ? (++num) : 0));
                array[num2 * 2] = 1;
                s.depth[num2]   = 0;
                s.opt_len--;
                if (static_tree != null)
                {
                    s.static_len -= static_tree[num2 * 2 + 1];
                }
            }
            max_code = num;
            for (int i = s.heap_len / 2; i >= 1; i--)
            {
                s.pqdownheap(array, i);
            }
            num2 = elems;
            do
            {
                int i = s.heap[1];
                s.heap[1] = s.heap[s.heap_len--];
                s.pqdownheap(array, 1);
                int num3 = s.heap[1];
                s.heap[--s.heap_max] = i;
                s.heap[--s.heap_max] = num3;
                array[num2 * 2]      = (short)(array[i * 2] + array[num3 * 2]);
                s.depth[num2]        = (byte)(Math.Max(s.depth[i], s.depth[num3]) + 1);
                array[i * 2 + 1]     = (array[num3 * 2 + 1] = (short)num2);
                s.heap[1]            = num2++;
                s.pqdownheap(array, 1);
            }while (s.heap_len >= 2);
            s.heap[--s.heap_max] = s.heap[1];
            gen_bitlen(s);
            gen_codes(array, num, s.bl_count);
        }
Esempio n. 2
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, 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);
		}
Esempio n. 3
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, 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);
        }
Esempio n. 4
0
        internal void build_tree(Deflate s)
        {
            int i;
            int num;
            int num1;

            short[] dynTree    = this.dyn_tree;
            short[] staticTree = this.stat_desc.static_tree;
            int     statDesc   = this.stat_desc.elems;
            int     num2       = -1;

            s.heap_len = 0;
            s.heap_max = Tree.HEAP_SIZE;
            for (i = 0; i < statDesc; i++)
            {
                if (dynTree[i * 2] == 0)
                {
                    dynTree[i * 2 + 1] = 0;
                }
                else
                {
                    Deflate deflate = s;
                    int     heapLen = deflate.heap_len + 1;
                    int     num3    = heapLen;
                    deflate.heap_len = heapLen;
                    int num4 = i;
                    num2         = num4;
                    s.heap[num3] = num4;
                    s.depth[i]   = 0;
                }
            }
            while (s.heap_len < 2)
            {
                int[]   numArray = s.heap;
                Deflate deflate1 = s;
                int     heapLen1 = deflate1.heap_len + 1;
                int     num5     = heapLen1;
                deflate1.heap_len = heapLen1;
                int num6 = num5;
                if (num2 < 2)
                {
                    num1 = num2 + 1;
                    num2 = num1;
                }
                else
                {
                    num1 = 0;
                }
                int num7 = num1;
                numArray[num6]   = num1;
                num              = num7;
                dynTree[num * 2] = 1;
                s.depth[num]     = 0;
                Deflate optLen = s;
                optLen.opt_len = optLen.opt_len - 1;
                if (staticTree == null)
                {
                    continue;
                }
                Deflate staticLen = s;
                staticLen.static_len = staticLen.static_len - staticTree[num * 2 + 1];
            }
            this.max_code = num2;
            for (i = s.heap_len / 2; i >= 1; i--)
            {
                s.pqdownheap(dynTree, i);
            }
            num = statDesc;
            do
            {
                i = s.heap[1];
                int[]   numArray1 = s.heap;
                int[]   numArray2 = s.heap;
                Deflate deflate2  = s;
                int     heapLen2  = deflate2.heap_len;
                int     num8      = heapLen2;
                deflate2.heap_len = heapLen2 - 1;
                numArray1[1]      = numArray2[num8];
                s.pqdownheap(dynTree, 1);
                int     num9     = s.heap[1];
                Deflate deflate3 = s;
                int     heapMax  = deflate3.heap_max - 1;
                int     num10    = heapMax;
                deflate3.heap_max = heapMax;
                s.heap[num10]     = i;
                Deflate deflate4 = s;
                int     heapMax1 = deflate4.heap_max - 1;
                int     num11    = heapMax1;
                deflate4.heap_max = heapMax1;
                s.heap[num11]     = num9;
                dynTree[num * 2]  = (short)(dynTree[i * 2] + dynTree[num9 * 2]);
                s.depth[num]      = (byte)(Math.Max(s.depth[i], s.depth[num9]) + 1);
                short num12 = (short)num;
                short num13 = num12;
                dynTree[num9 * 2 + 1] = num12;
                dynTree[i * 2 + 1]    = num13;
                int num14 = num;
                num       = num14 + 1;
                s.heap[1] = num14;
                s.pqdownheap(dynTree, 1);
            }while (s.heap_len >= 2);
            Deflate deflate5 = s;
            int     heapMax2 = deflate5.heap_max - 1;
            int     num15    = heapMax2;

            deflate5.heap_max = heapMax2;
            s.heap[num15]     = s.heap[1];
            this.gen_bitlen(s);
            Tree.gen_codes(dynTree, num2, s.bl_count);
        }