コード例 #1
0
        internal void build_tree(DeflateManager s)
        {
            short[] array     = dyn_tree;
            short[] treeCodes = staticTree.treeCodes;
            int     elems     = staticTree.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 (treeCodes != null)
                {
                    s.static_len -= treeCodes[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]        = (sbyte)(Math.Max((byte)s.depth[i], (byte)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);
        }
コード例 #2
0
 public int EndDeflate()
 {
     if (this.dstate == null)
     {
         throw new ZlibException("No Deflate State!");
     }
     this.dstate = null;
     return(0);
 }
コード例 #3
0
		public int EndDeflate()
		{
			if (dstate == null)
			{
				throw new ZlibException("No Deflate State!");
			}
			dstate = null;
			return 0;
		}
コード例 #4
0
 private int _InternalInitializeDeflate(bool wantRfc1950Header)
 {
     if (this.istate != null)
     {
         throw new ZlibException("You may not call InitializeDeflate() after calling InitializeInflate().");
     }
     this.dstate = new DeflateManager();
     this.dstate.WantRfc1950HeaderBytes = wantRfc1950Header;
     return(this.dstate.Initialize(this, this.CompressLevel, this.WindowBits, this.Strategy));
 }
コード例 #5
0
ファイル: ZlibCodec.cs プロジェクト: rhy2020/LuaGame
 /// <summary>
 /// End a deflation session.
 /// </summary>
 /// <remarks>
 /// Call this after making a series of one or more calls to Deflate(). All buffers are flushed.
 /// </remarks>
 /// <returns>Z_OK if all goes well.</returns>
 public int EndDeflate()
 {
     if (dstate == null)
     {
         throw new ZlibException("No Deflate State!");
     }
     // TODO: dinoch Tue, 03 Nov 2009  15:39 (test this)
     //int ret = dstate.End();
     dstate = null;
     return(ZlibConstants.Z_OK); //ret;
 }
コード例 #6
0
        internal void pqdownheap(short[] tree, int k)
        {
            int num = this.heap[k];

            for (int i = k << 1; i <= this.heap_len; i <<= 1)
            {
                if (i < this.heap_len && DeflateManager._IsSmaller(tree, this.heap[i + 1], this.heap[i], this.depth))
                {
                    i++;
                }
                if (DeflateManager._IsSmaller(tree, num, this.heap[i], this.depth))
                {
                    break;
                }
                this.heap[k] = this.heap[i];
                k            = i;
            }
            this.heap[k] = num;
        }
コード例 #7
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(DeflateManager s)
        {
            short[] tree = dyn_tree;
            short[] stree = staticTree.treeCodes;
            int     elems = staticTree.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]  = unchecked ((short)(tree[n * 2] + tree[m * 2]));
                s.depth[node]   = (sbyte)(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);
        }
コード例 #8
0
        internal StaticTree staticTree; // 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(DeflateManager s)
        {
            short[] tree         = dyn_tree;
            short[] stree        = staticTree.treeCodes;
            int[]   extra        = staticTree.extraBits;
            int     base_Renamed = staticTree.extraBase;
            int     max_length   = staticTree.maxLength;
            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 <= InternalConstants.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_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--;
                }
            }
        }
コード例 #9
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(DeflateManager s)
 {
     short[] tree  = dyn_tree;
     short[] stree = staticTree.treeCodes;
     int elems     = staticTree.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] = unchecked((short) (tree[n * 2] + tree[m * 2]));
         s.depth[node] = (sbyte) (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);
 }
コード例 #10
0
 internal StaticTree staticTree; // 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(DeflateManager s)
 {
     short[] tree = dyn_tree;
     short[] stree = staticTree.treeCodes;
     int[] extra = staticTree.extraBits;
     int base_Renamed = staticTree.extraBase;
     int max_length = staticTree.maxLength;
     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 <= InternalConstants.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_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--;
         }
     }
 }
