/**
 * 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
 *
 * Hacked by Ralph Hartley 8/00
 * Instead of acuumultaing the output in an array, write it directly to
 * a stream. A byte array big enough for a large image can be very big.
 *
 * In fact it has been hacked almost beyond recognition.
 */

import java.io.*;
import java.awt.*;
import java.awt.image.*;
import java.util.*;
import java.util.zip.*;
import java.io.*;
import javax.swing.*;

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;

  public static int compress = 5;
  public static int filter = FILTER_SUB | FILTER_UP;
  public static int chunksize;

  protected OutputStream out;
  protected int width, height;
  protected CRC32 crc = new CRC32();
  protected long crcValue;

  public boolean encodeAlpha = true;

  public JLabel status = null;
  public String message = "";

//  public static boolean kill = false;

  /**
   * Class constructor specifying Size of image, and stream to write to.
   * @param int width The total width of the image.
   * @param int height The total height of the image.
   * @param OutPutStream out The stream to write the image to.
   * @see java.awt.Image
   */
  public PngEncoder( int width,int height,OutputStream out) {
    this.width = width;
    this.height = height;
    this.out = out;
  }

  /**
   * Write an array of bytes output stream
   * Note: This routine has the side effect of updating
   * the crc.
   *
   * @param data The data to be written .
   */
  protected void writeBytes( byte[] data) throws IOException {
    out.write(data);
    crc.update(data);
  }

  /**
   * Write an array of bytes into the pngBytes array, specifying number of bytes to write.
   * Note: This routine has the side effect of updating
   * the crc.
   *
   * @param data The data to be written.
   * @param nBytes The number of bytes to be written.
   */
  protected void writeBytes( byte[] data, int nBytes ) throws IOException  {
    out.write(data,0,nBytes);
    crc.update(data,0,nBytes);
  }

  /**
   * Write a two-byte integer into the output.
   *
   * @param n The integer to be written.
   */
  protected void writeInt2( int n ) throws IOException {
    byte[] temp = { (byte)((n >> 8) & 0xff),
        	    (byte) (n & 0xff) };
    writeBytes( temp );
  }

  /**
   * Write a four-byte integer into the output.
   *
   * @param n The integer to be written.
   */
  protected void writeInt4( int n ) throws IOException {
    byte[] temp = { (byte)((n >> 24) & 0xff),
        	    (byte) ((n >> 16) & 0xff ),
        	    (byte) ((n >> 8) & 0xff ),
        	    (byte) ( n & 0xff ) };
    out.write( temp );
    crc.update(temp);
  }

  /**
   * Write a four-byte integer into the output.
   * Do not update crc.
   *
   * @param n The integer to be written.
   */
  protected void writeInt4nocrc( int n ) throws IOException {
    byte[] temp = { (byte)((n >> 24) & 0xff),
        	    (byte) ((n >> 16) & 0xff ),
        	    (byte) ((n >> 8) & 0xff ),
        	    (byte) ( n & 0xff ) };
    out.write( temp );
  }

  /**
   * Write a single byte into the output.
   *
   * @param n The integer to be written.
   */
  protected void writeByte( int b ) throws IOException {
    out.write(b);
    crc.update(b);
  }

  /**
   * Write a string into the output.
   * This uses the getBytes method, so the encoding used will
   * be its default.
   *
   * @param n The integer to be written.
   * @see java.lang.String#getBytes()
   */
  protected void writeString( String s ) throws IOException {
    writeBytes( s.getBytes() );
  }

  /**
   * Write a PNG "IHDR" chunk to the output.
   */
  protected void writeHeader() throws IOException {
    crc.reset();
    writeInt4nocrc( 13 );
    writeString( "IHDR");
//    width = image.getWidth( null );
//    height = image.getHeight( null );
    writeInt4( width );
    writeInt4( height );
    writeByte( 8 ); // bit depth
    writeByte( (encodeAlpha) ? 6 : 2 ); // direct model
    writeByte( 0 ); // compression method
    writeByte( 0 ); // filter method
    writeByte( 0 ); // no interlace
    crcValue = crc.getValue();
    writeInt4nocrc( (int) crcValue );
  }

  int bytesPerPixel = 4;
  byte[] lastline = null;
  byte[] raw = null;
  byte[] line = null;
  int[] pixels = null;
  byte[] deflatebuff;
  int defpos = 0;
  Deflater scrunch;

  /**
   * Writes the current image to the output stream in PNG format, specifying whether to encode alpha or not.
   *
   * @return an array of bytes, or null if there was a problem
   */
  public void start() throws IOException {
//      System.out.println("test");
    byte[]  pngIdBytes = { -119, 80, 78, 71, 13, 10, 26, 10 };

    writeBytes( pngIdBytes );
    writeHeader();

    bytesPerPixel = (encodeAlpha) ? 4 : 3;

    lastline = new byte[bytesPerPixel*width];     // previous line of image for filters.
    line = new byte[bytesPerPixel*width+1];         // current line of image (filtered).
    raw = new byte[bytesPerPixel*width];          // current line of image (unfiltered).
    pixels = new int[width];     // current line of imge (packed).
    for (int j=0;j<width*bytesPerPixel;j++) lastline[j] = (byte)0;
      
    scrunch = new Deflater( compress );

    if (chunksize==0) chunksize = 10000;

    deflatebuff = new byte[chunksize];
    defpos = 0;

  }

  /**
   * Write a slice of image data to the output stream.
   * This may write one or more PNG "IDAT" chunks.
   */
  public void addSlice(BufferedImage image,
        	       JLabel status,String message) throws IOException,CookKillException {
    int sliceheight = image.getHeight();
    int progress = -1;

    for (int row=0; row<sliceheight; row++) {

      if (Carto.kill==Carto.PRINTKILL) throw new CookKillException();

      if (row*100/sliceheight > progress && status!=null) {
        status.setText(message+" "+(progress=row*100/sliceheight)+"%");
      }

      // Get the pixels for this row.
      pixels = (int[]) image.getRaster().getDataElements(0,row,width,1,pixels);
        
      line[0] = (byte) filter; 
        
      // convert to bytes
      for (int j=0;j<width;j++) {
        for (int k=0;k<3;k++)
          raw[j*bytesPerPixel+k] = (byte)((pixels[j] >> (8*(2-k))) & 0xff);
        if (encodeAlpha) raw[j*bytesPerPixel+3] = (byte) ((pixels[j] >> 24) & 0xff );
      }

      // filter bytes
      for (int j = 0;j<bytesPerPixel*width;j++) {
        if (filter == FILTER_SUB && j>=bytesPerPixel)
          line[j+1] = (byte)(raw[j] - raw[j-bytesPerPixel]);
        else if (filter == FILTER_UP)
          line[j+1] = (byte)(raw[j] - lastline[j]);
        else line[j+1] = raw[j];
      }
      byte[] tmp = lastline;
      lastline = raw;
      raw = tmp;

      while (!scrunch.needsInput()) {
        defpos += scrunch.deflate(deflatebuff,defpos,chunksize-defpos);
        if (defpos==chunksize) {
          writeDat(deflatebuff,defpos);
          defpos = 0;
        }
      }

      scrunch.setInput(line);
    }
  }

  public void finish() throws IOException{
    try {
      scrunch.finish();
      
      while (!scrunch.finished()) {
        defpos += scrunch.deflate(deflatebuff,defpos,chunksize-defpos);
        if (defpos==chunksize || scrunch.finished()) {
          writeDat(deflatebuff,defpos);
          defpos = 0;
        }
      }
      writeEnd();
    } finally {clean();}
  }

  public void clean() {
    if (scrunch!=null) scrunch.end();
    deflatebuff=null;
    lastline=null;
    line=null;
    raw=null;
    pixels=null;
    if (out!=null) try {out.close();}catch(IOException e){}
    out=null;
  }

  /**
   * Write an IDAT chunk.
   * @param data the (compressed) data to be written.
   * @param size The number of bytes.
   */
  protected void writeDat(byte[] data,int size) throws IOException {
    crc.reset();
    writeInt4nocrc(size);
    writeString("IDAT");

    writeBytes(data,size);
        
    crcValue = crc.getValue();
    writeInt4nocrc( (int) crcValue );
  }

  /**
   * Write a PNG "IEND" chunk into the pngBytes array.
   */
  protected void writeEnd() throws IOException {
    writeInt4nocrc( 0 );
    crc.reset();
    writeString( "IEND" );
    crcValue = crc.getValue();
    writeInt4nocrc( (int) crcValue );
  }
}