/* GIFFile.java -- GIF decoder
   Copyright (C) 2006  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath 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
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */

package gnu.javax.imageio.gif;

import java.io.IOException;
import java.io.InputStream;
import java.util.Vector;

/**
 * GIFFile - reads a GIF file.
 * 
 * This class only does the bare minimum work, and returns the data in raw
 * formats (described below). The class is J2ME compatible, and hopefully
 * we can keep it that way without any significant overhead.
 *
 * @author Sven de Marothy. 
 */
public class GIFFile 
{
  // "NETSCAPE2.0" - identifier
  private final static byte[] nsBlock = new byte[]
  {0x4e, 0x45, 0x54, 0x53, 0x43, 0x41, 0x50, 0x45, 0x32, 0x2e, 0x30 };

  /**
   * Block identifiers
   */
  private final static int EXTENSION = 0x21;
  private final static int LOCAL = 0x2C;
  private final static int TERMINATOR = 0x3B;

  /**
   * Extension block types
   */
  private final static int EXTENSION_COMMENT = 254;
  private final static int EXTENSION_GCONTROL = 249; 
  private final static int EXTENSION_APPLICATION = 255;

  /**
   * Undraw commands for animation.
   */
  private final static int UNDRAW_OVERWRITE = 1;
  private final static int UNDRAW_RESTORE_BACKGROUND = 2;
  private final static int UNDRAW_RESTORE_PREVIOUS = 3; 

  /**
   * Image position and dimensions (images may be partial)
   */
  private int x, y, width, height;

  /**
   * Global dimensions
   */
  private int globalWidth, globalHeight;

  /**
   * Background color index.
   */
  private byte bgIndex;

  /**
   * Number of colors
   */
  private int nColors;

  /**
   * Global palette, if any
   */
  private byte[] globalPalette;

  /**
   * Any
   */
  private boolean hasGlobalColorMap;

  /**
   * Local palette, if any (used if available)
   */
  private byte[] localPalette;

  /**
   * Interlaced GIF or not?
   */
  private boolean interlaced;

  /**
   * Has transparency?
   */
  private boolean hasTransparency;
  
  /**
   * Undraw mode (animations)
   */
  private int undraw;

  /**
   * Transparent index;
   */
  private int transparentIndex;

  /**
   * The uncompressed raster
   */
  private byte[] raster;

  /**
   * The compressed data (freed after uncompressing)
   */
  private byte[] compressedData;

  /**
   * Frame delay in 100ths of a second ( centiseconds, metrically )
   */
  private int duration;

  /**
   * Indices used during decompression
   */
  private int dataBlockIndex;

  /**
   * The file comment , if a comment block exists.
   */
  private String comment;

  /**
   * Fields used by getBits()
   */
  private int remainingBits = 0;
  private int currentBits = 0;

  /**
   * Netscape animation extension
   */
  private boolean isLooped = false;

  /** Number of loops, 0 = infinite */
  private int loops;

  /**
   * Additional frames if it's an animated GIF.
   */
  private Vector animationFrames;

  /**
   * Loads the file from an input stream, which is not closed.
   * @throws IOException if an I/O error occured.
   * @throws GIFException if some file parsing error occured
   */
  public GIFFile(InputStream in) throws IOException, GIFException 
  {
    // Validate the signature
    if( !readSignature( in ) )
      throw new GIFException("Invalid GIF signature.");

    {
      byte[] data = new byte[7];
      if (in.read(data) != 7)
	throw new IOException("Couldn't read global descriptor.");

      globalWidth = ((data[1] & 0xFF) << 8) | (data[0] & 0xFF);
      globalHeight = ((data[3] & 0xFF) << 8) | (data[2] & 0xFF);
      byte flags = data[4];
      bgIndex = data[5];
      nColors = (1 << (( flags & 0x07) + 1));
      hasGlobalColorMap = ((flags & 0x80) != 0);
    }

    if( hasGlobalColorMap )
      {
	globalPalette = new byte[ nColors * 3 ];
	if( in.read( globalPalette ) != nColors * 3 )
	  throw new IOException("Couldn't read color map.");
      }
    
    int c = in.read();
    while( c == EXTENSION )
      {
	readExtension( in );
	c = in.read();
      }
      
    if( c != LOCAL )
      throw new GIFException("Extension blocks not followed by a local descriptor ("+c+")");

    loadImage( in );
    c = in.read(); 

    if( c == TERMINATOR ) // Not an animated GIF.
      return;

    // Load animation frames. Just quit if an error occurs instead 
    // of throwing an exception.
    animationFrames = new Vector();
    try 
      {
	while( c != TERMINATOR )
	  {
	    animationFrames.add( new GIFFile( this, in, c ) );
	    c = in.read(); 
	  }
      }
    catch(IOException ioe)
      {
      }
    catch(GIFException gife)
      {
      }
  }

