/*

 * 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.jpeg;

import javax.imageio.ImageTypeSpecifier;

import javax.imageio.ImageWriteParam;

import javax.imageio.IIOException;

import javax.imageio.stream.ImageInputStream;

import javax.imageio.stream.ImageOutputStream;

import javax.imageio.metadata.IIOMetadata;

import javax.imageio.metadata.IIOMetadataNode;

import javax.imageio.metadata.IIOMetadataFormat;

import javax.imageio.metadata.IIOMetadataFormatImpl;

import javax.imageio.metadata.IIOInvalidTreeException;

import javax.imageio.plugins.jpeg.JPEGQTable;

import javax.imageio.plugins.jpeg.JPEGHuffmanTable;

import javax.imageio.plugins.jpeg.JPEGImageWriteParam;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.NamedNodeMap;

import java.util.List;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.ListIterator;

import java.io.IOException;

import java.awt.color.ICC_Profile;

import java.awt.color.ICC_ColorSpace;

import java.awt.color.ColorSpace;

import java.awt.image.ColorModel;

import java.awt.Point;

/**

 * Metadata for the JPEG plug-in.

 */

public class JPEGMetadata extends IIOMetadata implements Cloneable {

    //////// Private variables

    private static final boolean debug = false;

    /**

     * A copy of <code>markerSequence</code>, created the first time the

     * <code>markerSequence</code> is modified.  This is used by reset

     * to restore the original state.

     */

    private List resetSequence = null;

    /**

     * Set to <code>true</code> when reading a thumbnail stored as

     * JPEG.  This is used to enforce the prohibition of JFIF thumbnails

     * containing any JFIF marker segments, and to ensure generation of

     * a correct native subtree during <code>getAsTree</code>.

     */

    private boolean inThumb = false;

    /**

     * Set by the chroma node construction method to signal the

     * presence or absence of an alpha channel to the transparency

     * node construction method.  Used only when constructing a

     * standard metadata tree.

     */

    private boolean hasAlpha;

    //////// end of private variables

    /////// Package-access variables

    /**

     * All data is a list of <code>MarkerSegment</code> objects.

     * When accessing the list, use the tag to identify the particular

     * subclass.  Any JFIF marker segment must be the first element

     * of the list if it is present, and any JFXX or APP2ICC marker

     * segments are subordinate to the JFIF marker segment.  This

     * list is package visible so that the writer can access it.

     * @see #MarkerSegment

     */

    List markerSequence = new ArrayList();

    /**

     * Indicates whether this object represents stream or image

     * metadata.  Package-visible so the writer can see it.

     */

    final boolean isStream;

    /////// End of package-access variables

    /////// Constructors

    /**

     * Constructor containing code shared by other constructors.

     */

    JPEGMetadata(boolean isStream, boolean inThumb) {

        super(true,  // Supports standard format

              JPEG.nativeImageMetadataFormatName,  // and a native format

              JPEG.nativeImageMetadataFormatClassName,

              null, null);  // No other formats

        this.inThumb = inThumb;

        // But if we are stream metadata, adjust the variables

        this.isStream = isStream;

        if (isStream) {

            nativeMetadataFormatName = JPEG.nativeStreamMetadataFormatName;

            nativeMetadataFormatClassName =

                JPEG.nativeStreamMetadataFormatClassName;

        }

    }

    /*

     * Constructs a <code>JPEGMetadata</code> object by reading the

     * contents of an <code>ImageInputStream</code>.  Has package-only

     * access.

     *

     * @param isStream A boolean indicating whether this object will be

     * stream or image metadata.

     * @param isThumb A boolean indicating whether this metadata object

     * is for an image or for a thumbnail stored as JPEG.

     * @param iis An <code>ImageInputStream</code> from which to read

     * the metadata.

     * @param reader The <code>JPEGImageReader</code> calling this

     * constructor, to which warnings should be sent.

     */

