package com.keypoint;/** * PngEncoder takes a Java Image object and creates a byte string which can be saved as a PNG file. * The Image is presumed to use the DirectColorModel. * * Thanks to Jay Denny at KeyPoint Software *    http://www.keypoint.com/ * who let me develop this code on company time. * * You may contact me with (probably very-much-needed) improvements, * comments, and bug fixes at: * *   david@catcode.com * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. *  * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. *  * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA * A copy of the GNU LGPL may be found at * http://www.gnu.org/copyleft/lesser.html, * * @author J. David Eisenberg * @version 1.4, 31 March 2000 */import java.awt.*;import java.awt.image.*;import java.util.*;import java.util.zip.*;import java.io.*;public class PngEncoder extends Object{    /** Constant specifying that alpha channel should be encoded. */    public static final boolean ENCODE_ALPHA=true;    /** Constant specifying that alpha channel should not be encoded. */    public static final boolean NO_ALPHA=false;    /** Constants for filters */    public static final int FILTER_NONE = 0;    public static final int FILTER_SUB = 1;    public static final int FILTER_UP = 2;    public static final int FILTER_LAST = 2;    protected byte[] pngBytes;    protected byte[] priorRow;    protected byte[] leftBytes;    protected Image image;    protected int width, height;    protected int bytePos, maxPos;    protected int hdrPos, dataPos, endPos;    protected CRC32 crc = new CRC32();    protected long crcValue;    protected boolean encodeAlpha;    protected int filter;    protected int bytesPerPixel;    protected int compressionLevel;    /**     * Class constructor     *     */    public PngEncoder()    {        this( null, false, FILTER_NONE, 0 );    }    /**     * Class constructor specifying Image to encode, with no alpha channel encoding.     *     * @param image A Java Image object which uses the DirectColorModel     * @see java.awt.Image     */    public PngEncoder( Image image )    {        this(image, false, FILTER_NONE, 0);    }    /**     * Class constructor specifying Image to encode, and whether to encode alpha.     *     * @param image A Java Image object which uses the DirectColorModel     * @param encodeAlpha Encode the alpha channel? false=no; true=yes     * @see java.awt.Image     */    public PngEncoder( Image image, boolean encodeAlpha )    {        this(image, encodeAlpha, FILTER_NONE, 0);    }    /**     * Class constructor specifying Image to encode, whether to encode alpha, and filter to use.     *     * @param image A Java Image object which uses the DirectColorModel     * @param encodeAlpha Encode the alpha channel? false=no; true=yes     * @param whichFilter 0=none, 1=sub, 2=up     * @see java.awt.Image     */    public PngEncoder( Image image, boolean encodeAlpha, int whichFilter )    {        this( image, encodeAlpha, whichFilter, 0 );    }    /**     * Class constructor specifying Image source to encode, whether to encode alpha, filter to use, and compression level.     *     * @param image A Java Image object     * @param encodeAlpha Encode the alpha channel? false=no; true=yes     * @param whichFilter 0=none, 1=sub, 2=up     * @param compLevel 0..9     * @see java.awt.Image     */    public PngEncoder( Image image, boolean encodeAlpha, int whichFilter,       int compLevel)    {        this.image = image;        this.encodeAlpha = encodeAlpha;        setFilter( whichFilter );        if (compLevel >=0 && compLevel <=9)        {            this.compressionLevel = compLevel;        }    }    /**     * Set the image to be encoded     *     * @param image A Java Image object which uses the DirectColorModel     * @see java.awt.Image     * @see java.awt.image.DirectColorModel     */    public void setImage( Image image )    {        this.image = image;        pngBytes = null;    }    /**     * Creates an array of bytes that is the PNG equivalent of the current image, specifying whether to encode alpha or not.     *     * @param encodeAlpha boolean false=no alpha, true=encode alpha     * @return an array of bytes, or null if there was a problem     */    public byte[] pngEncode( boolean encodeAlpha )    {        byte[]  pngIdBytes = { -119, 80, 78, 71, 13, 10, 26, 10 };        int     i;        if (image == null)        {            return null;        }        width = image.getWidth( null );        height = image.getHeight( null );        this.image = image;        /*         * start with an array that is big enough to hold all the pixels         * (plus filter bytes), and an extra 200 bytes for header info         */        pngBytes = new byte[((width+1) * height * 3) + 200];        /*         * keep track of largest byte written to the array         */        maxPos = 0;        bytePos = writeBytes( pngIdBytes, 0 );        hdrPos = bytePos;        writeHeader();        dataPos = bytePos;        if (writeImageData())        {            writeEnd();            pngBytes = resizeByteArray( pngBytes, maxPos );        }        else        {            pngBytes = null;        }        return pngBytes;    }    /**     * Creates an array of bytes that is the PNG equivalent of the current image.     * Alpha encoding is determined by its setting in the constructor.     *     * @return an array of bytes, or null if there was a problem     */    public byte[] pngEncode()    {        return pngEncode( encodeAlpha );    }    /**     * Set the alpha encoding on or off.     *     * @param encodeAlpha  false=no, true=yes     */    public void setEncodeAlpha( boolean encodeAlpha )    {        this.encodeAlpha = encodeAlpha;    }    /**     * Retrieve alpha encoding status.     *     * @return boolean false=no, true=yes     */    public boolean getEncodeAlpha()    {        return encodeAlpha;    }    /**     * Set the filter to use     *     * @param whichFilter from constant list     */    public void setFilter( int whichFilter )    {        this.filter = FILTER_NONE;        if ( whichFilter <= FILTER_LAST )        {            this.filter = whichFilter;        }    }    /**     * Retrieve filtering scheme     *     * @return int (see constant list)     */    public int getFilter()    {        return filter;    }        /**     * Set the compression level to use     *     * @param level 0 through 9     */    public void setCompressionLevel( int level )    {        if ( level >= 0 && level <= 9)        {            this.compressionLevel = level;        }    }    /**     * Retrieve compression level     *     * @return int in range 0-9     */    public int getCompressionLevel()    {        return compressionLevel;    }    /**     * Increase or decrease the length of a byte array.     *     * @param array The original array.     * @param newLength The length you wish the new array to have.     * @return Array of newly desired length. If shorter than the     *         original, the trailing elements are truncated.     */    protected byte[] resizeByteArray( byte[] array, int newLength )    {        byte[]  newArray = new byte[newLength];        int     oldLength = array.length;        System.arraycopy( array, 0, newArray, 0,            Math.min( oldLength, newLength ) );        return newArray;    }    /**     * Write an array of bytes into the pngBytes array.     * Note: This routine has the side effect of updating     * maxPos, the largest element written in the array.     * The array is resized by 1000 bytes or the length     * of the data to be written, whichever is larger.     *     * @param data The data to be written into pngBytes.     * @param offset The starting point to write to.     * @return The next place to be written to in the pngBytes array.     */    protected int writeBytes( byte[] data, int offset )    {        maxPos = Math.max( maxPos, offset + data.length );        if (data.length + offset > pngBytes.length)        {            pngBytes = resizeByteArray( pngBytes, pngBytes.length +                Math.max( 1000, data.length ) );        }        System.arraycopy( data, 0, pngBytes, offset, data.length );        return offset + data.length;    }