  /**
   * Constructor for additional animation frames.
   */
  private GIFFile(GIFFile parent, InputStream in, int c) 
    throws IOException, GIFException 
  {
    // Copy global properties.
    globalWidth = parent.globalWidth;
    globalHeight = parent.globalHeight;
    nColors = parent.nColors;
    globalPalette = parent.globalPalette;
    hasGlobalColorMap = parent.hasGlobalColorMap;
    interlaced = parent.interlaced;
    comment = parent.comment;
    isLooped = parent.isLooped;
    loops = parent.loops;

    while( c == EXTENSION )
    {
      readExtension( in );      
      c = in.read();
    }
      
    if( c != LOCAL )
      throw new GIFException("Extension blocks not followed by a local descriptor ("+c+")");

    loadImage( in );
  }

  /**
   * Reads a GIF file signature from an inputstream and checks it.
   *
   * @param in - the stream (reads 6 bytes, does not close or reset).
   * @return true if the signature is a valid GIF signature.
   * @throws an IOException if the signature could not be read.
   */
  public static boolean readSignature( InputStream in ) throws IOException
  { 
    byte[] data = new byte[6];
    if (in.read(data) != 6)
      throw new IOException("Couldn't read signature.");

    if( data[0] != 0x47 || data[1] != 0x49 || data[2] != 0x46 ||
	data[3] != 0x38 ) // GIF8
      return false;

    if( (data[4] != 0x39 && data[4] != 0x37) || // 7 | 9
	(data[5] != 0x61 && data[5] != 0x62) ) // 'a' or 'b'
      return false;
    return true;
  }
  

  /**
   * Loads the image local descriptor and then loads/decodes the image raster,
   * and then performs any necessary postprocessing like deinterlacing.
   */
  private void loadImage(InputStream in)
    throws IOException, GIFException
  {
    readLocal( in );

    try
      {
	decodeRaster( in );
      }
    catch(ArrayIndexOutOfBoundsException aioobe)
      {
	throw new GIFException("Error decompressing image.");
      }
    
    if( interlaced )  // Clean up
      deinterlace();
    packPixels();
  }

  /**
   * Pack the pixels if it's a 2, 4 or 16 color image.
   * While GIF may support any number of colors from 2-256, we won't bother
   * trying to pack pixels not resulting in even byte boundaries.
   * (AWT doesn't support that anyway, and most apps do the same.)
   */
  private void packPixels()
  {
    if( nColors != 2 && nColors != 4 && nColors != 16 )
      return;

    int nbits = 1;
    int ppbyte = 8; 
    if( nColors == 4 )
      {
	nbits = 2;
	ppbyte = 4;
      }
    else if( nColors == 16 )
      {
	nbits = 4;
	ppbyte = 2;
      }

    int rem = (width & (ppbyte - 1));
    int w = ( rem == 0 ) ? (width / ppbyte) : 
      ((width + ppbyte - rem) / ppbyte); 
    byte[] nr = new byte[ w * height ];
    for(int j = 0; j < height; j++)
      {
	for(int i = 0; i < width - ppbyte; i += ppbyte)
	  for(int k = 0; k < ppbyte; k++)
	    nr[ j * w + (i / ppbyte) ] |= (byte)((raster[ width * j + i + k ]
						  << (8 - nbits * (1 + k))));
 	for(int i = 0; i < rem; i++)
 	  nr[ j * w + w - 1 ] |= (byte)((raster[ width * j + width - rem + i ]
					 << (nbits * (rem - i))));
      }
    raster = nr;
  }

  /**
   * Returns the (global) width
   */
  public int getWidth()
  {
    return width;
  }

  /**
   * Returns the image height
   */
  public int getHeight()
  {
    return height;
  }

  /**
   * Returns the # of colors.
   */
  public int getNColors()
  {
    return nColors;
  }

  /**
   * Returns whether the GIF has transparency.
   */
  public boolean hasTransparency()
  {
    return hasTransparency;
  }