    JPEGMetadata(boolean isStream,

                 boolean isThumb,

                 ImageInputStream iis,

                 JPEGImageReader reader) throws IOException {

        this(isStream, isThumb);

        JPEGBuffer buffer = new JPEGBuffer(iis);

        buffer.loadBuf(0);

        // The first three bytes should be FF, SOI, FF

        if (((buffer.buf[0] & 0xff) != 0xff)

            || ((buffer.buf[1] & 0xff) != JPEG.SOI)

            || ((buffer.buf[2] & 0xff) != 0xff)) {

            throw new IIOException ("Image format error");

        }

        boolean done = false;

        buffer.bufAvail -=2;  // Next byte should be the ff before a marker

        buffer.bufPtr = 2;

        MarkerSegment newGuy = null;

        while (!done) {

            byte [] buf;

            int ptr;

            buffer.loadBuf(1);

            if (debug) {

                System.out.println("top of loop");

                buffer.print(10);

            }

            buffer.scanForFF(reader);

            switch (buffer.buf[buffer.bufPtr] & 0xff) {

            case 0:

                if (debug) {

                    System.out.println("Skipping 0");

                }

                buffer.bufAvail--;

                buffer.bufPtr++;

                break;

            case JPEG.SOF0:

            case JPEG.SOF1:

            case JPEG.SOF2:

                if (isStream) {

                    throw new IIOException

                        ("SOF not permitted in stream metadata");

                }

                newGuy = new SOFMarkerSegment(buffer);

                break;

            case JPEG.DQT:

                newGuy = new DQTMarkerSegment(buffer);

                break;

            case JPEG.DHT:

                newGuy = new DHTMarkerSegment(buffer);

                break;

            case JPEG.DRI:

                newGuy = new DRIMarkerSegment(buffer);

                break;

            case JPEG.APP0:

                // Either JFIF, JFXX, or unknown APP0

                buffer.loadBuf(8); // tag, length, id

                buf = buffer.buf;

                ptr = buffer.bufPtr;

                if ((buf[ptr+3] == 'J')

                    && (buf[ptr+4] == 'F')

                    && (buf[ptr+5] == 'I')

                    && (buf[ptr+6] == 'F')

                    && (buf[ptr+7] == 0)) {

                    if (inThumb) {

                        reader.warningOccurred

                            (JPEGImageReader.WARNING_NO_JFIF_IN_THUMB);

                        // Leave newGuy null

                        // Read a dummy to skip the segment

                        JFIFMarkerSegment dummy =

                            new JFIFMarkerSegment(buffer);

                    } else if (isStream) {

                        throw new IIOException

                            ("JFIF not permitted in stream metadata");

                    } else if (markerSequence.isEmpty() == false) {

                        throw new IIOException

                            ("JFIF APP0 must be first marker after SOI");

                    } else {

                        newGuy = new JFIFMarkerSegment(buffer);

                    }

                } else if ((buf[ptr+3] == 'J')

                           && (buf[ptr+4] == 'F')

                           && (buf[ptr+5] == 'X')

                           && (buf[ptr+6] == 'X')

                           && (buf[ptr+7] == 0)) {

                    if (isStream) {

                        throw new IIOException

                            ("JFXX not permitted in stream metadata");

                    }

                    if (inThumb) {

                        throw new IIOException

                          ("JFXX markers not allowed in JFIF JPEG thumbnail");

                    }

                    JFIFMarkerSegment jfif =

                        (JFIFMarkerSegment) findMarkerSegment

                               (JFIFMarkerSegment.class, true);

                    if (jfif == null) {

                        throw new IIOException

                            ("JFXX encountered without prior JFIF!");

                    }

                    jfif.addJFXX(buffer, reader);

                    // newGuy remains null

                } else {

                    newGuy = new MarkerSegment(buffer);

                    newGuy.loadData(buffer);

                }

                break;

            case JPEG.APP2:

                // Either an ICC profile or unknown APP2

                buffer.loadBuf(15); // tag, length, id

                if ((buffer.buf[buffer.bufPtr+3] == 'I')

                    && (buffer.buf[buffer.bufPtr+4] == 'C')

                    && (buffer.buf[buffer.bufPtr+5] == 'C')

                    && (buffer.buf[buffer.bufPtr+6] == '_')

                    && (buffer.buf[buffer.bufPtr+7] == 'P')

                    && (buffer.buf[buffer.bufPtr+8] == 'R')

                    && (buffer.buf[buffer.bufPtr+9] == 'O')

                    && (buffer.buf[buffer.bufPtr+10] == 'F')

                    && (buffer.buf[buffer.bufPtr+11] == 'I')

                    && (buffer.buf[buffer.bufPtr+12] == 'L')

                    && (buffer.buf[buffer.bufPtr+13] == 'E')

                    && (buffer.buf[buffer.bufPtr+14] == 0)

                    ) {

                    if (isStream) {

                        throw new IIOException

                            ("ICC profiles not permitted in stream metadata");

                    }

                    JFIFMarkerSegment jfif =

                        (JFIFMarkerSegment) findMarkerSegment

                        (JFIFMarkerSegment.class, true);

                    if (jfif == null) {

                        newGuy = new MarkerSegment(buffer);

                        newGuy.loadData(buffer);

                    } else {

                        jfif.addICC(buffer);

                    }

                    // newGuy remains null

                } else {

                    newGuy = new MarkerSegment(buffer);

                    newGuy.loadData(buffer);

                }

                break;

            case JPEG.APP14:

                // Either Adobe or unknown APP14

                buffer.loadBuf(8); // tag, length, id

                if ((buffer.buf[buffer.bufPtr+3] == 'A')

                    && (buffer.buf[buffer.bufPtr+4] == 'd')

                    && (buffer.buf[buffer.bufPtr+5] == 'o')

                    && (buffer.buf[buffer.bufPtr+6] == 'b')

                    && (buffer.buf[buffer.bufPtr+7] == 'e')) {

                    if (isStream) {

                        throw new IIOException

                      ("Adobe APP14 markers not permitted in stream metadata");

                    }

                    newGuy = new AdobeMarkerSegment(buffer);

                } else {

                    newGuy = new MarkerSegment(buffer);

                    newGuy.loadData(buffer);

                }

                break;

            case JPEG.COM:

                newGuy = new COMMarkerSegment(buffer);

                break;

            case JPEG.SOS:

                if (isStream) {

                    throw new IIOException

                        ("SOS not permitted in stream metadata");

                }

                newGuy = new SOSMarkerSegment(buffer);

                break;

            case JPEG.RST0:

            case JPEG.RST1:

            case JPEG.RST2:

            case JPEG.RST3:

            case JPEG.RST4:

            case JPEG.RST5:

            case JPEG.RST6:

            case JPEG.RST7:

                if (debug) {

                    System.out.println("Restart Marker");

                }

                buffer.bufPtr++; // Just skip it

                buffer.bufAvail--;

                break;

            case JPEG.EOI:

                done = true;

                buffer.bufPtr++;

                buffer.bufAvail--;

                break;

            default:

                newGuy = new MarkerSegment(buffer);

                newGuy.loadData(buffer);

                newGuy.unknown = true;

                break;

            }

            if (newGuy != null) {

                markerSequence.add(newGuy);

                if (debug) {

                    newGuy.print();

                }

                newGuy = null;

            }

        }

        // Now that we've read up to the EOI, we need to push back

        // whatever is left in the buffer, so that the next read

        // in the native code will work.

        buffer.pushBack();

        if (!isConsistent()) {

            throw new IIOException("Inconsistent metadata read from stream");

        }

    }

