/*

 * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.

 * 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.imageio.plugins.tiff;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.color.ColorSpace;

import java.awt.color.ICC_ColorSpace;

import java.awt.color.ICC_Profile;

import java.awt.image.BufferedImage;

import java.awt.image.ColorModel;

import java.awt.image.ComponentColorModel;

import java.awt.image.Raster;

import java.awt.image.RenderedImage;

import java.awt.image.SampleModel;

import java.io.IOException;

import java.nio.ByteOrder;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import javax.imageio.IIOException;

import javax.imageio.ImageIO;

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 org.w3c.dom.Node;

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

import javax.imageio.plugins.tiff.BaselineTIFFTagSet;

import javax.imageio.plugins.tiff.TIFFField;

import javax.imageio.plugins.tiff.TIFFImageReadParam;

import javax.imageio.plugins.tiff.TIFFTagSet;

public class TIFFImageReader extends ImageReader {

    // A somewhat arbitrary upper bound on SamplesPerPixel. Hyperspectral

    // images as of this writing appear to be under 300 bands so this should

    // account for those cases should they arise.

    private static final int SAMPLES_PER_PIXEL_MAX = 1024;

    // In baseline TIFF the largest data types are 64-bit long and double.

    private static final int BITS_PER_SAMPLE_MAX = 64;

    // The current ImageInputStream source.

    private ImageInputStream stream = null;

    // True if the file header has been read.

    private boolean gotHeader = false;

    private ImageReadParam imageReadParam = getDefaultReadParam();

    // Stream metadata, or null.

    private TIFFStreamMetadata streamMetadata = null;

    // The current image index.

    private int currIndex = -1;

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

    private TIFFImageMetadata imageMetadata = null;

    // A <code>List</code> of <code>Long</code>s indicating the stream

    // positions of the start of the IFD for each image.  Entries

    // are added as needed.

    private List<Long> imageStartPosition = new ArrayList<Long>();

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

    private int numImages = -1;

    // The ImageTypeSpecifiers of the images in the stream.

    // Contains a map of Integers to Lists.

    private HashMap<Integer, List<ImageTypeSpecifier>> imageTypeMap

            = new HashMap<Integer, List<ImageTypeSpecifier>>();

    private BufferedImage theImage = null;

    private int width = -1;

    private int height = -1;

    private int numBands = -1;

    private int tileOrStripWidth = -1, tileOrStripHeight = -1;

    private int planarConfiguration = BaselineTIFFTagSet.PLANAR_CONFIGURATION_CHUNKY;

    private int compression;

    private int photometricInterpretation;

    private int samplesPerPixel;

    private int[] sampleFormat;

    private int[] bitsPerSample;

    private int[] extraSamples;

    private char[] colorMap;

    private int sourceXOffset;

    private int sourceYOffset;

    private int srcXSubsampling;

    private int srcYSubsampling;

    private int dstWidth;

    private int dstHeight;

    private int dstMinX;

    private int dstMinY;

    private int dstXOffset;

    private int dstYOffset;

    private int tilesAcross;

    private int tilesDown;

    private int pixelsRead;

    private int pixelsToRead;

    public TIFFImageReader(ImageReaderSpi originatingProvider) {

        super(originatingProvider);

    }

    public void setInput(Object input,

            boolean seekForwardOnly,

            boolean ignoreMetadata) {

        super.setInput(input, seekForwardOnly, ignoreMetadata);

        // Clear all local values based on the previous stream contents.

        resetLocal();

        if (input != null) {

            if (!(input instanceof ImageInputStream)) {

                throw new IllegalArgumentException("input not an ImageInputStream!");

            }

            this.stream = (ImageInputStream) input;

        } else {

            this.stream = null;

        }

    }

    // Do not seek to the beginning of the stream so as to allow users to

    // point us at an IFD within some other file format

    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 TIFFStreamMetadata();

        try {

            int byteOrder = stream.readUnsignedShort();

            if (byteOrder == 0x4d4d) {

                streamMetadata.byteOrder = ByteOrder.BIG_ENDIAN;

                stream.setByteOrder(ByteOrder.BIG_ENDIAN);

            } else if (byteOrder == 0x4949) {

                streamMetadata.byteOrder = ByteOrder.LITTLE_ENDIAN;

                stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);

            } else {

                processWarningOccurred(

                        "Bad byte order in header, assuming little-endian");

                streamMetadata.byteOrder = ByteOrder.LITTLE_ENDIAN;

                stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);

            }

            int magic = stream.readUnsignedShort();

            if (magic != 42) {

                processWarningOccurred(

                        "Bad magic number in header, continuing");

            }

            // Seek to start of first IFD

            long offset = stream.readUnsignedInt();

            imageStartPosition.add(Long.valueOf(offset));

            stream.seek(offset);

        } catch (IOException e) {

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

        }

        gotHeader = true;

    }

    private int locateImage(int imageIndex) throws IIOException {

        readHeader();

        try {

            // Find closest known index

            int index = Math.min(imageIndex, imageStartPosition.size() - 1);

            // Seek to that position

            Long l = imageStartPosition.get(index);

            stream.seek(l.longValue());

            // Skip IFDs until at desired index or last image found

            while (index < imageIndex) {

                int count = stream.readUnsignedShort();

                stream.skipBytes(12 * count);

                long offset = stream.readUnsignedInt();

                if (offset == 0) {

                    return index;

                }

                imageStartPosition.add(Long.valueOf(offset));

                stream.seek(offset);

                ++index;

            }

        } catch (IOException e) {

            throw new IIOException("Couldn't seek!", e);

        }

        if (currIndex != imageIndex) {

            imageMetadata = null;

        }

        currIndex = imageIndex;

        return imageIndex;

    }

    public int getNumImages(boolean allowSearch) throws IOException {

        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;

    }

    public IIOMetadata getStreamMetadata() throws IIOException {

        readHeader();

        return streamMetadata;

    }

    // 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;

        }

    }

    // Verify that imageIndex is in bounds, find the image IFD, read the

    // image metadata, initialize instance variables from the metadata.

    private void seekToImage(int imageIndex) throws IIOException {

        checkIndex(imageIndex);

        int index = locateImage(imageIndex);

        if (index != imageIndex) {

            throw new IndexOutOfBoundsException("imageIndex out of bounds!");

        }

        readMetadata();

        initializeFromMetadata();

    }

    // Stream must be positioned at start of IFD for 'currIndex'

    private void readMetadata() throws IIOException {

        if (stream == null) {

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

        }

        if (imageMetadata != null) {

            return;

        }

        try {

            // Create an object to store the image metadata

            List<TIFFTagSet> tagSets;

            if (imageReadParam instanceof TIFFImageReadParam) {

                tagSets

                        = ((TIFFImageReadParam) imageReadParam).getAllowedTagSets();

            } else {

                tagSets = new ArrayList<TIFFTagSet>(1);

                tagSets.add(BaselineTIFFTagSet.getInstance());

            }

            this.imageMetadata = new TIFFImageMetadata(tagSets);

            imageMetadata.initializeFromStream(stream, ignoreMetadata);

        } catch (IIOException iioe) {

            throw iioe;

        } catch (IOException ioe) {

            throw new IIOException("I/O error reading image metadata!", ioe);

        }

    }

    private int getWidth() {

        return this.width;

    }

    private int getHeight() {

        return this.height;

    }

    // Returns tile width if image is tiled, else image width

    private int getTileOrStripWidth() {

        TIFFField f

                = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_TILE_WIDTH);

        return (f == null) ? getWidth() : f.getAsInt(0);

    }

    // Returns tile height if image is tiled, else strip height

    private int getTileOrStripHeight() {

        TIFFField f

                = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_TILE_LENGTH);

        if (f != null) {

            return f.getAsInt(0);

        }

        f = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_ROWS_PER_STRIP);

        // Default for ROWS_PER_STRIP is 2^32 - 1, i.e., infinity

        int h = (f == null) ? -1 : f.getAsInt(0);

        return (h == -1) ? getHeight() : h;

    }

    private int getPlanarConfiguration() {

        TIFFField f

                = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_PLANAR_CONFIGURATION);

        if (f != null) {

            int planarConfigurationValue = f.getAsInt(0);

            if (planarConfigurationValue

                    == BaselineTIFFTagSet.PLANAR_CONFIGURATION_PLANAR) {

                // Some writers (e.g. Kofax standard Multi-Page TIFF

                // Storage Filter v2.01.000; cf. bug 4929147) do not

                // correctly set the value of this field. Attempt to

                // ascertain whether the value is correctly Planar.

                if (getCompression()

                        == BaselineTIFFTagSet.COMPRESSION_OLD_JPEG

                        && imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT)

                        != null) {

                    // JPEG interchange format cannot have

                    // PlanarConfiguration value Chunky so reset.

                    processWarningOccurred("PlanarConfiguration \"Planar\" value inconsistent with JPEGInterchangeFormat; resetting to \"Chunky\".");

                    planarConfigurationValue

                            = BaselineTIFFTagSet.PLANAR_CONFIGURATION_CHUNKY;

                } else {

                    TIFFField offsetField

                            = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_TILE_OFFSETS);

                    if (offsetField == null) {

                        // Tiles

                        offsetField

                                = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_STRIP_OFFSETS);

                        int tw = getTileOrStripWidth();

                        int th = getTileOrStripHeight();

                        int tAcross = (getWidth() + tw - 1) / tw;

                        int tDown = (getHeight() + th - 1) / th;

                        int tilesPerImage = tAcross * tDown;

                        long[] offsetArray = offsetField.getAsLongs();

                        if (offsetArray != null

                                && offsetArray.length == tilesPerImage) {

                            // Length of offsets array is

                            // TilesPerImage for Chunky and

                            // SamplesPerPixel*TilesPerImage for Planar.

                            processWarningOccurred("PlanarConfiguration \"Planar\" value inconsistent with TileOffsets field value count; resetting to \"Chunky\".");

                            planarConfigurationValue

                                    = BaselineTIFFTagSet.PLANAR_CONFIGURATION_CHUNKY;

                        }

                    } else {

                        // Strips

                        int rowsPerStrip = getTileOrStripHeight();

                        int stripsPerImage

                                = (getHeight() + rowsPerStrip - 1) / rowsPerStrip;

                        long[] offsetArray = offsetField.getAsLongs();

                        if (offsetArray != null

                                && offsetArray.length == stripsPerImage) {

                            // Length of offsets array is

                            // StripsPerImage for Chunky and

                            // SamplesPerPixel*StripsPerImage for Planar.

                            processWarningOccurred("PlanarConfiguration \"Planar\" value inconsistent with StripOffsets field value count; resetting to \"Chunky\".");

                            planarConfigurationValue

                                    = BaselineTIFFTagSet.PLANAR_CONFIGURATION_CHUNKY;

                        }

                    }

                }

            }

            return planarConfigurationValue;

        }

        return BaselineTIFFTagSet.PLANAR_CONFIGURATION_CHUNKY;

    }

    private long getTileOrStripOffset(int tileIndex) throws IIOException {

        TIFFField f

                = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_TILE_OFFSETS);

        if (f == null) {

            f = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_STRIP_OFFSETS);

        }

        if (f == null) {

            f = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT);

        }

        if (f == null) {

            throw new IIOException("Missing required strip or tile offsets field.");

        }

        return f.getAsLong(tileIndex);

    }

    private long getTileOrStripByteCount(int tileIndex) throws IOException {

        TIFFField f

                = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_TILE_BYTE_COUNTS);

        if (f == null) {

            f

                    = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_STRIP_BYTE_COUNTS);

        }

        if (f == null) {

            f = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);

        }

        long tileOrStripByteCount;

        if (f != null) {

            tileOrStripByteCount = f.getAsLong(tileIndex);

        } else {

            processWarningOccurred("TIFF directory contains neither StripByteCounts nor TileByteCounts field: attempting to calculate from strip or tile width and height.");

            // Initialize to number of bytes per strip or tile assuming

            // no compression.

            int bitsPerPixel = bitsPerSample[0];

            for (int i = 1; i < samplesPerPixel; i++) {

                bitsPerPixel += bitsPerSample[i];

            }

            int bytesPerRow = (getTileOrStripWidth() * bitsPerPixel + 7) / 8;

            tileOrStripByteCount = bytesPerRow * getTileOrStripHeight();

            // Clamp to end of stream if possible.

            long streamLength = stream.length();

            if (streamLength != -1) {

                tileOrStripByteCount

                        = Math.min(tileOrStripByteCount,

                                streamLength - getTileOrStripOffset(tileIndex));

            } else {

                processWarningOccurred("Stream length is unknown: cannot clamp estimated strip or tile byte count to EOF.");

            }

        }

        return tileOrStripByteCount;

    }

    private int getCompression() {

        TIFFField f

                = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_COMPRESSION);

        if (f == null) {

            return BaselineTIFFTagSet.COMPRESSION_NONE;

        } else {

            return f.getAsInt(0);

        }

    }

    public int getWidth(int imageIndex) throws IOException {

        seekToImage(imageIndex);

        return getWidth();

    }

    public int getHeight(int imageIndex) throws IOException {

        seekToImage(imageIndex);

        return getHeight();

    }

    /**

     * Initializes these instance variables from the image metadata:

     * <pre>

     * compression

     * width

     * height

     * samplesPerPixel

     * numBands

     * colorMap

     * photometricInterpretation

     * sampleFormat

     * bitsPerSample

     * extraSamples

     * tileOrStripWidth

     * tileOrStripHeight

     * </pre>

     */

    private void initializeFromMetadata() throws IIOException {

        TIFFField f;

        // Compression

        f = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_COMPRESSION);

        if (f == null) {

            processWarningOccurred("Compression field is missing; assuming no compression");

            compression = BaselineTIFFTagSet.COMPRESSION_NONE;

        } else {

            compression = f.getAsInt(0);

        }

        // Whether key dimensional information is absent.

        boolean isMissingDimension = false;

        // ImageWidth -> width

        f = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_IMAGE_WIDTH);

        if (f != null) {

            this.width = f.getAsInt(0);

        } else {

            processWarningOccurred("ImageWidth field is missing.");

            isMissingDimension = true;

        }

        // ImageLength -> height

        f = imageMetadata.getTIFFField(BaselineTIFFTagSet.TAG_IMAGE_LENGTH);

        if (f != null) {