コード例 #11
0
        internal void gen_bitlen(DeflateManager s)
        {
            short[] array     = dyn_tree;
            short[] treeCodes = staticTree.treeCodes;
            int[]   extraBits = staticTree.extraBits;
            int     extraBase = staticTree.extraBase;
            int     maxLength = staticTree.maxLength;
            int     num       = 0;

            for (int i = 0; i <= InternalConstants.MAX_BITS; i++)
            {
                s.bl_count[i] = 0;
            }
            array[s.heap[s.heap_max] * 2 + 1] = 0;
            int j;

            for (j = s.heap_max + 1; j < HEAP_SIZE; j++)
            {
                int num2 = s.heap[j];
                int i    = array[array[num2 * 2 + 1] * 2 + 1] + 1;
                if (i > maxLength)
                {
                    i = maxLength;
                    num++;
                }
                array[num2 * 2 + 1] = (short)i;
                if (num2 <= max_code)
                {
                    s.bl_count[i]++;
                    int num3 = 0;
                    if (num2 >= extraBase)
                    {
                        num3 = extraBits[num2 - extraBase];
                    }
                    short num4 = array[num2 * 2];
                    s.opt_len += num4 * (i + num3);
                    if (treeCodes != null)
                    {
                        s.static_len += num4 * (treeCodes[num2 * 2 + 1] + num3);
                    }
                }
            }
            if (num != 0)
            {
                do
                {
                    int i = maxLength - 1;
                    while (s.bl_count[i] == 0)
                    {
                        i--;
                    }
                    s.bl_count[i]--;
                    s.bl_count[i + 1] = (short)(s.bl_count[i + 1] + 2);
                    s.bl_count[maxLength]--;
                    num -= 2;
                }while (num > 0);
                for (int i = maxLength; i != 0; i--)
                {
                    int num2 = s.bl_count[i];
                    while (num2 != 0)
                    {
                        int num5 = s.heap[--j];
                        if (num5 <= max_code)
                        {
                            if (array[num5 * 2 + 1] != i)
                            {
                                s.opt_len           = (int)(s.opt_len + ((long)i - (long)array[num5 * 2 + 1]) * array[num5 * 2]);
                                array[num5 * 2 + 1] = (short)i;
                            }
                            num2--;
                        }
                    }
                }
            }
        }
コード例 #12
0
        internal void gen_bitlen(DeflateManager s)
        {
            int num4;

            short[] numArray  = this.dyn_tree;
            short[] treeCodes = this.staticTree.treeCodes;
            int[]   extraBits = this.staticTree.extraBits;
            int     extraBase = this.staticTree.extraBase;
            int     maxLength = this.staticTree.maxLength;
            int     num9      = 0;
            int     index     = 0;

            while (index <= InternalConstants.MAX_BITS)
            {
                s.bl_count[index] = 0;
                index++;
            }
            numArray[(s.heap[s.heap_max] * 2) + 1] = 0;
            int num3 = s.heap_max + 1;

            while (num3 < HEAP_SIZE)
            {
                num4  = s.heap[num3];
                index = numArray[(numArray[(num4 * 2) + 1] * 2) + 1] + 1;
                if (index > maxLength)
                {
                    index = maxLength;
                    num9++;
                }
                numArray[(num4 * 2) + 1] = (short)index;
                if (num4 <= this.max_code)
                {
                    s.bl_count[index] = (short)(s.bl_count[index] + 1);
                    int num7 = 0;
                    if (num4 >= extraBase)
                    {
                        num7 = extraBits[num4 - extraBase];
                    }
                    short num8 = numArray[num4 * 2];
                    s.opt_len += num8 * (index + num7);
                    if (treeCodes != null)
                    {
                        s.static_len += num8 * (treeCodes[(num4 * 2) + 1] + num7);
                    }
                }
                num3++;
            }
            if (num9 != 0)
            {
                do
                {
                    index = maxLength - 1;
                    while (s.bl_count[index] == 0)
                    {
                        index--;
                    }
                    s.bl_count[index]     = (short)(s.bl_count[index] - 1);
                    s.bl_count[index + 1] = (short)(s.bl_count[index + 1] + 2);
                    s.bl_count[maxLength] = (short)(s.bl_count[maxLength] - 1);
                    num9 -= 2;
                }while (num9 > 0);
                for (index = maxLength; index != 0; index--)
                {
                    num4 = s.bl_count[index];
                    while (num4 != 0)
                    {
                        int num5 = s.heap[--num3];
                        if (num5 <= this.max_code)
                        {
                            if (numArray[(num5 * 2) + 1] != index)
                            {
                                s.opt_len += (index - numArray[(num5 * 2) + 1]) * numArray[num5 * 2];
                                numArray[(num5 * 2) + 1] = (short)index;
                            }
                            num4--;
                        }
                    }
                }
            }
        }