  /**
   * Returns the index of the transparent color.
   */
  public int getTransparentIndex()
  {
    return transparentIndex;
  }

  /**
   * Retuns the GIF file comment, or null if none exists.
   */
  public String getComment()
  {
    return comment;
  }

  /**
   * Get duration of the frame for animations.
   */
  public int getDuration()
  {
    return duration;
  }

  /**
   * Deinterlaces the image.
   */
  private void deinterlace()
  {
    byte[] nr = new byte[ width * height ];
    int n = 0;
    for(int i = 0; i < ((height + 7) >> 3); i++)
      {
	System.arraycopy( raster, n, nr, width * i * 8, width );
	n += width;
      }
    for(int i = 0; i < ((height + 3) >> 3); i++)
      {
	System.arraycopy( raster, n, nr, width * ( 8 * i + 4 ), width );
	n += width;
      }
    for(int i = 0; i < (height >> 2); i++)
      {
	System.arraycopy( raster, n, nr, width * (4 * i + 2), width );
	n += width;
      }
    for(int i = 0; i < (height >> 1); i++)
      {
	System.arraycopy( raster, n, nr, width * (2 * i + 1), width );
	n += width;
      }
    raster = nr;
  }

  /**
   * Reads the local descriptor
   */
  private void readLocal(InputStream in) throws IOException
  {
    byte[] data = new byte[9];
    if (in.read(data) != 9)
      throw new IOException("Couldn't read local descriptor.");
    x = ((data[1] & 0xFF) << 8) | (data[0] & 0xFF);
    y = ((data[3] & 0xFF) << 8) | (data[2] & 0xFF);
    width = ((data[5] & 0xFF) << 8) | (data[4] & 0xFF);
    height = ((data[7] & 0xFF) << 8) | (data[6] & 0xFF);
    byte flags = data[8];
    interlaced = (( flags & 0x40 ) != 0);
    if( (flags & 0x80) != 0 )
      { // has a local color map
	int nLocalColors = (1 << (( flags & 0x07) + 1));
	if( !hasGlobalColorMap )
	  nColors = nLocalColors;
	localPalette = new byte[ nLocalColors * 3 ];
	if( in.read( localPalette ) != nLocalColors * 3 )
	  throw new IOException("Couldn't read color map.");
      }
  }   

  /**
   * Returns the image's palette in raw format 
   * (r0,g0,b0,r1,g1,b2..r(Ncolors-1),g(Ncolors-1),b(Ncolors-1))
   */
  public byte[] getRawPalette()
  {
    return hasGlobalColorMap ? globalPalette : localPalette;
  }

  /**
   * Returns the image file for animated gifs.
   */
  public GIFFile getImage( int index )
  {
    if( index == 0 )
      return this;
    if( animationFrames == null )
      throw new ArrayIndexOutOfBoundsException("Only one image in file");
    return (GIFFile)animationFrames.elementAt( index - 1 );
  }

  /**
   * Return the image's raw image data.
   * If the color depth is 1,2 or 4 bits per pixel the pixels are packed
   * and the scanlines padded up to the nearest byte if needed.
   */
  public byte[] getRawImage()
  {
    return raster;
  }

  /**
   * Return the number of images in the GIF file
   */
  public int nImages()
  {
    if( animationFrames != null )
      return 1 + animationFrames.size();
    return 1;
  }

  /**
   * Handles extension blocks.
   */
  private void readExtension(InputStream in) throws IOException, GIFException 
  {
    int functionCode = in.read();
    byte[] data = readData(in);
    switch( functionCode )
      {
      case EXTENSION_COMMENT: // comment block
	comment = new String(data, "8859_1");
	break;

      case EXTENSION_GCONTROL: // Graphics control extension
	undraw = (data[0] & 0x1C) >> 2;
	// allegedly there can be bad values of this.
	if( undraw < 1 && undraw > 3 ) undraw = 1; 
	hasTransparency = ((data[0] & 0x01) == 1);
	transparentIndex = (data[3] & 0xFF);
	duration = ((data[2] & 0xFF) << 8) | (data[1] & 0xFF);
	break;

	// Application extension. We only parse the Netscape animation
	// extension here. Which is the only one most use anyway.
      case EXTENSION_APPLICATION:
	boolean isNS = true;
	for(int i = 0; i < nsBlock.length; i++ )
	  if( nsBlock[i] != data[i] )
	    isNS = false;
	if( isNS )
	  {
	    isLooped = true;
	    loops = ((data[12] & 0xFF) << 8) | (data[13] & 0xFF);
	  }
	break;

      default:
	break;
      }
  }

