deflater.java

j2me解压缩j2me解压缩j2me解压缩j2me解压缩j2me解压缩j2me解压缩j2me解压缩j2me解压缩

    public synchronized void finish() throws IOException
    {
        finish = true;
        int err = c_stream.deflate(JZlib.Z_FINISH);
        if (err == JZlib.Z_STREAM_END)
        {
            finished = true;
        }
        //if(err!=JZlib.Z_OK)System.out.println(ErrorMsg(c_stream,err));
        //err=c_stream.deflateEnd();
        if (err != JZlib.Z_OK && err != JZlib.Z_STREAM_END)
        {
            System.out.println(ErrorMsg(c_stream, err));
            throw new IOException(ErrorMsg(c_stream, err));
        }//if      
    }

    /**
     * Returns true if the end of the compressed data output stream has
     * been reached.
     * @return true if the end of the compressed data output stream has
     * been reached
     */
    public synchronized boolean finished()
    {
        return finished;
    }

    /**
     * Fills specified buffer with compressed data. Returns actual number
     * of bytes of compressed data. A return value of 0 indicates that
     * needsInput() should be called in order to determine if more input
     * data is required.
     * @param b the buffer for the compressed data
     * @param off the start offset of the data
     * @param len the maximum number of bytes of compressed data
     * @return the actual number of bytes of compressed data
     */
    public synchronized int deflate(byte[] b, int off, int len) throws IOException
    {
        if (b == null)
        {
            throw new NullPointerException();
        }
        if (off < 0 || len < 0 || off + len > b.length)
        {
            throw new ArrayIndexOutOfBoundsException();
        }
        return deflateBytes(b, off, len);
    }

    /**
     * Fills specified buffer with compressed data. Returns actual number
     * of bytes of compressed data. A return value of 0 indicates that
     * needsInput() should be called in order to determine if more input
     * data is required.
     * @param b the buffer for the compressed data
     * @return the actual number of bytes of compressed data
     */
    public int deflate(byte[] b) throws IOException
    {
        return deflate(b, 0, b.length);
    }

    /**
     * Returns the ADLER-32 value of the uncompressed data.
     * @return the ADLER-32 value of the uncompressed data
     */
    public synchronized int getAdler()
    {
        if (c_stream == null)
        {
            throw new NullPointerException();
        }
        return (int) c_stream.adler;
    }

    /**
     * Returns the total number of bytes input so far.
     * @return the total number of bytes input so far
     */
    public synchronized int getTotalIn()
    {
        if (c_stream == null)
        {
            throw new NullPointerException();
        }
        return (int) c_stream.total_in;
    }

    /**
     * Returns the total number of bytes output so far.
     * @return the total number of bytes output so far
     */
    public synchronized int getTotalOut()
    {
        if (c_stream == null)
        {
            throw new NullPointerException();
        }
        return (int) c_stream.total_out;
    }

    /**
     * Resets deflater so that a new set of input data can be processed.
     * Keeps current compression level and strategy settings.
     */
    public synchronized void reset() throws IOException
    {
        if (c_stream == null)
        {
            throw new NullPointerException();
        }//if
        c_stream = null;
        init(level, DEFAULT_STRATEGY, nowrap);
        finish = false;
        finished = false;
        //off = len = 0;     
        c_stream.next_in_index = c_stream.avail_in = 0;
    }

    /**
     * Closes the compressor and discards any unprocessed input.
     * This method should be called when the compressor is no longer
     * being used, but will also be called automatically by the
     * finalize() method. Once this method is called, the behavior
     * of the Deflater object is undefined.
     */
    public synchronized void end()
    {
        if (c_stream != null)
        {
            c_stream.free();
            c_stream = null;
        }
    }

    //    /**
    //     * Closes the compressor when garbage is collected.
    //     */
    //    protected void finalize() {
    //     end();
    //    }
    private void init(int level, int strategy, boolean nowrap) throws IOException
    {
        this.level = level;
        this.strategy = strategy;
        c_stream = new ZStream();

        //??? may be correct ZIP data is needed here
        int err;
        if (nowrap)
        {
            //err=c_stream.deflateInit(JZlib.Z_DEFAULT_COMPRESSION,-1);
            err = c_stream.deflateInit(level, -1);
        }
        else
        {
            //err=c_stream.deflateInit(JZlib.Z_DEFAULT_COMPRESSION);
            err = c_stream.deflateInit(level);
        }//if
        if (err == JZlib.Z_STREAM_END)
        {
            finished = true;
        }
        if (err != JZlib.Z_OK)
        {
            System.out.println(ErrorMsg(c_stream, err));
            throw new IOException(ErrorMsg(c_stream, err));
        }//if      
    }

    private int deflateBytes(byte[] b, int off, int len) throws IOException
    {
        //System.out.println("b.length="+b.length+" off="+off+" len="+len);
        final long last_total_out = c_stream.total_out;
        c_stream.next_out = b;
        c_stream.next_out_index = off;
        c_stream.avail_out = len;

        final int err;
        if (finish == true)
        {
            err = c_stream.deflate(JZlib.Z_FINISH);
        }
        else
        {
            err = c_stream.deflate(JZlib.Z_NO_FLUSH);//TODO adjust FLUSH method
        }//if 
        if (err == JZlib.Z_STREAM_END)
        {
            finished = true;
        }
        if (err != JZlib.Z_OK && err != JZlib.Z_STREAM_END)
        {
            System.out.println(ErrorMsg(c_stream, err));
            throw new IOException(ErrorMsg(c_stream, err));
        }//if      
        if (c_stream.total_out > Integer.MAX_VALUE)
        {
            throw new IOException("Internal error: JZlib deflated data is too long");
        }//if
        return (int) (c_stream.total_out - last_total_out);
    }

    private static final void CheckError(ZStream z, int err) throws IOException
    {
        if (err != JZlib.Z_OK)
        {
            String err_s = "zip error: " + err;
            if (z.msg != null)
            {
                err_s = err_s + " (" + z.msg + ")";
            }
            throw new IOException(err_s);
        }//if
    }

    private static final String ErrorMsg(ZStream z, int err) throws IOException
    {
        String ret = null;
        if (err != JZlib.Z_OK)
        {
            String err_s = "zip error: " + err;
            if (z.msg != null)
            {
                err_s = err_s + " (" + z.msg + ")";
            }
            ret = err_s;
        }//if
        return ret;
    }

//==================================================================
    public static void main(String[] args) throws Exception
    {
        final int hlen = 0;
        final byte[] buff = "qwertyuiopasdfghjklzxcvbnm".getBytes();
        int l_in = buff.length;
        final byte[] out_buf = new byte[buff.length + 30];
        Deflater compressor = new Deflater(9);
        System.out.println("#1");
        compressor.reset();
        System.out.println("#2");
        compressor.setInput(buff, 0, l_in);
        System.out.println("#3");
        while (!compressor.needsInput())
        {
            System.out.println("#7");
            compressor.deflate(out_buf, hlen + compressor.getTotalOut(),out_buf.length - (hlen + compressor.getTotalOut()));
            System.out.println("#7.2");
        }//while
        
        System.out.println("#8");
        compressor.finish();
        System.out.println("#9");
        compressor.deflate(out_buf, hlen + compressor.getTotalOut(),
                           out_buf.length - (hlen + compressor.getTotalOut()));
        System.out.println("#10");
        int l_out = compressor.getTotalOut();
    }
}