/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package com.sun.imageio.plugins.gif;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.image.BufferedImage;

import java.awt.image.DataBuffer;

import java.awt.image.WritableRaster;

import java.io.BufferedInputStream;

import java.io.DataInputStream;

import java.io.EOFException;

import java.io.InputStream;

import java.io.IOException;

import java.nio.ByteOrder;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import javax.imageio.IIOException;

import javax.imageio.ImageReader;

import javax.imageio.ImageReadParam;

import javax.imageio.ImageTypeSpecifier;

import javax.imageio.metadata.IIOMetadata;

import javax.imageio.spi.ImageReaderSpi;

import javax.imageio.stream.ImageInputStream;

import com.sun.imageio.plugins.common.ReaderUtil;

public class GIFImageReader extends ImageReader {

    // The current ImageInputStream source.

    ImageInputStream stream = null;

    // Per-stream settings

    // True if the file header including stream metadata has been read.

    boolean gotHeader = false;

    // Global metadata, read once per input setting.

    GIFStreamMetadata streamMetadata = null;

    // The current image index

    int currIndex = -1;

    // Metadata for image at 'currIndex', or null.

    GIFImageMetadata imageMetadata = null;

    // A List of Longs indicating the stream positions of the

    // start of the metadata for each image.  Entries are added

    // as needed.

    List imageStartPosition = new ArrayList();

    // Length of metadata for image at 'currIndex', valid only if

    // imageMetadata != null.

    int imageMetadataLength;

    // The number of images in the stream, if known, otherwise -1.

    int numImages = -1;

    // Variables used by the LZW decoding process

    byte[] block = new byte[255];

    int blockLength = 0;

    int bitPos = 0;

    int nextByte = 0;

    int initCodeSize;

    int clearCode;

    int eofCode;

    // 32-bit lookahead buffer

    int next32Bits = 0;

    // Try if the end of the data blocks has been found,

    // and we are simply draining the 32-bit buffer

    boolean lastBlockFound = false;

    // The image to be written.

    BufferedImage theImage = null;

    // The image's tile.

    WritableRaster theTile = null;

    // The image dimensions (from the stream).

    int width = -1, height = -1;

    // The pixel currently being decoded (in the stream's coordinates).

    int streamX = -1, streamY = -1;

    // The number of rows decoded

    int rowsDone = 0;

    // The current interlace pass, starting with 0.

    int interlacePass = 0;

    // End per-stream settings

    // Constants used to control interlacing.

    static final int[] interlaceIncrement = { 8, 8, 4, 2, -1 };

    static final int[] interlaceOffset = { 0, 4, 2, 1, -1 };

    public GIFImageReader(ImageReaderSpi originatingProvider) {

        super(originatingProvider);

    }

    // Take input from an ImageInputStream

    public void setInput(Object input,

                         boolean seekForwardOnly,

                         boolean ignoreMetadata) {

        super.setInput(input, seekForwardOnly, ignoreMetadata);

        if (input != null) {

            if (!(input instanceof ImageInputStream)) {

                throw new IllegalArgumentException

                    ("input not an ImageInputStream!");

            }

            this.stream = (ImageInputStream)input;

        } else {

            this.stream = null;

        }

        // Clear all values based on the previous stream contents

        resetStreamSettings();

    }

    public int getNumImages(boolean allowSearch) throws IIOException {

        if (stream == null) {

            throw new IllegalStateException("Input not set!");

        }

        if (seekForwardOnly && allowSearch) {

            throw new IllegalStateException

                ("seekForwardOnly and allowSearch can't both be true!");

        }

        if (numImages > 0) {

            return numImages;

        }

        if (allowSearch) {

            this.numImages = locateImage(Integer.MAX_VALUE) + 1;

        }

        return numImages;

    }

    // Throw an IndexOutOfBoundsException if index < minIndex,

    // and bump minIndex if required.

    private void checkIndex(int imageIndex) {

        if (imageIndex < minIndex) {

            throw new IndexOutOfBoundsException("imageIndex < minIndex!");

        }

        if (seekForwardOnly) {

            minIndex = imageIndex;

        }

    }

    public int getWidth(int imageIndex) throws IIOException {

        checkIndex(imageIndex);

        int index = locateImage(imageIndex);

        if (index != imageIndex) {

            throw new IndexOutOfBoundsException();

        }

        readMetadata();

        return imageMetadata.imageWidth;

    }

    public int getHeight(int imageIndex) throws IIOException {

        checkIndex(imageIndex);

        int index = locateImage(imageIndex);

        if (index != imageIndex) {

            throw new IndexOutOfBoundsException();

        }

        readMetadata();

        return imageMetadata.imageHeight;

    }