    /**

     * Constructs a default stream <code>JPEGMetadata</code> object appropriate

     * for the given write parameters.

     */

    JPEGMetadata(ImageWriteParam param, JPEGImageWriter writer) {

        this(true, false);

        JPEGImageWriteParam jparam = null;

        if ((param != null) && (param instanceof JPEGImageWriteParam)) {

            jparam = (JPEGImageWriteParam) param;

            if (!jparam.areTablesSet()) {

                jparam = null;

            }

        }

        if (jparam != null) {

            markerSequence.add(new DQTMarkerSegment(jparam.getQTables()));

            markerSequence.add

                (new DHTMarkerSegment(jparam.getDCHuffmanTables(),

                                      jparam.getACHuffmanTables()));

        } else {

            // default tables.

            markerSequence.add(new DQTMarkerSegment(JPEG.getDefaultQTables()));

            markerSequence.add(new DHTMarkerSegment(JPEG.getDefaultHuffmanTables(true),

                                                    JPEG.getDefaultHuffmanTables(false)));

        }

        // Defensive programming

        if (!isConsistent()) {

            throw new InternalError("Default stream metadata is inconsistent");

        }

    }

    /**

     * Constructs a default image <code>JPEGMetadata</code> object appropriate

     * for the given image type and write parameters.

     */

