Exemplo n.º 1
0
        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;
            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 -= (int)static_tree[num2 * 2 + 1];
                }
            }
            this.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];
            this.gen_bitlen(s);
            Tree.gen_codes(array, num, s.bl_count);
        }
Exemplo n.º 2
0
        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);
        }
Exemplo 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);
        }
Exemplo n.º 4
0
Arquivo: cs.cs Projeto: J5lx/luminous
        // 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);
        }
Exemplo n.º 5
0
        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);
        }
Exemplo n.º 6
0
 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);
 }
Exemplo n.º 7
0
        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);
        }
Exemplo n.º 8
0
 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);
 }