    public Iterator getImageTypes(int imageIndex) throws IIOException {

        checkIndex(imageIndex);

        int index = locateImage(imageIndex);

        if (index != imageIndex) {

            throw new IndexOutOfBoundsException();

        }

        readMetadata();

        List l = new ArrayList(1);

        byte[] colorTable;

        if (imageMetadata.localColorTable != null) {

            colorTable = imageMetadata.localColorTable;

        } else {

            colorTable = streamMetadata.globalColorTable;

        }

        // Normalize color table length to 2^1, 2^2, 2^4, or 2^8

        int length = colorTable.length/3;

        int bits;

        if (length == 2) {

            bits = 1;

        } else if (length == 4) {

            bits = 2;

        } else if (length == 8 || length == 16) {

            // Bump from 3 to 4 bits

            bits = 4;

        } else {

            // Bump to 8 bits

            bits = 8;

        }

        int lutLength = 1 << bits;

        byte[] r = new byte[lutLength];

        byte[] g = new byte[lutLength];

        byte[] b = new byte[lutLength];

        // Entries from length + 1 to lutLength - 1 will be 0

        int rgbIndex = 0;

        for (int i = 0; i < length; i++) {

            r[i] = colorTable[rgbIndex++];

            g[i] = colorTable[rgbIndex++];

            b[i] = colorTable[rgbIndex++];

        }

        byte[] a = null;

        if (imageMetadata.transparentColorFlag) {

            a = new byte[lutLength];

            Arrays.fill(a, (byte)255);

            // Some files erroneously have a transparent color index

            // of 255 even though there are fewer than 256 colors.

            int idx = Math.min(imageMetadata.transparentColorIndex,

                               lutLength - 1);

            a[idx] = (byte)0;

        }

        int[] bitsPerSample = new int[1];

        bitsPerSample[0] = bits;

        l.add(ImageTypeSpecifier.createIndexed(r, g, b, a, bits,

                                               DataBuffer.TYPE_BYTE));

        return l.iterator();

    }

    public ImageReadParam getDefaultReadParam() {

        return new ImageReadParam();

    }

    public IIOMetadata getStreamMetadata() throws IIOException {

        readHeader();

        return streamMetadata;

    }

    public IIOMetadata getImageMetadata(int imageIndex) throws IIOException {

        checkIndex(imageIndex);

        int index = locateImage(imageIndex);

        if (index != imageIndex) {

            throw new IndexOutOfBoundsException("Bad image index!");

        }

        readMetadata();

        return imageMetadata;

    }

    // BEGIN LZW STUFF

    private void initNext32Bits() {

        next32Bits = block[0] & 0xff;

        next32Bits |= (block[1] & 0xff) << 8;

        next32Bits |= (block[2] & 0xff) << 16;

        next32Bits |= block[3] << 24;

        nextByte = 4;

    }

    // Load a block (1-255 bytes) at a time, and maintain

    // a 32-bit lookahead buffer that is filled from the left

    // and extracted from the right.

    //

    // When the last block is found, we continue to

    //

    private int getCode(int codeSize, int codeMask) throws IOException {

        if (bitPos + codeSize > 32) {

            return eofCode; // No more data available

        }

        int code = (next32Bits >> bitPos) & codeMask;

        bitPos += codeSize;

        // Shift in a byte of new data at a time

        while (bitPos >= 8 && !lastBlockFound) {

            next32Bits >>>= 8;

            bitPos -= 8;

            // Check if current block is out of bytes

            if (nextByte >= blockLength) {

                // Get next block size

                blockLength = stream.readUnsignedByte();

                if (blockLength == 0) {

                    lastBlockFound = true;

                    return code;

                } else {

                    int left = blockLength;

                    int off = 0;

                    while (left > 0) {

                        int nbytes = stream.read(block, off, left);

                        off += nbytes;

                        left -= nbytes;

                    }

                    nextByte = 0;

                }

            }

            next32Bits |= block[nextByte++] << 24;

        }

        return code;

    }

    public void initializeStringTable(int[] prefix,

                                      byte[] suffix,

                                      byte[] initial,

                                      int[] length) {

        int numEntries = 1 << initCodeSize;

        for (int i = 0; i < numEntries; i++) {

            prefix[i] = -1;

            suffix[i] = (byte)i;

            initial[i] = (byte)i;

            length[i] = 1;

        }

        // Fill in the entire table for robustness against

        // out-of-sequence codes.

        for (int i = numEntries; i < 4096; i++) {

            prefix[i] = -1;

            length[i] = 1;

        }

        // tableIndex = numEntries + 2;

        // codeSize = initCodeSize + 1;

        // codeMask = (1 << codeSize) - 1;

    }

    Rectangle sourceRegion;

    int sourceXSubsampling;

    int sourceYSubsampling;

    int sourceMinProgressivePass;

    int sourceMaxProgressivePass;

    Point destinationOffset;

    Rectangle destinationRegion;

    // Used only if IIOReadUpdateListeners are present