    JPEGMetadata(ImageTypeSpecifier imageType,

                 ImageWriteParam param,

                 JPEGImageWriter writer) {

        this(false, false);

        boolean wantJFIF = true;

        boolean wantAdobe = false;

        int transform = JPEG.ADOBE_UNKNOWN;

        boolean willSubsample = true;

        boolean wantICC = false;

        boolean wantProg = false;

        boolean wantOptimized = false;

        boolean wantExtended = false;

        boolean wantQTables = true;

        boolean wantHTables = true;

        float quality = JPEG.DEFAULT_QUALITY;

        byte[] componentIDs = { 1, 2, 3, 4};

        int numComponents = 0;

        ImageTypeSpecifier destType = null;

        if (param != null) {

            destType = param.getDestinationType();

            if (destType != null) {

                if (imageType != null) {

                    // Ignore the destination type.

                    writer.warningOccurred

                        (JPEGImageWriter.WARNING_DEST_IGNORED);

                    destType = null;

                }

            }

            // The only progressive mode that makes sense here is MODE_DEFAULT

            if (param.canWriteProgressive()) {

                // the param may not be one of ours, so it may return false.

                // If so, the following would throw an exception

                if (param.getProgressiveMode() == ImageWriteParam.MODE_DEFAULT) {

                    wantProg = true;

                    wantOptimized = true;

                    wantHTables = false;

                }

            }

            if (param instanceof JPEGImageWriteParam) {

                JPEGImageWriteParam jparam = (JPEGImageWriteParam) param;

                if (jparam.areTablesSet()) {

                    wantQTables = false;  // If the param has them, metadata shouldn't

                    wantHTables = false;

                    if ((jparam.getDCHuffmanTables().length > 2)

                            || (jparam.getACHuffmanTables().length > 2)) {

                        wantExtended = true;

                    }

                }

                // Progressive forces optimized, regardless of param setting

                // so consult the param re optimized only if not progressive

                if (!wantProg) {

                    wantOptimized = jparam.getOptimizeHuffmanTables();

                    if (wantOptimized) {

                        wantHTables = false;

                    }

                }

            }

            // compression quality should determine the q tables.  Note that this

            // will be ignored if we already decided not to create any.

            // Again, the param may not be one of ours, so we must check that it

            // supports compression settings

            if (param.canWriteCompressed()) {

                if (param.getCompressionMode() == ImageWriteParam.MODE_EXPLICIT) {

                    quality = param.getCompressionQuality();

                }

            }

        }

        // We are done with the param, now for the image types

        ColorSpace cs = null;

        if (destType != null) {

            ColorModel cm = destType.getColorModel();

            numComponents = cm.getNumComponents();

            boolean hasExtraComponents = (cm.getNumColorComponents() != numComponents);

            boolean hasAlpha = cm.hasAlpha();

            cs = cm.getColorSpace();

            int type = cs.getType();

            switch(type) {

            case ColorSpace.TYPE_GRAY:

                willSubsample = false;

                if (hasExtraComponents) {  // e.g. alpha

                    wantJFIF = false;

                }

                break;

            case ColorSpace.TYPE_3CLR:

                if (cs == JPEG.JCS.getYCC()) {

                    wantJFIF = false;

                    componentIDs[0] = (byte) 'Y';

                    componentIDs[1] = (byte) 'C';

                    componentIDs[2] = (byte) 'c';

                    if (hasAlpha) {

                        componentIDs[3] = (byte) 'A';

                    }

                }

                break;

            case ColorSpace.TYPE_YCbCr:

                if (hasExtraComponents) { // e.g. K or alpha

                    wantJFIF = false;

                    if (!hasAlpha) { // Not alpha, so must be K

                        wantAdobe = true;

                        transform = JPEG.ADOBE_YCCK;

                    }

                }

                break;

            case ColorSpace.TYPE_RGB:  // with or without alpha

                wantJFIF = false;

                wantAdobe = true;

                willSubsample = false;

                componentIDs[0] = (byte) 'R';

                componentIDs[1] = (byte) 'G';

                componentIDs[2] = (byte) 'B';

                if (hasAlpha) {

                    componentIDs[3] = (byte) 'A';

                }

                break;

            default:

                // Everything else is not subsampled, gets no special marker,

                // and component ids are 1 - N

                wantJFIF = false;