コード例 #13
0
        internal void build_tree(DeflateManager s)
        {
            int num2;
            int num5;

            short[] tree      = this.dyn_tree;
            short[] treeCodes = this.staticTree.treeCodes;
            int     elems     = this.staticTree.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) ? 0 : ++num4;
                tree[num5 * 2] = 1;
                s.depth[num5]  = 0;
                s.opt_len--;
                if (treeCodes != null)
                {
                    s.static_len -= treeCodes[(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]        = (sbyte)(Math.Max((byte)s.depth[num2], (byte)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);
        }
コード例 #14
0
 /// <summary>
 /// End a deflation session.
 /// </summary>
 /// <remarks>
 /// Call this after making a series of one or more calls to Deflate(). All buffers are flushed.
 /// </remarks>
 /// <returns>Z_OK if all goes well.</returns>
 public int EndDeflate()
 {
     if (dstate == null)
         throw new ZlibException("No Deflate State!");
     // TODO: dinoch Tue, 03 Nov 2009  15:39 (test this)
     //int ret = dstate.End();
     dstate = null;
     return ZlibConstants.Z_OK; //ret;
 }
コード例 #15
0
        private int _InternalInitializeDeflate(bool wantRfc1950Header)
        {
            if (istate != null) throw new ZlibException("You may not call InitializeDeflate() after calling InitializeInflate().");
            dstate = new DeflateManager();
            dstate.WantRfc1950HeaderBytes = wantRfc1950Header;

            return dstate.Initialize(this, this.CompressLevel, this.WindowBits, this.Strategy);
        }
コード例 #16
0
        internal void gen_bitlen(DeflateManager s)
        {
            short[] array     = this.dyn_tree;
            short[] treeCodes = this.staticTree.treeCodes;
            int[]   extraBits = this.staticTree.extraBits;
            int     extraBase = this.staticTree.extraBase;
            int     maxLength = this.staticTree.maxLength;
            int     num       = 0;

            for (int i = 0; i <= InternalConstants.MAX_BITS; i++)
            {
                s.bl_count[i] = 0;
            }
            array[s.heap[s.heap_max] * 2 + 1] = 0;
            int j;

            for (j = s.heap_max + 1; j < ZTree.HEAP_SIZE; j++)
            {
                int num2 = s.heap[j];
                int i    = (int)(array[(int)(array[num2 * 2 + 1] * 2 + 1)] + 1);
                if (i > maxLength)
                {
                    i = maxLength;
                    num++;
                }
                array[num2 * 2 + 1] = (short)i;
                if (num2 <= this.max_code)
                {
                    short[] expr_DC_cp_0 = s.bl_count;
                    int     expr_DC_cp_1 = i;
                    expr_DC_cp_0[expr_DC_cp_1] += 1;
                    int num3 = 0;
                    if (num2 >= extraBase)
                    {
                        num3 = extraBits[num2 - extraBase];
                    }
                    short num4 = array[num2 * 2];
                    s.opt_len += (int)num4 * (i + num3);
                    if (treeCodes != null)
                    {
                        s.static_len += (int)num4 * ((int)treeCodes[num2 * 2 + 1] + num3);
                    }
                }
            }
            if (num == 0)
            {
                return;
            }
            do
            {
                int i = maxLength - 1;
                while (s.bl_count[i] == 0)
                {
                    i--;
                }
                short[] expr_179_cp_0 = s.bl_count;
                int     expr_179_cp_1 = i;
                expr_179_cp_0[expr_179_cp_1] -= 1;
                s.bl_count[i + 1]             = s.bl_count[i + 1] + 2;
                short[] expr_1A5_cp_0 = s.bl_count;
                int     expr_1A5_cp_1 = maxLength;
                expr_1A5_cp_0[expr_1A5_cp_1] -= 1;
                num -= 2;
            }while (num > 0);
            for (int i = maxLength; i != 0; i--)
            {
                int num2 = (int)s.bl_count[i];
                while (num2 != 0)
                {
                    int num5 = s.heap[--j];
                    if (num5 <= this.max_code)
                    {
                        if ((int)array[num5 * 2 + 1] != i)
                        {
                            s.opt_len           = (int)((long)s.opt_len + ((long)i - (long)array[num5 * 2 + 1]) * (long)array[num5 * 2]);
                            array[num5 * 2 + 1] = (short)i;
                        }
                        num2--;
                    }
                }
            }
        }