  /**
   * Reads a series of data blocks and merges them into a single one.
   */
  private byte[] readData(InputStream in) throws IOException
  {
    Vector v = new Vector();
    int totalBytes = 0;

    int n = in.read();
    do
      {
	totalBytes += n;
	byte[] block = new byte[ n ];
	in.read(block);
	v.add(block);
	n = in.read();
      }
    while( n > 0 );

    n = 0;
    byte[] bigBuffer = new byte[ totalBytes ];
    for( int i = 0; i < v.size(); i++ )
      {
	byte[] block = (byte[])v.elementAt(i);
	System.arraycopy(block, 0, bigBuffer, n, block.length);
	n += block.length;
      }
    return bigBuffer;
  }

  /**
   * Loads a compressed image block and decompresses it.
   */
  private void decodeRaster(InputStream in) throws IOException
  {
    int initialCodeSize = in.read();
    compressedData = readData( in );
    dataBlockIndex = 0;

    int rasterIndex = 0; // Index into the raster
    int clearCode = (1 << initialCodeSize); // 256 usually
    int endCode = clearCode + 1; // The stop code.

    raster = new byte[ width * height ];

    int codeSize = initialCodeSize + 1;
    int code = getBits( codeSize ); // = clear
    int nextCode = endCode + 1;

    /*
     * Initialize LZW dictionary
     *
     * First index - code #
     * Second index:
     * 0 = color index
     * 1 = parent (-1 - no parent)
     * 2 = first value
     * 3 - depth
     * The latter two aren't strictly necessary but make things faster, since
     * copying the values forward is faster than going back and looking.
     */
    short[][] dictionary = new short[ 4096 ][ 4 ];

    for(short i = 0; i < nColors; i ++ )
      {
	dictionary[i][0] = i;  // color index	
	dictionary[i][1] = -1; // parent
	dictionary[i][2] = i;  // first	
	dictionary[i][3] = 1;  // depth
      }

    code = getBits( codeSize ); // get second code
    raster[ rasterIndex++ ] = (byte)dictionary[code][0];
    int old = code;    
    code = getBits( codeSize ); // start at the third code
    int c;

    do
      {
	if( code == clearCode )
	  {
	    codeSize = initialCodeSize + 1;
 	    nextCode = endCode + 1; 
	    // get and output second code
	    code = getBits( codeSize ); 
	    raster[ rasterIndex++ ] = (byte)dictionary[code][0];
	    old = code;
	  }
	else
	  {
	    dictionary[nextCode][1] = (short)old; // parent = old
	    dictionary[nextCode][2] = dictionary[old][2]; // first pixel
	    dictionary[nextCode][3] = (short)(dictionary[old][3] + 1); // depth
	
	    // appended pixel  = first pixel of c
	    if( code < nextCode )
	      {
		dictionary[nextCode][0] = dictionary[code][2]; 
		old = code;
	      }
	    else // first of old
	      {
		dictionary[nextCode][0] = dictionary[old][2]; 
		old = nextCode;
	      }

	    c = old;
	    // output the code c
	    int depth = dictionary[c][3];
	    for( int i = depth - 1; i >= 0; i-- )
	      {
		raster[ rasterIndex + i ] = (byte)dictionary[c][0];
		c = dictionary[c][1]; // go to parent.
	      }
	    rasterIndex += depth;
	    nextCode ++;

	    if( codeSize < 12 && nextCode >= (1 << codeSize) )
	      codeSize++;
	  }
	code = getBits( codeSize );
      }
    while( code != endCode && dataBlockIndex < compressedData.length );
    
    compressedData = null; // throw away compressed data.
  }

  /**
   * Returns nbits number of bits (in the LSBs) from compressedData
   */
  private int getBits( int nbits )
  {
    while( nbits > remainingBits )
      {
	int c = (compressedData[ dataBlockIndex++ ] & 0xFF) << remainingBits;
	currentBits |= c;
	remainingBits += 8;
      }
    int rval = (currentBits & ((1 << nbits) - 1));
    currentBits = (currentBits >> nbits);
    remainingBits -= nbits;
    return rval;
  }

  /**
   * Generic exception used by GIFFile to report decoding errors.
   */
  public static class GIFException extends Exception 
  {
    public GIFException(String message)
    {
      super(message);
    }
  }
}