    int updateMinY;

    int updateYStep;

    boolean decodeThisRow = true;

    int destY = 0;

    byte[] rowBuf;

    private void outputRow() {

        // Clip against ImageReadParam

        int width = Math.min(sourceRegion.width,

                             destinationRegion.width*sourceXSubsampling);

        int destX = destinationRegion.x;

        if (sourceXSubsampling == 1) {

            theTile.setDataElements(destX, destY, width, 1, rowBuf);

        } else {

            for (int x = 0; x < width; x += sourceXSubsampling, destX++) {

                theTile.setSample(destX, destY, 0, rowBuf[x] & 0xff);

            }

        }

        // Update IIOReadUpdateListeners, if any

        if (updateListeners != null) {

            int[] bands = { 0 };

            // updateYStep will have been initialized if

            // updateListeners is non-null

            processImageUpdate(theImage,

                               destX, destY,

                               width, 1, 1, updateYStep,

                               bands);

        }

    }

    private void computeDecodeThisRow() {

        this.decodeThisRow =

            (destY < destinationRegion.y + destinationRegion.height) &&

            (streamY >= sourceRegion.y) &&

            (streamY < sourceRegion.y + sourceRegion.height) &&

            (((streamY - sourceRegion.y) % sourceYSubsampling) == 0);

    }

    private void outputPixels(byte[] string, int len) {

        if (interlacePass < sourceMinProgressivePass ||

            interlacePass > sourceMaxProgressivePass) {

            return;

        }

        for (int i = 0; i < len; i++) {

            if (streamX >= sourceRegion.x) {

                rowBuf[streamX - sourceRegion.x] = string[i];

            }

            // Process end-of-row

            ++streamX;

            if (streamX == width) {

                // Update IIOReadProgressListeners

                ++rowsDone;

                processImageProgress(100.0F*rowsDone/height);

                if (decodeThisRow) {

                    outputRow();

                }

                streamX = 0;

                if (imageMetadata.interlaceFlag) {

                    streamY += interlaceIncrement[interlacePass];

                    if (streamY >= height) {

                        // Inform IIOReadUpdateListeners of end of pass

                        if (updateListeners != null) {

                            processPassComplete(theImage);

                        }

                        ++interlacePass;

                        if (interlacePass > sourceMaxProgressivePass) {

                            return;

                        }

                        streamY = interlaceOffset[interlacePass];

                        startPass(interlacePass);

                    }

                } else {

                    ++streamY;

                }

                // Determine whether pixels from this row will

                // be written to the destination

                this.destY = destinationRegion.y +

                    (streamY - sourceRegion.y)/sourceYSubsampling;

                computeDecodeThisRow();

            }

        }

    }

    // END LZW STUFF

    private void readHeader() throws IIOException {

        if (gotHeader) {

            return;

        }

        if (stream == null) {

            throw new IllegalStateException("Input not set!");

        }

        // Create an object to store the stream metadata

        this.streamMetadata = new GIFStreamMetadata();

        try {

            stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);

            byte[] signature = new byte[6];

            stream.readFully(signature);

            StringBuffer version = new StringBuffer(3);

            version.append((char)signature[3]);

            version.append((char)signature[4]);

            version.append((char)signature[5]);

            streamMetadata.version = version.toString();

            streamMetadata.logicalScreenWidth = stream.readUnsignedShort();

            streamMetadata.logicalScreenHeight = stream.readUnsignedShort();

            int packedFields = stream.readUnsignedByte();

            boolean globalColorTableFlag = (packedFields & 0x80) != 0;

            streamMetadata.colorResolution = ((packedFields >> 4) & 0x7) + 1;

            streamMetadata.sortFlag = (packedFields & 0x8) != 0;

            int numGCTEntries = 1 << ((packedFields & 0x7) + 1);

            streamMetadata.backgroundColorIndex = stream.readUnsignedByte();

            streamMetadata.pixelAspectRatio = stream.readUnsignedByte();

            if (globalColorTableFlag) {

                streamMetadata.globalColorTable = new byte[3*numGCTEntries];

                stream.readFully(streamMetadata.globalColorTable);

            } else {

                streamMetadata.globalColorTable = null;

            }

            // Found position of metadata for image 0

            imageStartPosition.add(Long.valueOf(stream.getStreamPosition()));

        } catch (IOException e) {

            throw new IIOException("I/O error reading header!", e);

        }

        gotHeader = true;

    }

    private boolean skipImage() throws IIOException {

        // Stream must be at the beginning of an image descriptor

        // upon exit

        try {

            while (true) {

                int blockType = stream.readUnsignedByte();

                if (blockType == 0x2c) {

                    stream.skipBytes(8);

                    int packedFields = stream.readUnsignedByte();

                    if ((packedFields & 0x80) != 0) {

                        // Skip color table if any