Exemple #1
0
 public int EndDeflate()
 {
     if ( dstate == null )
         throw new CompressionProcessException ( "No Deflate State!" );
     dstate = null;
     return ZlibConstants.Z_OK;
 }
Exemple #2
0
        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;
            int n, m;
            int bits;
            int xbits;
            short f;
            int overflow = 0;

            for ( bits = 0; bits <= ZlibConstants.MAX_BITS; bits++ )
                s.bl_count [ bits ] = 0;

            tree [ s.heap [ s.heap_max ] * 2 + 1 ] = 0;

            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;

                if ( n > max_code )
                    continue;

                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;

            do
            {
                bits = max_length - 1;
                while ( s.bl_count [ bits ] == 0 )
                    bits--;
                s.bl_count [ bits ]--;
                s.bl_count [ bits + 1 ] = ( short ) ( s.bl_count [ bits + 1 ] + 2 );
                s.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--;
                }
            }
        }
Exemple #3
0
        internal void build_tree( DeflateManager s )
        {
            short [] tree = dyn_tree;
            short [] stree = staticTree.treeCodes;
            int elems = staticTree.elems;
            int n, m;
            int max_code = -1;
            int node;

            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;
                }
            }

            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 ];
            }
            this.max_code = max_code;

            for ( n = s.heap_len / 2; n >= 1; n-- )
                s.pqdownheap ( tree, n );

            node = elems;
            do
            {
                n = s.heap [ 1 ];
                s.heap [ 1 ] = s.heap [ s.heap_len-- ];
                s.pqdownheap ( tree, 1 );
                m = s.heap [ 1 ];

                s.heap [ --s.heap_max ] = n;
                s.heap [ --s.heap_max ] = 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;

                s.heap [ 1 ] = node++;
                s.pqdownheap ( tree, 1 );
            }
            while ( s.heap_len >= 2 );

            s.heap [ --s.heap_max ] = s.heap [ 1 ];

            gen_bitlen ( s );

            gen_codes ( tree, max_code, s.bl_count );
        }
Exemple #4
0
        private int _InternalInitializeDeflate( bool wantRfc1950Header )
        {
            if ( istate != null ) throw new CompressionProcessException ( "You may not call InitializeDeflate() after calling InitializeInflate()." );
            dstate = new DeflateManager ();
            dstate.WantRfc1950HeaderBytes = wantRfc1950Header;

            return dstate.Initialize ( this, this.CompressLevel, this.WindowBits, this.Strategy );
        }